feat(project): 为项目活动时间线添加成员角色名称显示功能

- 在 ObjectActivityConstants 中添加 MEMBER_ACTION_UPDATE 类型支持 - 为 ProductActivityQueryService 和 ProductActivityTimelineQueryService 添加角色名称加载和缓存功能 - 实现角色名称解析和 JSON 数据结构扩展 - 添加相关单元测试验证角色名称显示逻辑 - 集成 ObjectPermissionApi 获取角色信息并实现缓存机制
feat(project): 新增产品动态时间线接口并重构活动查询逻辑
2026-04-24 16:22:23 +08:00 · 2026-04-24 15:43:38 +08:00 · 2026-04-23 09:23:33 +08:00 · 2026-04-23 09:22:43 +08:00 · 2026-04-22 18:18:38 +08:00 · 2026-04-22 14:38:41 +08:00
161 changed files with 10420 additions and 1130 deletions
--- a/.m2-temp/com/njcn/njcn-dependencies-bom-jdk17/1.0.0/njcn-dependencies-bom-jdk17-1.0.0.pom.lastUpdated
+++ b/.m2-temp/com/njcn/njcn-dependencies-bom-jdk17/1.0.0/njcn-dependencies-bom-jdk17-1.0.0.pom.lastUpdated
@@ -0,0 +1,4 @@
+#NOTE: This is a Maven Resolver internal implementation file, its format can be changed without prior notice.
+#Tue Apr 21 08:50:58 CST 2026
+https\://maven.aliyun.com/repository/public/.lastUpdated=1776732658408
+https\://maven.aliyun.com/repository/public/.error=
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -0,0 +1,239 @@
+# AGENTS.md
+
+## 适用范围
+
+本说明适用于以 `C:\code\gitea\rdms\cn-rdms` 为根目录的整个仓库。
+
+描述仓库现状时，以当前代码、当前配置、当前文档中可直接验证的事实为准；除非用户明确要求，不引入历史实现、过渡方案或已废弃模型来解释当前状态。
+
+默认回答保持精简，优先给结论、改动点和必要风险，不做过多展开；如果存在你关心但未展开的细节，由你继续追问后再补充。
+
+## 交互原则
+
+- 默认先给执行方案，说明目标、涉及模块、预计改动点和验证方式。
+- 在用户评审并明确同意前，不直接开始实际修改、编译、测试、打包或其他执行动作。
+- 是否执行由用户决定；如果用户只要求分析、审阅或出方案，就停留在分析和方案层。
+
+## 项目概览
+
+这是一个面向 RDMS 服务的多模块 Maven 单仓库项目。
+
+- Java 版本：17
+- 构建工具：Maven
+- 根模块打包类型：`pom`
+- Spring Boot 版本：`3.5.9`
+
+## 本地环境约定
+
+- 本机 Maven 安装路径：`C:\software\apache-maven-3.8.9`
+- 如需执行 Maven 命令，优先使用完整路径：`C:\software\apache-maven-3.8.9\bin\mvn.cmd`
+- 不要假设 `mvn` 已加入 PATH
+- 只有在用户已明确同意执行编译、测试、打包等 Maven 命令时，才使用上述路径执行
+
+顶层模块：
+
+1. `rdms-system`
+2. `rdms-project`
+3. `rdms-framework`
+4. `rdms-gateway`
+
+当前系统域能力主要集中在 `rdms-system`，RDMS 核心交付域能力主要集中在 `rdms-project`，但这只是现阶段结构，不应被理解为长期只保留这两个业务模块。
+
+后续如果新增独立业务服务，例如项目/产品管理模块、工作流模块，应继续沿用当前仓库的模块拆分方式，而不是把所有后续业务长期堆进 `rdms-system`。
+
+## 模块说明
+
+### `rdms-system`
+
+当前已存在的系统业务聚合模块。
+
+- `rdms-system/rdms-system-boot`
+  - 主应用模块
+  - 启动入口：`rdms-system/rdms-system-boot/src/main/java/com/njcn/rdms/module/system/SystemServerApplication.java`
+  - 主包路径：`com.njcn.rdms.module.system`
+  - 常见子包：`api`、`controller`、`convert`、`dal`、`framework`、`job`、`service`、`util`、`websocket`
+- `rdms-system/rdms-system-api`
+  - 供其他服务依赖的共享 API 模块
+  - 包含对外 API 契约与枚举定义
+
+说明：
+
+- 当前权限、用户、组织、岗位、菜单、角色等系统核心能力主要落在这里。
+- 如果后续只是给系统域补充新的系统子能力，可以继续在 `rdms-system` 内按现有结构扩展。
+- 如果后续形成独立业务域，例如 `rdms-project`、`rdms-workflow`，应优先建设为新的独立业务模块，而不是默认继续塞进 `rdms-system`。
+
+### `rdms-project`
+
+当前已存在的 RDMS 核心交付业务聚合模块。
+
+- `rdms-project/rdms-project-boot`
+  - 主应用模块
+  - 启动入口：`rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/ProjectServerApplication.java`
+  - 主包路径：`com.njcn.rdms.module.project`
+  - 常见子包：`api`、`controller`、`convert`、`dal`、`framework`、`service`
+- `rdms-project/rdms-project-api`
+  - 供其他服务依赖的共享 API 模块
+  - 包含对外 API 契约与枚举定义
+
+说明：
+
+- 当前项目集、项目、产品、需求、任务、工单、执行等 RDMS 核心业务能力应优先落在这里。
+- 需要复用用户、组织、岗位、权限等系统能力时，应通过 `rdms-system-api` 调用，不要反向依赖 `rdms-system-boot`。
+
+### `rdms-framework`
+
+共享框架与内部 starter 模块。
+
+- `rdms-framework/rdms-common`
+  - 核心通用工具与公共抽象
+- 其他 `rdms-spring-boot-starter-*` 模块
+  - 内部 starter，覆盖 `env`、`web`、`rpc`、`security`、`mybatis`、`redis`、`mq`、`websocket`、`excel`、`protection`、`test`、`biz-ip`
+
+### `rdms-gateway`
+
+Spring Cloud Gateway 网关服务。
+
+- 启动入口：`rdms-gateway/src/main/java/com/njcn/rdms/gateway/GatewayServerApplication.java`
+- 主包路径：`com.njcn.rdms.gateway`
+- 常见子包：`filter`、`handler`、`jackson`、`route`、`util`
+
+## 模块演进约束
+
+后续新增业务能力时，先区分下面两种情况，不要混用：
+
+1. 新增独立微服务模块，例如 `rdms-project`、`rdms-workflow`
+2. 只是在现有 `rdms-system` 中新增一个业务子域
+
+### 新增独立微服务模块
+
+如果后续能力已经具备独立服务边界，应优先按下面结构建设：
+
+```text
+rdms-xxx
+├─ rdms-xxx-api
+└─ rdms-xxx-boot
+```
+
+约束：
+
+- 根 `pom.xml` 增加新的聚合模块
+- `api` 模块承载对外 RPC/Feign 接口、DTO、错误码、枚举、常量
+- `boot` 模块承载启动类、controller、service、dal、convert、api 实现、模块级 framework 配置和资源文件
+- 包路径、`spring.application.name`、`ApiConstants`、`RpcConstants`、`rdms.info.base-package` 必须保持一致
+- 新服务不是简单复制 `rdms-system` 的名字，而是复用它的工程骨架和分层习惯
+
+### 在 `rdms-system` 中新增业务子域
+
+如果只是给系统服务补一个当前阶段仍适合放在 `rdms-system` 内的子域，则继续沿用现有结构：
+
+- `controller/admin/...` 或 `controller/app/...`
+- `service/...`
+- `dal/dataobject/...`
+- `dal/mysql/...`
+- `convert/...`
+- 需要跨模块暴露时，在 `rdms-system-api` 中补 API、DTO、错误码、枚举
+
+约束：
+
+- 不要为了新增子域引入一套平行的 `application/domain/infrastructure/adapter` 分层语言
+- 不要让外部模块直接依赖 `rdms-system-boot` 的 service 或 mapper
+- 如果某项能力未来明显会演进成独立微服务，文档和实现上都要避免把它写死成只能存在于 `rdms-system`
+
+## 代码目录
+
+- Java 源码：`*/src/main/java`
+- 资源文件：`*/src/main/resources`
+- 测试代码：`*/src/test/java`
+- 本地辅助脚本：`scripts/`
+
+## 分层职责约束
+
+### `rdms-framework`
+
+- `rdms-framework` 承担基础能力，不承载具体业务语义。
+- 除非出现框架级缺陷，或该能力明确属于全局可复用基础设施，否则不要把业务判断硬塞进 framework。
+
+### `rdms-gateway`
+
+- `rdms-gateway` 只负责统一入口、令牌校验、登录用户透传、路由和网关层横切逻辑。
+- 不要在 gateway 层承载组织、成员、负责人、项目、产品、工作流状态流转或数据可见性这类业务语义。
+
+### Controller 层
+
+- Controller 负责 HTTP 暴露、参数校验、权限注解、结果封装。
+- 不要在 controller 中直接编排复杂业务流程，也不要直接操作多个 mapper 拼装业务规则。
+- 请求和响应对象优先沿用 `ReqVO`、`RespVO` 风格，不要直接把 DO 暴露给前端。
+
+### Service 层
+
+- 核心业务规则、事务、缓存、领域编排应落在 service 层。
+- 如果是已有领域增强，优先在现有 service 下扩展，不要为了“看起来更整齐”平移整套代码。
+- 不要把复杂规则散落到 controller、mapper 或 `util` 中。
+
+### DAL 层
+
+- 新表应有对应的 DO 和 Mapper。
+- Mapper 优先继承 `BaseMapperX<T>`，不要重复写样板 CRUD。
+- 查询条件优先沿用 `LambdaQueryWrapperX`、默认方法封装和现有 MyBatis Plus 风格，不要无必要回退到 XML。
+- Mapper 以查询封装为主，不承担领域校验职责。
+
+### Convert 层
+
+- 如果某个领域已经有 `convert` 风格，则继续沿用。
+- 简单场景允许直接使用 `BeanUtils`。
+- 不要为了统一而强推所有地方都改成 MapStruct，也不要反过来把已有 convert 全部删掉。
+
+## 认证与共享调用约束
+
+- 默认沿用现有 OAuth2 / Token / `LoginUser` / `login-user` 透传主链，不要另造一套认证上下文体系。
+- 不要额外发明 ThreadLocal、Session 或自定义 header 体系替代当前登录态恢复方式。
+- 接口级权限判断默认沿用 `@PreAuthorize("@ss.hasPermission(...)")` 这条链路，不要绕开现有权限框架另起一套实现。
+- 跨模块、跨服务访问能力时，优先通过对应的 `*-api` 模块定义 API、DTO、常量和枚举。
+- 不要让外部模块直接依赖某个 `*-boot` 模块的 service 或 mapper。
+
+## 数据与 SQL 约束
+
+- 新增业务表的 DO 优先复用当前 `BaseDO` / 审计字段风格；除非表本身明确不需要逻辑删除，不要再引入另一套审计基类。
+- 不要假设运行时存在自动数据库迁移；如果代码依赖新表、新字段或新索引，必须同步补齐对应 SQL 与文档说明。
+- SQL 脚本应放在目标模块的 `src/main/resources/sql/...` 下，并保持可审阅、可单独执行、语义清晰。
+- 变更缓存、日志、审计相关逻辑时，优先沿用现有机制，不要绕开现有登录上下文、缓存约定和审计字段填充方式。
+
+## 注释与编码
+
+- 新增或修改代码时，关键字段、关键分支、关键约束和非直观实现应补充简洁中文注释。
+- 不要为了省事删除原有有效注释，也不要添加无信息量的注释。
+- 写入中文内容时必须保持 UTF-8 编码，并自行检查中文显示是否正常；不要用“改成英文”规避乱码问题。
+- 使用 superpowers 产出的功能文档时，例如设计文档、实施计划、联调说明，除非用户明确要求，否则默认用中文落地；代码标识、文件路径、接口路径、SQL、命令保持原始技术标识，不做意译。
+
+## 工作规则
+
+1. 除非任务明确要求修改共享契约或 starter，否则优先进行有边界的模块内改动，避免跨模块扩散。
+2. 业务逻辑应放在对应业务模块的 `*-boot` 实现模块；可复用契约放在对应的 `*-api` 模块；可复用框架能力放在 `rdms-framework`。
+3. 除非任务本身就是环境配置调整，否则避免修改 `application-local.yaml` 和 `application-dev.yaml`。
+4. 将本地资源 YAML 视为可能带有机器环境差异的文件；修改前先检查 git 状态。
+5. 保持既有包结构约定不变：
+   - 控制器放在 `controller`
+   - 服务层放在 `service`
+   - 持久层放在 `dal`
+   - DTO/VO 转换放在 `convert`
+6. 当前系统域代码主要在 `rdms-system`，RDMS 核心交付域代码主要在 `rdms-project`，但这不是永久约束；新增业务能力时，先判断应该落在现有系统域内、现有项目交付域内，还是应建设为新的 `rdms-xxx` 业务模块。
+7. 新增共享能力时，优先扩展现有 `rdms-spring-boot-starter-*` 模块，不要在业务服务里重复堆配置。
+8. 修改跨模块使用的 API 时，需要同时更新提供方实现和对应的 `rdms-system-api` 或对应 `rdms-xxx-api` 契约。
+9. 除非用户明确要求，否则不执行任何编译、构建、测试、打包或其他会实际运行项目的命令，包括但不限于 `mvn`、启动命令和脚本。
+
+## 测试指引
+
+先定义验证方式，再实施修改。默认通过以下方式验证：
+
+- 代码路径是否闭环，调用链是否与模块边界一致
+- 配置项、接口契约、权限标识、路由或资源注册是否前后一致
+- 改动范围是否控制在当前任务所需的最小集合内
+- 受影响的文档、SQL、配置或接口说明是否需要同步更新
+
+如果任务影响了 Spring 配置、序列化、安全、路由、RPC 契约、MyBatis 行为或跨模块 API，一律明确说明哪些部分已静态检查、哪些部分尚未实际运行验证。
+
+## 给后续 Agent 的说明
+
+- 仓库中可能存在未提交的本地配置改动，不要覆盖与当前任务无关的编辑。
+- `docs/` 目录属于当前工作上下文的一部分，不是归档材料；做架构级修改前先查阅。
+- 根目录 `pom.xml` 负责统一版本和依赖对齐；涉及版本调整时，优先修改根 `pom.xml`，不要散落到子模块中。
--- a/pom.xml
+++ b/pom.xml
@@ -9,6 +9,7 @@
    <packaging>pom</packaging>
    <modules>
        <module>rdms-system</module>
+        <module>rdms-project</module>
        <module>rdms-framework</module>
        <module>rdms-gateway</module>
    </modules>
@@ -118,6 +119,15 @@
                <artifactId>rdms-spring-boot-starter-websocket</artifactId>
                <version>${revision}</version>
            </dependency>
+
+            <!-- 热部署依赖-->
+            <dependency>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-devtools</artifactId>
+                <version>${spring.boot.version}</version>
+                <scope>runtime</scope>
+                <optional>true</optional>
+            </dependency>
        </dependencies>
    </dependencyManagement>

--- a/rdms-framework/rdms-common/src/main/java/com/njcn/rdms/framework/common/enums/RpcConstants.java
+++ b/rdms-framework/rdms-common/src/main/java/com/njcn/rdms/framework/common/enums/RpcConstants.java
@@ -26,5 +26,17 @@ public interface RpcConstants {
     */
    String SYSTEM_PREFIX = RPC_API_PREFIX + "/system";

+    /**
+     * project 服务名
+     *
+     * 注意，需要保证和 spring.application.name 保持一致
+     */
+    String PROJECT_NAME = "rdms-project-server";
+
+    /**
+     * project 服务的前缀
+     */
+    String PROJECT_PREFIX = RPC_API_PREFIX + "/project";
+

 }
--- a/rdms-framework/rdms-spring-boot-starter-env/src/main/java/com/njcn/rdms/framework/env/core/package-info.java
+++ b/rdms-framework/rdms-spring-boot-starter-env/src/main/java/com/njcn/rdms/framework/env/core/package-info.java
@@ -0,0 +1 @@
+package com.njcn.rdms.framework.env.core;
--- a/rdms-framework/rdms-spring-boot-starter-excel/src/main/java/com/njcn/rdms/framework/dict/validation/InDictCollectionValidator.java
+++ b/rdms-framework/rdms-spring-boot-starter-excel/src/main/java/com/njcn/rdms/framework/dict/validation/InDictCollectionValidator.java
@@ -10,6 +10,8 @@ import java.util.List;

 public class InDictCollectionValidator implements ConstraintValidator<InDict, Collection<?>> {

+    private static final String MISSING_DICT_DATA_MESSAGE = "字典数据缺失，请联系管理员维护";
+
    private String dictType;

    @Override
@@ -25,6 +27,12 @@ public class InDictCollectionValidator implements ConstraintValidator<InDict, Co
        }
        // 校验全部通过
        List<String> dbValues = DictFrameworkUtils.getDictDataValueList(dictType);
+        if (dbValues.isEmpty()) {
+            context.disableDefaultConstraintViolation();
+            context.buildConstraintViolationWithTemplate(MISSING_DICT_DATA_MESSAGE)
+                    .addConstraintViolation();
+            return false;
+        }
        boolean match = list.stream().allMatch(v -> dbValues.stream()
                .anyMatch(dbValue -> dbValue.equalsIgnoreCase(v.toString())));
        if (match) {
@@ -40,4 +48,3 @@ public class InDictCollectionValidator implements ConstraintValidator<InDict, Co
    }

 }
-
--- a/rdms-framework/rdms-spring-boot-starter-excel/src/main/java/com/njcn/rdms/framework/dict/validation/InDictValidator.java
+++ b/rdms-framework/rdms-spring-boot-starter-excel/src/main/java/com/njcn/rdms/framework/dict/validation/InDictValidator.java
@@ -9,6 +9,8 @@ import java.util.List;

 public class InDictValidator implements ConstraintValidator<InDict, Object> {

+    private static final String MISSING_DICT_DATA_MESSAGE = "字典数据缺失，请联系管理员维护";
+
    private String dictType;

    @Override
@@ -24,6 +26,12 @@ public class InDictValidator implements ConstraintValidator<InDict, Object> {
        }
        // 校验通过
        final List<String> values = DictFrameworkUtils.getDictDataValueList(dictType);
+        if (values.isEmpty()) {
+            context.disableDefaultConstraintViolation();
+            context.buildConstraintViolationWithTemplate(MISSING_DICT_DATA_MESSAGE)
+                    .addConstraintViolation();
+            return false;
+        }
        boolean match = values.stream().anyMatch(v -> StrUtil.equalsIgnoreCase(v, value.toString()));
        if (match) {
            return true;
@@ -38,4 +46,3 @@ public class InDictValidator implements ConstraintValidator<InDict, Object> {
    }

 }
-
--- a/rdms-gateway/src/main/resources/application-dev.yaml
+++ b/rdms-gateway/src/main/resources/application-dev.yaml
@@ -6,10 +6,10 @@ spring:
      username: # Nacos 账号
      password: # Nacos 密码
      discovery: # 【配置中心】配置项
-        namespace: 1e0fcd92-49b4-4cda-b531-828c7d36fef5 # 命名空间。这里使用 dev 开发环境
+        namespace: dev # 命名空间。这里使用 dev 开发环境
        group: DEFAULT_GROUP # 使用的 Nacos 配置分组，默认为 DEFAULT_GROUP
      config: # 【注册中心】配置项
-        namespace: 1e0fcd92-49b4-4cda-b531-828c7d36fef5 # 命名空间。这里使用 dev 开发环境
+        namespace: dev # 命名空间。这里使用 dev 开发环境
        group: DEFAULT_GROUP # 使用的 Nacos 配置分组，默认为 DEFAULT_GROUP

 #################### 监控相关配置 ####################
--- a/rdms-gateway/src/main/resources/application-local.yaml
+++ b/rdms-gateway/src/main/resources/application-local.yaml
@@ -6,10 +6,10 @@ spring:
      username: # Nacos 账号
      password: # Nacos 密码
      discovery: # 【配置中心】配置项
-        namespace: 1e0fcd92-49b4-4cda-b531-828c7d36fef5 # 命名空间。这里使用 dev 开发环境
+        namespace: dev # 命名空间。这里使用 dev 开发环境
        group: DEFAULT_GROUP # 使用的 Nacos 配置分组，默认为 DEFAULT_GROUP
      config: # 【注册中心】配置项
-        namespace: 1e0fcd92-49b4-4cda-b531-828c7d36fef5 # 命名空间。这里使用 dev 开发环境
+        namespace: dev # 命名空间。这里使用 dev 开发环境
        group: DEFAULT_GROUP # 使用的 Nacos 配置分组，默认为 DEFAULT_GROUP

 #################### 监控相关配置 ####################
--- a/rdms-gateway/src/main/resources/application.yaml
+++ b/rdms-gateway/src/main/resources/application.yaml
@@ -49,6 +49,19 @@ spring:
              uri: grayLb://rdms-system-server
              predicates: # 断言，作为路由的匹配条件，对应 RouteDefinition 数组
                - Path=/system/ws/**
+            ## project-server 服务
+            - id: project-admin-api # 路由的编号
+              uri: grayLb://rdms-project-server
+              predicates: # 断言，作为路由的匹配条件，对应 RouteDefinition 数组
+                - Path=/admin-api/project/**
+              filters:
+                  - RewritePath=/admin-api/project/v3/api-docs, /v3/api-docs
+            - id: project-app-api # 路由的编号
+              uri: grayLb://rdms-project-server
+              predicates: # 断言，作为路由的匹配条件，对应 RouteDefinition 数组
+                - Path=/app-api/project/**
+              filters:
+                  - RewritePath=/app-api/project/v3/api-docs, /v3/api-docs
            ## bpm-server 服务
            - id: bpm-admin-api # 路由的编号
              uri: grayLb://rdms-bpm-server
@@ -76,6 +89,9 @@ knife4j:
      - name: system-server
        service-name: rdms-system-server
        url: /admin-api/system/v3/api-docs
+      - name: project-server
+        service-name: rdms-project-server
+        url: /admin-api/project/v3/api-docs
      - name: bpm-server
        service-name: bpm-server
        url: /admin-api/bpm/v3/api-docs
--- a/rdms-project/2026-04-23-product-activity-timeline-api-design.md
+++ b/rdms-project/2026-04-23-product-activity-timeline-api-design.md
@@ -0,0 +1,270 @@
+# 产品动态时间线后端接口需求说明
+
+日期：2026-04-23
+
+## 1. 背景
+
+当前产品对象首页中的“产品动态时间线”模块，用户期望不是展示几条前端拼装的摘要，而是一个可以在首页内直接查询的正式动态模块。
+
+本轮已确认的目标能力包括：
+
+- 首页内直接展示产品动态时间线
+- 默认查询最近 `30 天`
+- 支持自定义起止时间筛选
+- 支持事件类型多选筛选
+- 支持分页
+- 第一版事件范围收敛在产品对象与团队关系，不混入需求池事件
+
+## 2. 当前前端现状
+
+当前前端可直接使用的真实接口只有：
+
+- `GET /project/product/get`
+- `GET /project/product/{id}/settings`
+- `GET /project/product/{id}/members`
+
+这些接口目前只能提供：
+
+- 产品当前状态
+- 最近一次状态原因
+- 产品经理
+- 成员加入时间
+- 成员退出时间
+- 当前成员角色
+
+它们可以勉强拼出少量“最近动态摘要”，但不足以支撑正式时间线查询模块。
+
+## 3. 当前接口为什么不够
+
+如果继续只依赖现有接口，前端存在以下硬缺口：
+
+1. 没有统一的产品动态分页接口
+2. 没有事件类型维度，无法支持类型筛选
+3. 没有统一发生时间字段集合，无法稳定支持时间筛选
+4. 没有事件操作人字段，无法明确展示“谁做了什么”
+5. 没有统一的事件摘要字段，前端只能自己硬拼文案
+6. 没有产品状态变更前后值，无法展示“从什么状态变更为什么状态”
+7. 没有产品经理变更前后值，无法展示交接关系
+8. 没有分页总数字段，无法做首页内翻页
+
+因此，现有接口只适合做“概览摘要”，不适合做“可查询产品动态时间线”。
+
+## 4. 后端接口交付要求
+
+后端必须新增一条专用分页接口：
+
+`GET /project/product/{id}/activities/page`
+
+这条接口只服务“产品动态时间线”能力，不承担需求池动态，不承担首页其它概览指标。
+
+前端要求后端单独提供这条接口，原因如下：
+
+- 语义清晰，前后端都容易维护
+- 首页时间线可直接消费
+- 后续如果要做独立的产品动态页，也可以继续复用这条接口
+- 不需要继续让前端从多个接口里拼装事件
+
+## 5. 第一版事件范围
+
+第一版事件类型确认收敛为 5 类：
+
+- `product_created`：产品创建
+- `product_status_changed`：产品状态变更
+- `product_manager_changed`：产品经理变更
+- `product_member_joined`：成员加入
+- `product_member_removed`：成员移出
+
+第一版明确不纳入：
+
+- 成员角色调整
+- 需求新增
+- 需求状态流转
+- 需求关闭
+- 里程碑事件
+- 风险点事件
+
+## 6. 查询参数要求
+
+接口必须支持以下查询参数：
+
+- `pageNo`：页码
+- `pageSize`：每页数量
+- `startTime`：开始时间
+- `endTime`：结束时间
+- `types`：事件类型数组，多选
+
+补充要求：
+
+- 当前端未传时间范围时，后端默认按最近 `30 天` 返回
+- 返回结果按 `occurredAt desc` 倒序排列
+- `types` 支持多选，不要求前端单选
+
+示例：
+
+```http
+GET /project/product/1001/activities/page?pageNo=1&pageSize=10&startTime=2026-03-24 00:00:00&endTime=2026-04-23 23:59:59&types=product_status_changed&types=product_manager_changed
+```
+
+## 7. 返回结构要求
+
+接口返回必须支持分页，分页结构至少应满足：
+
+```json
+{
+  "total": 128,
+  "list": [
+    {
+      "id": "act_001",
+      "type": "product_status_changed",
+      "title": "产品状态变更",
+      "operatorId": "10001",
+      "operatorName": "张敏",
+      "occurredAt": "2026-04-23 10:32:15",
+      "summary": "产品状态由暂停变更为启用",
+      "reason": "测试恢复",
+      "beforeStatus": "paused",
+      "afterStatus": "active"
+    }
+  ]
+}
+```
+
+分页顶层字段至少包括：
+
+- `total`
+- `list`
+
+如果后端已有统一分页模型，可以沿用现有分页结构，但前端必须能稳定拿到总数和列表。
+
+## 8. 事件通用字段要求
+
+无论哪种事件类型，后端都应统一返回以下字段：
+
+- `id`：事件唯一 ID
+- `type`：事件类型编码
+- `title`：事件标题
+- `operatorId`：操作人 ID
+- `operatorName`：操作人名称
+- `occurredAt`：发生时间
+- `summary`：事件摘要
+- `reason`：原因或备注，可为空
+
+这些字段是首页时间线最小可展示集合。
+
+## 9. 各事件类型的专属字段要求
+
+### 9.1 产品创建 `product_created`
+
+必须补充：
+
+- `creatorUserId`
+- `creatorUserName`
+
+### 9.2 产品状态变更 `product_status_changed`
+
+这是当前最关键的一类事件，后端必须返回：
+
+- `beforeStatus`
+- `afterStatus`
+- `reason`
+
+前端需要用这组字段明确表达：
+
+- 变更前状态
+- 变更后状态
+- 本次变更原因
+
+例如：
+
+- `暂停 -> 启用`
+- `启用 -> 归档`
+
+### 9.3 产品经理变更 `product_manager_changed`
+
+必须返回：
+
+- `beforeManagerUserId`
+- `beforeManagerUserName`
+- `afterManagerUserId`
+- `afterManagerUserName`
+- `reason`
+
+否则前端无法准确展示交接关系，只能看到当前经理，不能看到变更前后关系。
+
+### 9.4 成员加入 `product_member_joined`
+
+必须返回：
+
+- `memberUserId`
+- `memberUserName`
+- `roleId`
+- `roleName`
+- `remark`
+
+### 9.5 成员移出 `product_member_removed`
+
+必须返回：
+
+- `memberUserId`
+- `memberUserName`
+- `roleId`
+- `roleName`
+- `reason`
+
+## 10. 前端展示口径
+
+前端首页时间线模块第一版会直接基于这条接口支持：
+
+- 默认最近 `30 天`
+- 自定义时间范围筛选
+- 事件类型多选筛选
+- 分页切换
+
+每条记录最少展示：
+
+- 事件类型
+- 事件标题
+- 操作人
+- 发生时间
+- 变更摘要
+- 原因/备注
+
+其中“产品状态变更”需要明确体现：
+
+- 变更前状态
+- 变更后状态
+- 变更原因
+
+## 11. 为什么不建议继续让前端拼装
+
+如果继续沿用当前前端拼装方案，会有这些问题：
+
+- 产品状态变更前后值无法补齐
+- 产品经理变更前后值无法补齐
+- 无法支持分页
+- 无法支持统一时间筛选
+- 无法支持统一类型筛选
+- 不同事件文案会在前端散落拼装，长期维护成本高
+
+因此这里的前后端边界应明确为：
+
+- 后端提供统一产品动态分页接口
+- 前端负责筛选条件组织、分页交互和时间线展示
+
+## 12. 本轮需求结论
+
+本轮给后端的结论可以直接收敛为：
+
+1. 当前前端已有接口不满足正式产品动态时间线需求
+2. 后端新增 `GET /project/product/{id}/activities/page`
+3. 接口必须支持分页、默认最近 `30 天`、自定义时间范围、事件类型多选
+4. 第一版事件类型只做：
+   - 产品创建
+   - 产品状态变更
+   - 产品经理变更
+   - 成员加入
+   - 成员移出
+5. 产品状态变更必须提供前后状态和原因
+6. 产品经理变更必须提供前后经理信息
+
+这条接口交付后，前端才能把当前“产品动态时间线”从拼装摘要升级成正式可查询模块。
--- a/rdms-project/2026-04-23-product-overview-homepage-design.md
+++ b/rdms-project/2026-04-23-product-overview-homepage-design.md
@@ -0,0 +1,292 @@
+# 产品对象首页改版设计说明
+
+日期：2026-04-23
+
+## 1. 目标
+
+本设计用于收敛 RDMS 产品对象上下文默认首页的改版方向。
+
+本轮目标不是继续做“说明型占位页”，而是明确把当前 `/product/dashboard?objectId=...` 改成一个真正可用的产品对象首页：
+
+- 第一眼先让用户知道当前看的是什么产品
+- 第二眼能快速判断对象最近发生了什么
+- 第三眼能看出需求池现在的经营状态和最近变化
+- 底部为后续业务模块保留正式挂载位，而不是临时拼接入口
+
+## 2. 已确认诉求
+
+基于本轮对话，已确认以下用户诉求：
+
+1. 首页顶部必须先展示产品基础概述，而不是先铺统计卡片
+2. 基础概述至少包含：名称、编号、团队、产品经理等对象基础信息
+3. 页面需要一块明显的时间线，用于承接产品对象与团队变更动态
+4. 页面需要承接需求池管理情况，重点看总量、状态、待处理等统计信息
+5. 需求相关事件不要混入对象时间线，应单独作为需求池最近变化区域
+6. 快捷入口不要保留
+7. 底部允许保留后续扩展区，重点预留给里程碑、风险点管理、产品资料等模块
+8. 能接真实接口就接真实接口，当前没有稳定接口的区域允许先用假数据，但结构必须按正式首页来设计
+
+## 3. 首页定位结论
+
+本页定位不是：
+
+- 纯报表看板
+- 纯审计日志页
+- 设置页搬运版
+- 导航入口集合页
+
+本页定位应当是：
+
+- 产品对象首页
+- 偏统计，也带审计
+- 但页面主语始终是“当前产品对象”
+
+换句话说，这个页面要同时回答三个问题：
+
+1. 我现在看的是什么产品？
+2. 这个产品对象最近发生了什么？
+3. 这个产品的需求池现在处于什么状态？
+
+## 4. 页面结构
+
+### 4.1 桌面端结构
+
+桌面端建议采用三层结构：
+
+1. 顶部 `对象基础概述横幅`
+2. 中部 `左时间线 + 右需求池双模块`
+3. 底部 `扩展信息区`
+
+推荐布局比例：
+
+- 顶部横幅：`24 / 24`
+- 中部主区：左 `16 / 24`，右 `8 / 24`
+- 底部扩展区：`24 / 24`
+
+中部左侧时间线高度应明显高于右侧任一单模块，形成首页主阅读区。
+
+### 4.2 移动端结构
+
+移动端统一退化为单列纵向布局，顺序为：
+
+1. 对象基础概述横幅
+2. 对象 / 团队动态时间线
+3. 需求池管理概览
+4. 需求池最近变化
+5. 扩展信息区
+
+移动端不强撑左右栏并排，不做卡片墙式压缩。
+
+## 5. 模块设计
+
+### 5.1 对象基础概述横幅
+
+顶部采用“档案横幅型”，不采用纯指标卡片型。
+
+横幅左侧承接对象身份信息：
+
+- 产品名称
+- 产品编号
+- 当前状态标签
+- 产品经理
+- 团队规模
+- 团队角色摘要
+- 简短描述或备注
+
+横幅右侧承接 4 个摘要指标：
+
+- 团队人数
+- 需求总量
+- 待处理需求
+- 最近动态时间
+
+设计原则：
+
+- 左侧负责建立对象识别
+- 右侧负责快速判断当前概况
+- 右侧指标只保留 4 项，不堆成报表卡片墙
+
+### 5.2 对象 / 团队动态时间线
+
+该区域位于中部左侧，是首页的主阅读区。
+
+这条时间线只承接对象与团队变化，不承接需求事件。
+
+第一版事件范围收敛为：
+
+- 产品创建
+- 产品状态变更
+- 产品经理变更
+- 成员加入
+- 成员移出
+- 成员角色调整
+
+每条时间线建议展示：
+
+- 事件标题
+- 事件类型标签
+- 发生时间
+- 操作摘要
+- 必要时展示原因或备注
+
+表达目标是“业务时间线”，不是后台审计表格。
+
+### 5.3 需求池管理概览
+
+该区域位于中部右侧上半块，用于表达需求池的经营状态。
+
+第一版首页需要优先看到的内容：
+
+- 需求总量
+- 各状态数量
+- 待处理数量
+- 高优先级待处理数量
+
+展示方式建议为“摘要指标 + 状态分布列表”，不直接在首页展开完整需求表格。
+
+这一块回答的是：
+
+- 需求池是否健康
+- 当前待处理压力大不大
+- 是否存在需要优先关注的积压
+
+### 5.4 需求池最近变化
+
+该区域位于中部右侧下半块，与需求池管理概览上下分层，但属于同一侧栏语义。
+
+该区域不重复展示总量，而是展示需求池最近发生的变化。
+
+第一版建议承接：
+
+- 最近新增需求
+- 最近状态流转
+- 最近关闭或完成
+
+每条记录建议至少展示：
+
+- 需求标题
+- 动作类型
+- 时间
+- 当前状态或状态变更摘要
+
+若当前没有真实数据，仍保留正式模块壳，不退化成“待开发”一句话。
+
+### 5.5 扩展信息区
+
+底部不再保留快捷入口，改为正式扩展信息区。
+
+当前优先预留 3 类模块位：
+
+- 里程碑
+- 风险点管理
+- 产品资料
+
+这一层的作用是：
+
+- 为后续对象级信息继续扩展留下稳定挂载位
+- 不把中部主结构挤成信息大杂烩
+- 避免为了未来模块提前做假导航入口
+
+如果当前没有稳定接口，可先保留正式卡片结构与空态说明。
+
+## 6. 数据策略
+
+### 6.1 真实接口优先
+
+当前首页优先消费现有真实接口：
+
+- `fetchGetProduct`
+- `fetchGetProductSettings`
+- `fetchGetProductMembers`
+
+这些接口足以支撑：
+
+- 对象基础概述中的名称、编号、状态、产品经理、描述
+- 团队人数与角色摘要
+- 最近动态中的产品创建、状态变化、成员加入/移出
+
+### 6.2 假数据使用边界
+
+当前没有稳定真实接口的区域，允许先用假数据，但边界必须明确：
+
+- 需求池管理概览
+- 需求池最近变化
+- 扩展信息区中的里程碑、风险点管理、产品资料摘要
+
+假数据的使用原则：
+
+1. 只补“当前没有稳定接口”的区域
+2. 不反向污染对象基础信息
+3. 不把假数据混入对象上下文 store
+4. 数据源要集中放在概览页自己的 mock 模块中，方便后续替换
+
+### 6.3 不推荐的做法
+
+以下做法应避免：
+
+- 把需求假数据散落写进页面组件
+- 用对象 demo 数据冒充真实产品详情
+- 把对象时间线和需求时间线混成一条
+- 用快捷入口伪装成首页内容
+
+## 7. 空态规则
+
+首页至少要区分三种状态：
+
+1. 能力未接入，只能先显示正式占位信息
+2. 能力已接入，但当前该产品暂无业务数据
+3. 当前用户无权限查看该模块
+
+这三种状态不能共用一套模糊文案。
+
+对需求池和扩展信息区，当前阶段更推荐“正式空态”而不是“待开发”。
+
+## 8. 页面边界
+
+首页明确不承接以下内容：
+
+- 快捷入口导航区
+- 完整团队成员表格
+- 完整需求列表表格
+- 设置页重表单
+- 完整审计日志明细页
+
+首页要做的是概述、判断与阅读，不是重操作页。
+
+## 9. 实施建议
+
+第一阶段建议先完成结构性改造：
+
+1. 重做顶部横幅，建立对象档案感
+2. 保留中部左高右双块结构
+3. 用真实接口接通对象概述与对象 / 团队时间线
+4. 用局部 mock 数据先接通需求池两块和底部扩展区
+
+第二阶段再逐步替换需求池与扩展区数据源：
+
+- 接真实需求池统计接口
+- 接真实需求动态接口
+- 接里程碑、风险点、产品资料摘要接口
+
+## 10. 验证标准
+
+本设计是否成立，可按以下标准判断：
+
+1. 进入首页后，第一眼能认出当前产品对象
+2. 用户能自然读到对象 / 团队最近发生了什么
+3. 右侧能快速判断需求池当前压力与最近变化
+4. 页面看起来像“对象首页”，而不是“普通后台卡片堆叠页”
+5. 当前没有真实接口的区域也保留正式结构，不显得像临时占位
+6. 后续新增里程碑、风险点管理、产品资料等能力时，不需要推翻整页结构
+
+## 11. 本轮设计结论
+
+本轮最终设计结论如下：
+
+- 首页定位为“产品对象首页”，偏统计，也带审计，但不做纯报表页
+- 顶部采用档案横幅型，先立住对象身份信息
+- 中部左侧是高权重的对象 / 团队动态时间线
+- 中部右侧拆为“需求池管理概览 + 需求池最近变化”上下两块
+- 底部去掉快捷入口，改为正式扩展信息区
+- 当前有真实接口的模块优先接真实接口
+- 当前没有稳定接口的区域允许先用假数据，但必须隔离在概览页局部 mock 数据源中
--- a/rdms-project/pom.xml
+++ b/rdms-project/pom.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>com.njcn</groupId>
+        <artifactId>cn-rdms</artifactId>
+        <version>${revision}</version>
+    </parent>
+
+    <artifactId>rdms-project</artifactId>
+    <packaging>pom</packaging>
+    <name>${project.artifactId}</name>
+    <description>
+        RDMS 项目交付域模块
+        该模块承载项目集、项目、产品、需求、任务、工单、执行等 RDMS 核心交付业务能力。
+    </description>
+    <modules>
+        <module>rdms-project-boot</module>
+        <module>rdms-project-api</module>
+    </modules>
+
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+</project>
--- a/rdms-project/rdms-project-api/pom.xml
+++ b/rdms-project/rdms-project-api/pom.xml
@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>com.njcn</groupId>
+        <artifactId>rdms-project</artifactId>
+        <version>${revision}</version>
+    </parent>
+
+    <artifactId>rdms-project-api</artifactId>
+    <description>
+        项目交付域接口，暴露给其它模块调用
+    </description>
+
+    <dependencies>
+
+        <dependency>
+            <groupId>com.njcn</groupId>
+            <artifactId>rdms-common</artifactId>
+        </dependency>
+
+        <!-- Web 相关 -->
+        <dependency>
+            <groupId>io.swagger.core.v3</groupId>
+            <artifactId>swagger-annotations</artifactId>
+        </dependency>
+
+        <!-- 参数校验 -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-validation</artifactId>
+            <optional>true</optional>
+        </dependency>
+
+        <!-- RPC 远程调用相关 -->
+        <dependency>
+            <groupId>org.springframework.cloud</groupId>
+            <artifactId>spring-cloud-starter-openfeign</artifactId>
+            <optional>true</optional>
+        </dependency>
+
+    </dependencies>
+
+</project>
--- a/rdms-project/rdms-project-api/src/main/java/com/njcn/rdms/module/project/api/package-info.java
+++ b/rdms-project/rdms-project-api/src/main/java/com/njcn/rdms/module/project/api/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Project API 包，定义暴露给其它模块的 API
+ */
+package com.njcn.rdms.module.project.api;
--- a/rdms-project/rdms-project-api/src/main/java/com/njcn/rdms/module/project/enums/ApiConstants.java
+++ b/rdms-project/rdms-project-api/src/main/java/com/njcn/rdms/module/project/enums/ApiConstants.java
@@ -0,0 +1,24 @@
+package com.njcn.rdms.module.project.enums;
+
+import com.njcn.rdms.framework.common.enums.RpcConstants;
+
+/**
+ * API 相关的枚举
+ */
+public class ApiConstants {
+
+    /**
+     * 服务名
+     *
+     * 注意，需要保证和 spring.application.name 保持一致
+     */
+    public static final String NAME = RpcConstants.PROJECT_NAME;
+
+    public static final String PREFIX = RpcConstants.PROJECT_PREFIX;
+
+    public static final String VERSION = "1.0.0";
+
+    private ApiConstants() {
+    }
+
+}
--- a/rdms-project/rdms-project-api/src/main/java/com/njcn/rdms/module/project/enums/ErrorCodeConstants.java
+++ b/rdms-project/rdms-project-api/src/main/java/com/njcn/rdms/module/project/enums/ErrorCodeConstants.java
@@ -0,0 +1,37 @@
+package com.njcn.rdms.module.project.enums;
+
+import com.njcn.rdms.framework.common.exception.ErrorCode;
+
+/**
+ * Project 错误码枚举类
+ *
+ * 产品管理当前使用 1-008-001-000 段。
+ */
+public interface ErrorCodeConstants {
+
+    // ========== 产品管理 1-008-001-000 ==========
+    ErrorCode PRODUCT_NOT_EXISTS = new ErrorCode(1_008_001_000, "产品不存在");
+    ErrorCode PRODUCT_CODE_DUPLICATE = new ErrorCode(1_008_001_001, "已经存在编码为【{}】的产品");
+    ErrorCode PRODUCT_NAME_DUPLICATE = new ErrorCode(1_008_001_002, "已经存在名称为【{}】的产品");
+    ErrorCode PRODUCT_CODE_NOT_MODIFIABLE = new ErrorCode(1_008_001_003, "产品编码创建后不允许修改");
+    ErrorCode PRODUCT_STATUS_ACTION_NOT_ALLOWED = new ErrorCode(1_008_001_004, "当前产品状态不支持动作【{}】");
+    ErrorCode PRODUCT_STATUS_ACTION_REASON_REQUIRED = new ErrorCode(1_008_001_005, "动作【{}】必须填写原因");
+    ErrorCode PRODUCT_DELETE_NAME_MISMATCH = new ErrorCode(1_008_001_006, "删除确认名称与当前产品名称不一致");
+    ErrorCode PRODUCT_STATUS_NOT_ALLOW_EDIT = new ErrorCode(1_008_001_007, "当前产品状态不允许编辑");
+    ErrorCode PRODUCT_PAUSED_ONLY_ALLOW_LIMITED_UPDATE = new ErrorCode(1_008_001_008, "产品暂停后仅允许修正描述，产品经理请通过产品团队维护");
+    ErrorCode PRODUCT_MEMBER_NOT_EXISTS = new ErrorCode(1_008_001_009, "产品团队成员不存在");
+    ErrorCode PRODUCT_MEMBER_ALREADY_EXISTS = new ErrorCode(1_008_001_010, "该用户已是当前产品的有效团队成员");
+    ErrorCode PRODUCT_MEMBER_ROLE_INVALID = new ErrorCode(1_008_001_011, "角色不存在或不属于产品对象角色");
+    ErrorCode PRODUCT_MANAGER_TRANSFER_INFO_REQUIRED = new ErrorCode(1_008_001_013, "切换产品经理时必须同时传入原产品经理用户和交接后角色");
+    ErrorCode PRODUCT_MANAGER_MEMBER_NOT_ALLOW_REMOVE = new ErrorCode(1_008_001_014, "当前产品经理不能移出产品团队，请先完成经理转交");
+    ErrorCode PRODUCT_MANAGER_MEMBER_NOT_ALLOW_DOWNGRADE = new ErrorCode(1_008_001_015, "当前产品经理不能直接调整为非经理角色，请先完成经理转交");
+    ErrorCode PRODUCT_MEMBER_NOT_ACTIVE = new ErrorCode(1_008_001_016, "当前产品团队成员已失效");
+    ErrorCode PRODUCT_MANAGER_TRANSFER_SOURCE_INVALID = new ErrorCode(1_008_001_017, "原产品经理信息与当前产品经理不一致");
+    ErrorCode PRODUCT_MANAGER_TRANSFER_ROLE_INVALID = new ErrorCode(1_008_001_018, "原产品经理交接后的角色不能仍为产品经理");
+    ErrorCode PRODUCT_MANAGER_NOT_MODIFIABLE = new ErrorCode(1_008_001_019, "产品主数据编辑不允许直接变更产品经理，请通过产品团队维护");
+    ErrorCode PRODUCT_OBJECT_PERMISSION_DENIED = new ErrorCode(1_008_001_020, "当前用户不具备该产品的操作权限【{}】");
+    ErrorCode PRODUCT_DELETE_CONFIRM_TEXT_INVALID = new ErrorCode(1_008_001_021, "删除确认口令不正确");
+    ErrorCode PRODUCT_STATUS_CONCURRENT_MODIFIED = new ErrorCode(1_008_001_022, "产品状态已发生变化，请刷新后重试");
+    ErrorCode PRODUCT_STATUS_MODEL_NOT_EXISTS_OR_DISABLED = new ErrorCode(1_008_001_023, "产品状态定义不存在或已停用");
+
+}
--- a/rdms-project/rdms-project-boot/pom.xml
+++ b/rdms-project/rdms-project-boot/pom.xml
@@ -0,0 +1,116 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <parent>
+        <groupId>com.njcn</groupId>
+        <artifactId>rdms-project</artifactId>
+        <version>${revision}</version>
+    </parent>
+
+    <artifactId>rdms-project-boot</artifactId>
+    <description>项目交付域功能服务模块</description>
+    <properties>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <dependencies>
+        <!-- Spring Cloud 基础 -->
+        <dependency>
+            <groupId>com.njcn</groupId>
+            <artifactId>rdms-spring-boot-starter-env</artifactId>
+        </dependency>
+
+        <!-- 依赖服务 -->
+        <dependency>
+            <groupId>com.njcn</groupId>
+            <artifactId>rdms-project-api</artifactId>
+            <version>${revision}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.njcn</groupId>
+            <artifactId>rdms-system-api</artifactId>
+            <version>${revision}</version>
+        </dependency>
+
+        <!-- Web 相关 -->
+        <dependency>
+            <groupId>com.njcn</groupId>
+            <artifactId>rdms-spring-boot-starter-security</artifactId>
+        </dependency>
+
+        <!-- DB 相关 -->
+        <dependency>
+            <groupId>com.njcn</groupId>
+            <artifactId>rdms-spring-boot-starter-mybatis</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>com.njcn</groupId>
+            <artifactId>rdms-spring-boot-starter-redis</artifactId>
+        </dependency>
+
+        <!-- RPC 远程调用相关 -->
+        <dependency>
+            <groupId>com.njcn</groupId>
+            <artifactId>rdms-spring-boot-starter-rpc</artifactId>
+        </dependency>
+
+        <!-- 工具类相关 -->
+        <dependency>
+            <groupId>com.njcn</groupId>
+            <artifactId>rdms-spring-boot-starter-excel</artifactId>
+        </dependency>
+
+        <!-- Registry 注册中心相关 -->
+        <dependency>
+            <groupId>com.alibaba.cloud</groupId>
+            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
+        </dependency>
+
+        <!-- Config 配置中心相关 -->
+        <dependency>
+            <groupId>com.alibaba.cloud</groupId>
+            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
+        </dependency>
+
+        <!-- Test 测试相关 -->
+        <dependency>
+            <groupId>com.njcn</groupId>
+            <artifactId>rdms-spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
+        <!-- 热部署-->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-devtools</artifactId>
+            <scope>runtime</scope>
+            <optional>true</optional>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>${project.artifactId}</finalName>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <version>${spring.boot.version}</version>
+                <configuration>
+                    <addResources>true</addResources>
+                </configuration>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/ProjectServerApplication.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/ProjectServerApplication.java
@@ -0,0 +1,16 @@
+package com.njcn.rdms.module.project;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+/**
+ * 项目交付域服务启动类
+ */
+@SpringBootApplication
+public class ProjectServerApplication {
+
+    public static void main(String[] args) {
+        SpringApplication.run(ProjectServerApplication.class, args);
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/api/package-info.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/api/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * Project API 实现包，放置对外暴露 RPC 接口的实现类
+ */
+package com.njcn.rdms.module.project.api;
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/constant/ObjectActivityConstants.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/constant/ObjectActivityConstants.java
@@ -0,0 +1,86 @@
+package com.njcn.rdms.module.project.constant;
+
+import org.springframework.util.StringUtils;
+
+import java.util.List;
+import java.util.Set;
+
+/**
+ * 对象动态常量
+ *
+ * 说明：
+ * 1. 当前先承载产品对象首页时间线使用的 activityType / actionType 常量
+ * 2. 后续项目等对象复用同类动态能力时，继续按前缀分组扩展，不单独拆分枚举
+ */
+public final class ObjectActivityConstants {
+
+    private ObjectActivityConstants() {
+    }
+
+    // ========== 动态来源类型 ==========
+    public static final String ACTIVITY_TYPE_STATUS = "status";
+    public static final String ACTIVITY_TYPE_PRODUCT = "product";
+    public static final String ACTIVITY_TYPE_MEMBER = "member";
+
+    // ========== 审计业务类型 ==========
+    public static final String PRODUCT_BIZ_TYPE = "product";
+    public static final String MEMBER_BIZ_TYPE = "rdms_user_object_role";
+
+    // ========== 产品对象动作 ==========
+    public static final String PRODUCT_ACTION_CREATE = "create";
+    public static final String PRODUCT_ACTION_UPDATE = "update";
+    public static final String PRODUCT_ACTION_DELETE = "delete";
+    public static final String PRODUCT_ACTION_CHANGE_MANAGER = "change_manager";
+
+    // ========== 状态动作 ==========
+    public static final String STATUS_ACTION_PAUSE = "pause";
+    public static final String STATUS_ACTION_RESUME = "resume";
+    public static final String STATUS_ACTION_ARCHIVE = "archive";
+    public static final String STATUS_ACTION_ABANDON = "abandon";
+
+    // ========== 成员动作 ==========
+    public static final String MEMBER_ACTION_ADD = "add_member";
+    public static final String MEMBER_ACTION_UPDATE = "update_member";
+    public static final String MEMBER_ACTION_REMOVE = "remove_member";
+
+    public static final List<String> STATUS_ACTION_TYPES = List.of(
+            STATUS_ACTION_PAUSE, STATUS_ACTION_RESUME, STATUS_ACTION_ARCHIVE, STATUS_ACTION_ABANDON);
+
+    public static final List<String> PRODUCT_TIMELINE_ACTION_TYPES = List.of(
+            PRODUCT_ACTION_CREATE, PRODUCT_ACTION_CHANGE_MANAGER);
+
+    public static final List<String> MEMBER_TIMELINE_ACTION_TYPES = List.of(
+            MEMBER_ACTION_ADD, MEMBER_ACTION_UPDATE, MEMBER_ACTION_REMOVE);
+
+    private static final Set<String> STATUS_ACTION_TYPE_SET = Set.copyOf(STATUS_ACTION_TYPES);
+
+    public static boolean isStatusAction(String actionType) {
+        return STATUS_ACTION_TYPE_SET.contains(normalize(actionType));
+    }
+
+    public static String resolveActionName(String actionType) {
+        String normalizedActionType = normalize(actionType);
+        if (!StringUtils.hasText(normalizedActionType)) {
+            return actionType;
+        }
+        return switch (normalizedActionType) {
+            case PRODUCT_ACTION_CREATE -> "创建";
+            case PRODUCT_ACTION_UPDATE -> "更新";
+            case PRODUCT_ACTION_DELETE -> "删除";
+            case STATUS_ACTION_PAUSE -> "暂停";
+            case STATUS_ACTION_RESUME -> "恢复";
+            case STATUS_ACTION_ARCHIVE -> "归档";
+            case STATUS_ACTION_ABANDON -> "废弃";
+            case PRODUCT_ACTION_CHANGE_MANAGER -> "切换产品经理";
+            case MEMBER_ACTION_ADD -> "新增成员";
+            case MEMBER_ACTION_UPDATE -> "调整成员";
+            case MEMBER_ACTION_REMOVE -> "移出成员";
+            default -> normalizedActionType;
+        };
+    }
+
+    private static String normalize(String value) {
+        return StringUtils.hasText(value) ? value.trim() : null;
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/package-info.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * 管理端控制器包
+ */
+package com.njcn.rdms.module.project.controller.admin;
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/ProductController.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/ProductController.java
@@ -0,0 +1,85 @@
+package com.njcn.rdms.module.project.controller.admin.product;
+
+import com.njcn.rdms.framework.common.pojo.CommonResult;
+import com.njcn.rdms.framework.common.pojo.PageResult;
+import com.njcn.rdms.framework.common.util.object.BeanUtils;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductContextRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductDeleteReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductPageReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductSaveReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductStatusActionReqVO;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductDO;
+import com.njcn.rdms.module.project.service.product.ProductService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.validation.Valid;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import static com.njcn.rdms.framework.common.pojo.CommonResult.success;
+
+@Tag(name = "管理后台 - 产品管理")
+@RestController
+@RequestMapping("/project/product")
+@Validated
+public class ProductController {
+
+    @Resource
+    private ProductService productService;
+
+    @PostMapping("/create")
+    @Operation(summary = "创建产品")
+    @PreAuthorize("@ss.hasPermission('project:product:create')")
+    public CommonResult<Long> createProduct(@Valid @RequestBody ProductSaveReqVO createReqVO) {
+        return success(productService.createProduct(createReqVO));
+    }
+
+    @PutMapping("/update")
+    @Operation(summary = "更新产品")
+    public CommonResult<Boolean> updateProduct(@Valid @RequestBody ProductSaveReqVO updateReqVO) {
+        productService.updateProduct(updateReqVO);
+        return success(true);
+    }
+
+    @GetMapping("/get")
+    @Operation(summary = "获取产品详情")
+    @Parameter(name = "id", description = "产品编号", required = true, example = "1024")
+    public CommonResult<ProductRespVO> getProduct(@RequestParam("id") Long id) {
+        ProductDO product = productService.getProduct(id);
+        return success(BeanUtils.toBean(product, ProductRespVO.class));
+    }
+
+    @GetMapping("/{id}/context")
+    @Operation(summary = "获取产品上下文")
+    @Parameter(name = "id", description = "产品编号", required = true, example = "1024")
+    public CommonResult<ProductContextRespVO> getProductContext(@PathVariable("id") Long id) {
+        return success(productService.getProductContext(id));
+    }
+
+    @GetMapping("/page")
+    @Operation(summary = "获取产品分页")
+    @PreAuthorize("@ss.hasPermission('project:product:query')")
+    public CommonResult<PageResult<ProductRespVO>> getProductPage(@Valid ProductPageReqVO pageReqVO) {
+        PageResult<ProductDO> pageResult = productService.getProductPage(pageReqVO);
+        return success(BeanUtils.toBean(pageResult, ProductRespVO.class));
+    }
+
+    @PostMapping("/change-status")
+    @Operation(summary = "变更产品状态")
+    public CommonResult<Boolean> changeProductStatus(@Valid @RequestBody ProductStatusActionReqVO reqVO) {
+        productService.changeProductStatus(reqVO);
+        return success(true);
+    }
+
+    @PostMapping("/delete")
+    @Operation(summary = "删除产品")
+    public CommonResult<Boolean> deleteProduct(@Valid @RequestBody ProductDeleteReqVO reqVO) {
+        productService.deleteProduct(reqVO);
+        return success(true);
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/ProductMemberController.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/ProductMemberController.java
@@ -0,0 +1,63 @@
+package com.njcn.rdms.module.project.controller.admin.product;
+
+import com.njcn.rdms.framework.common.pojo.CommonResult;
+import com.njcn.rdms.module.project.controller.admin.product.vo.member.ProductMemberInactiveReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.member.ProductMemberRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.member.ProductMemberSaveReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.member.ProductMemberUpdateReqVO;
+import com.njcn.rdms.module.project.service.product.ProductMemberService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.validation.Valid;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+import static com.njcn.rdms.framework.common.pojo.CommonResult.success;
+
+@Tag(name = "管理后台 - 产品团队")
+@RestController
+@RequestMapping("/project/product")
+@Validated
+public class ProductMemberController {
+
+    @Resource
+    private ProductMemberService productMemberService;
+
+    @GetMapping("/{id}/members")
+    @Operation(summary = "获取产品团队成员列表")
+    @Parameter(name = "id", description = "产品编号", required = true, example = "1024")
+    public CommonResult<List<ProductMemberRespVO>> getProductMemberList(@PathVariable("id") Long productId) {
+        return success(productMemberService.getProductMemberList(productId));
+    }
+
+    @PostMapping("/{id}/members")
+    @Operation(summary = "新增产品团队成员")
+    @Parameter(name = "id", description = "产品编号", required = true, example = "1024")
+    public CommonResult<Long> createProductMember(@PathVariable("id") Long productId,
+                                                  @Valid @RequestBody ProductMemberSaveReqVO reqVO) {
+        return success(productMemberService.createProductMember(productId, reqVO));
+    }
+
+    @PutMapping("/{id}/members/{memberId}")
+    @Operation(summary = "调整产品团队成员角色")
+    public CommonResult<Boolean> updateProductMember(@PathVariable("id") Long productId,
+                                                     @PathVariable("memberId") Long memberId,
+                                                     @Valid @RequestBody ProductMemberUpdateReqVO reqVO) {
+        productMemberService.updateProductMember(productId, memberId, reqVO);
+        return success(true);
+    }
+
+    @PostMapping("/{id}/members/{memberId}/inactive")
+    @Operation(summary = "移出产品团队成员")
+    public CommonResult<Boolean> inactiveProductMember(@PathVariable("id") Long productId,
+                                                       @PathVariable("memberId") Long memberId,
+                                                       @Valid @RequestBody ProductMemberInactiveReqVO reqVO) {
+        productMemberService.inactiveProductMember(productId, memberId, reqVO);
+        return success(true);
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/ProductSettingController.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/ProductSettingController.java
@@ -0,0 +1,71 @@
+package com.njcn.rdms.module.project.controller.admin.product;
+
+import com.njcn.rdms.framework.common.pojo.CommonResult;
+import com.njcn.rdms.framework.common.pojo.PageResult;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityPageReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityTimelinePageReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityTimelineRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.setting.ProductSettingBaseInfoUpdateReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.setting.ProductSettingRespVO;
+import com.njcn.rdms.module.project.service.product.ProductService;
+import com.njcn.rdms.module.project.service.product.ProductSettingService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.annotation.Resource;
+import jakarta.validation.Valid;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import static com.njcn.rdms.framework.common.pojo.CommonResult.success;
+
+@Tag(name = "管理后台 - 产品设置")
+@RestController
+@RequestMapping("/project/product")
+@Validated
+public class ProductSettingController {
+
+    @Resource
+    private ProductSettingService productSettingService;
+    @Resource
+    private ProductService productService;
+
+    @GetMapping("/{id}/settings")
+    @Operation(summary = "获取产品设置")
+    @Parameter(name = "id", description = "产品编号", required = true, example = "1024")
+    public CommonResult<ProductSettingRespVO> getProductSettings(@PathVariable("id") Long id) {
+        return success(productSettingService.getProductSettings(id));
+    }
+
+    @GetMapping("/{id}/activities")
+    @Operation(summary = "获取产品动态")
+    @Parameter(name = "id", description = "产品编号", required = true, example = "1024")
+    public CommonResult<PageResult<ProductActivityRespVO>> getProductActivities(@PathVariable("id") Long id,
+                                                                                @Valid ProductActivityPageReqVO reqVO) {
+        return success(productSettingService.getProductActivities(id, reqVO));
+    }
+
+    @GetMapping("/{id}/activities/page")
+    @Operation(summary = "获取产品动态时间线分页")
+    @Parameter(name = "id", description = "产品编号", required = true, example = "1024")
+    public CommonResult<PageResult<ProductActivityTimelineRespVO>> getProductActivityTimelinePage(
+            @PathVariable("id") Long id, @Valid ProductActivityTimelinePageReqVO reqVO) {
+        return success(productSettingService.getProductActivityTimelinePage(id, reqVO));
+    }
+
+    @PutMapping("/{id}/settings/base-info")
+    @Operation(summary = "更新产品设置基础信息")
+    @Parameter(name = "id", description = "产品编号", required = true, example = "1024")
+    public CommonResult<Boolean> updateProductBaseInfo(@PathVariable("id") Long id,
+                                                        @Valid @RequestBody ProductSettingBaseInfoUpdateReqVO reqVO) {
+        productService.updateProductBaseInfo(id, reqVO);
+        return success(true);
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/activity/ProductActivityPageReqVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/activity/ProductActivityPageReqVO.java
@@ -0,0 +1,31 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.activity;
+
+import com.njcn.rdms.framework.common.pojo.PageParam;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.time.LocalDateTime;
+
+import static com.njcn.rdms.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
+
+@Schema(description = "管理后台 - 产品动态分页 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ProductActivityPageReqVO extends PageParam {
+
+    @Schema(description = "动态类型", example = "status")
+    @Size(max = 16, message = "动态类型长度不能超过16个字符")
+    private String activityType;
+
+    @Schema(description = "动作编码", example = "pause")
+    @Size(max = 32, message = "动作编码长度不能超过32个字符")
+    private String actionType;
+
+    @Schema(description = "操作时间区间", example = "[2026-04-01 00:00:00, 2026-04-30 23:59:59]")
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    private LocalDateTime[] operateTime;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/activity/ProductActivityRespVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/activity/ProductActivityRespVO.java
@@ -0,0 +1,45 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.activity;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+@Schema(description = "管理后台 - 产品动态 Response VO")
+@Data
+public class ProductActivityRespVO {
+
+    @Schema(description = "动态类型", example = "status")
+    private String type;
+
+    @Schema(description = "动作编码", example = "pause")
+    private String actionType;
+
+    @Schema(description = "动作名称", example = "暂停")
+    private String actionName;
+
+    @Schema(description = "原状态", example = "active")
+    private String fromStatus;
+
+    @Schema(description = "目标状态", example = "paused")
+    private String toStatus;
+
+    @Schema(description = "动作原因", example = "资源不足")
+    private String reason;
+
+    @Schema(description = "操作人用户编号", example = "1024")
+    private Long operatorUserId;
+
+    @Schema(description = "操作人名称", example = "张三")
+    private String operatorName;
+
+    @Schema(description = "操作时间", example = "2026-04-21 12:00:00")
+    private LocalDateTime operateTime;
+
+    @Schema(description = "展示摘要", example = "张三执行了【暂停】：资源不足")
+    private String summary;
+
+    @Schema(description = "补充详情")
+    private String details;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/activity/ProductActivityTimelinePageReqVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/activity/ProductActivityTimelinePageReqVO.java
@@ -0,0 +1,35 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.activity;
+
+import com.njcn.rdms.framework.common.pojo.PageParam;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+import static com.njcn.rdms.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
+
+@Schema(description = "管理后台 - 产品动态时间线分页 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ProductActivityTimelinePageReqVO extends PageParam {
+
+    @Schema(description = "动态类型", example = "status")
+    @Size(max = 16, message = "动态类型长度不能超过16个字符")
+    private String activityType;
+
+    @Schema(description = "动作编码数组")
+    private List<@Size(max = 32, message = "动作编码长度不能超过32个字符") String> actionTypes;
+
+    @Schema(description = "开始时间", example = "2026-03-24 00:00:00")
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    private LocalDateTime startTime;
+
+    @Schema(description = "结束时间", example = "2026-04-23 23:59:59")
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    private LocalDateTime endTime;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/activity/ProductActivityTimelineRespVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/activity/ProductActivityTimelineRespVO.java
@@ -0,0 +1,54 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.activity;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+@Schema(description = "管理后台 - 产品动态时间线 Response VO")
+@Data
+public class ProductActivityTimelineRespVO {
+
+    @Schema(description = "动态唯一标识", example = "status:11")
+    private String id;
+
+    @Schema(description = "动态类型", example = "status")
+    private String type;
+
+    @Schema(description = "动作编码", example = "pause")
+    private String actionType;
+
+    @Schema(description = "动作名称", example = "暂停")
+    private String actionName;
+
+    @Schema(description = "操作人用户编号", example = "1024")
+    private Long operatorUserId;
+
+    @Schema(description = "操作人名称", example = "张三")
+    private String operatorName;
+
+    @Schema(description = "目标成员用户编号，仅 member 类型返回", example = "2043945809271713793")
+    private Long targetUserId;
+
+    @Schema(description = "目标成员名称，仅 member 类型返回，读取缓存实时转换", example = "张三")
+    private String targetUserName;
+
+    @Schema(description = "发生时间", example = "2026-04-21 12:00:00")
+    private LocalDateTime occurredAt;
+
+    @Schema(description = "展示摘要", example = "张三执行了【暂停】：资源不足")
+    private String summary;
+
+    @Schema(description = "动作原因", example = "资源不足")
+    private String reason;
+
+    @Schema(description = "原状态", example = "active")
+    private String fromStatus;
+
+    @Schema(description = "目标状态", example = "paused")
+    private String toStatus;
+
+    @Schema(description = "补充详情")
+    private String details;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/member/ProductMemberInactiveReqVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/member/ProductMemberInactiveReqVO.java
@@ -0,0 +1,15 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.member;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+@Schema(description = "管理后台 - 产品团队成员移出 Request VO")
+@Data
+public class ProductMemberInactiveReqVO {
+
+    @Schema(description = "移出原因", example = "已退出当前产品协作")
+    @Size(max = 500, message = "移出原因长度不能超过500个字符")
+    private String reason;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/member/ProductMemberRespVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/member/ProductMemberRespVO.java
@@ -0,0 +1,45 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.member;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+@Schema(description = "管理后台 - 产品团队成员 Response VO")
+@Data
+public class ProductMemberRespVO {
+
+    @Schema(description = "团队关系编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
+    private Long id;
+
+    @Schema(description = "用户编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "2048")
+    private Long userId;
+
+    @Schema(description = "用户昵称", example = "小王")
+    private String userNickname;
+
+    @Schema(description = "角色编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "3100000002001")
+    private Long roleId;
+
+    @Schema(description = "角色名称", example = "产品经理")
+    private String roleName;
+
+    @Schema(description = "角色编码", example = "product_manager")
+    private String roleCode;
+
+    @Schema(description = "是否当前产品经理", requiredMode = Schema.RequiredMode.REQUIRED, example = "true")
+    private Boolean managerFlag;
+
+    @Schema(description = "状态（0有效 1失效）", requiredMode = Schema.RequiredMode.REQUIRED, example = "0")
+    private Integer status;
+
+    @Schema(description = "加入时间")
+    private LocalDateTime joinedTime;
+
+    @Schema(description = "退出时间")
+    private LocalDateTime leftTime;
+
+    @Schema(description = "备注", example = "当前负责需求收敛")
+    private String remark;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/member/ProductMemberSaveReqVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/member/ProductMemberSaveReqVO.java
@@ -0,0 +1,30 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.member;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+@Schema(description = "管理后台 - 产品团队成员新增 Request VO")
+@Data
+public class ProductMemberSaveReqVO {
+
+    @Schema(description = "用户编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
+    @NotNull(message = "用户编号不能为空")
+    private Long userId;
+
+    @Schema(description = "角色编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "3100000002001")
+    @NotNull(message = "角色编号不能为空")
+    private Long roleId;
+
+    @Schema(description = "备注", example = "来自产品团队维护")
+    @Size(max = 500, message = "备注长度不能超过500个字符")
+    private String remark;
+
+    @Schema(description = "原产品经理用户编号，仅切换产品经理时传递", example = "2048")
+    private Long previousManagerUserId;
+
+    @Schema(description = "原产品经理交接后的角色编号，仅切换产品经理时传递", example = "3100000002002")
+    private Long previousManagerRoleId;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/member/ProductMemberUpdateReqVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/member/ProductMemberUpdateReqVO.java
@@ -0,0 +1,30 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.member;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+@Schema(description = "管理后台 - 产品团队成员更新 Request VO")
+@Data
+public class ProductMemberUpdateReqVO {
+
+    @Schema(description = "角色编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "3100000002002")
+    @NotNull(message = "角色编号不能为空")
+    private Long roleId;
+
+    @Schema(description = "备注", example = "调整为产品观察者")
+    @Size(max = 500, message = "备注长度不能超过500个字符")
+    private String remark;
+
+    @Schema(description = "变更原因", example = "职责调整")
+    @Size(max = 500, message = "变更原因长度不能超过500个字符")
+    private String reason;
+
+    @Schema(description = "原产品经理用户编号，仅切换产品经理时传递", example = "2048")
+    private Long previousManagerUserId;
+
+    @Schema(description = "原产品经理交接后的角色编号，仅切换产品经理时传递", example = "3100000002002")
+    private Long previousManagerRoleId;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductContextNavRespVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductContextNavRespVO.java
@@ -0,0 +1,25 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.product;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Schema(description = "管理后台 - 产品上下文导航 Response VO")
+@Data
+public class ProductContextNavRespVO {
+
+    @Schema(description = "菜单编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "3201")
+    private Long id;
+
+    @Schema(description = "菜单名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "概览")
+    private String name;
+
+    @Schema(description = "菜单路径", example = "/project/product/overview")
+    private String path;
+
+    @Schema(description = "菜单图标", example = "mdi:view-dashboard-outline")
+    private String icon;
+
+    @Schema(description = "显示顺序", example = "10")
+    private Integer sort;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductContextProductRespVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductContextProductRespVO.java
@@ -0,0 +1,28 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.product;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Schema(description = "管理后台 - 产品上下文中的当前产品摘要 Response VO")
+@Data
+public class ProductContextProductRespVO {
+
+    @Schema(description = "产品编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
+    private Long id;
+
+    @Schema(description = "产品编码", requiredMode = Schema.RequiredMode.REQUIRED, example = "CNPD2026001")
+    private String code;
+
+    @Schema(description = "产品方向字典值", requiredMode = Schema.RequiredMode.REQUIRED, example = "direction_value")
+    private String directionCode;
+
+    @Schema(description = "产品名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "RDMS产品平台")
+    private String name;
+
+    @Schema(description = "产品经理用户编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
+    private Long managerUserId;
+
+    @Schema(description = "产品状态编码", requiredMode = Schema.RequiredMode.REQUIRED, example = "active")
+    private String statusCode;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductContextRespVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductContextRespVO.java
@@ -0,0 +1,26 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.product;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Schema(description = "管理后台 - 产品上下文 Response VO")
+@Data
+@NoArgsConstructor
+public class ProductContextRespVO {
+
+    @Schema(description = "当前产品摘要")
+    private ProductContextProductRespVO currentProduct;
+
+    @Schema(description = "当前用户在该产品下的角色信息")
+    private ProductContextRoleRespVO currentRole;
+
+    @Schema(description = "当前产品下可见导航集合")
+    private List<ProductContextNavRespVO> navs;
+
+    @Schema(description = "当前产品下按钮权限码集合")
+    private List<String> buttons;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductContextRoleRespVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductContextRoleRespVO.java
@@ -0,0 +1,19 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.product;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Schema(description = "管理后台 - 产品上下文中的当前角色 Response VO")
+@Data
+public class ProductContextRoleRespVO {
+
+    @Schema(description = "对象角色编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "3201")
+    private Long roleId;
+
+    @Schema(description = "对象角色编码", example = "product_manager")
+    private String roleCode;
+
+    @Schema(description = "对象角色名称", example = "产品经理")
+    private String roleName;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductDeleteReqVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductDeleteReqVO.java
@@ -0,0 +1,32 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.product;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+@Schema(description = "管理后台 - 产品删除 Request VO")
+@Data
+public class ProductDeleteReqVO {
+
+    @Schema(description = "产品编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
+    @NotNull(message = "产品编号不能为空")
+    private Long id;
+
+    @Schema(description = "确认输入的产品名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "RDMS产品平台")
+    @NotBlank(message = "确认产品名称不能为空")
+    @Size(max = 128, message = "确认产品名称长度不能超过128个字符")
+    private String productName;
+
+    @Schema(description = "删除原因", requiredMode = Schema.RequiredMode.REQUIRED, example = "产品录入错误")
+    @NotBlank(message = "删除原因不能为空")
+    @Size(max = 500, message = "删除原因长度不能超过500个字符")
+    private String reason;
+
+    @Schema(description = "删除确认口令，当前固定输入 DELETE", requiredMode = Schema.RequiredMode.REQUIRED, example = "DELETE")
+    @NotBlank(message = "删除确认口令不能为空")
+    @Size(max = 32, message = "删除确认口令长度不能超过32个字符")
+    private String confirmText;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductPageReqVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductPageReqVO.java
@@ -0,0 +1,39 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.product;
+
+import com.njcn.rdms.framework.common.pojo.PageParam;
+import com.njcn.rdms.framework.dict.validation.InDict;
+import com.njcn.rdms.module.system.enums.DictTypeConstants;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.springframework.format.annotation.DateTimeFormat;
+
+import java.time.LocalDateTime;
+
+import static com.njcn.rdms.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
+
+@Schema(description = "管理后台 - 产品分页 Request VO")
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ProductPageReqVO extends PageParam {
+
+    @Schema(description = "关键词，匹配产品编码或产品名称", example = "CNPD2026001")
+    private String keyword;
+
+    @Schema(description = "产品方向字典值", example = "direction_value")
+    @InDict(type = DictTypeConstants.OBJECT_DIRECTION)
+    private String directionCode;
+
+    @Schema(description = "产品经理用户编号", example = "1024")
+    private Long managerUserId;
+
+    @Schema(description = "产品状态编码", example = "active")
+    @Size(max = 32, message = "产品状态编码长度不能超过32个字符")
+    private String statusCode;
+
+    @Schema(description = "更新时间", example = "[2026-04-01 00:00:00, 2026-04-30 23:59:59]")
+    @DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
+    private LocalDateTime[] updateTime;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductRespVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductRespVO.java
@@ -0,0 +1,42 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.product;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+@Schema(description = "管理后台 - 产品 Response VO")
+@Data
+public class ProductRespVO {
+
+    @Schema(description = "产品编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
+    private Long id;
+
+    @Schema(description = "产品编码", requiredMode = Schema.RequiredMode.REQUIRED, example = "CNPD2026001")
+    private String code;
+
+    @Schema(description = "产品方向字典值", requiredMode = Schema.RequiredMode.REQUIRED, example = "direction_value")
+    private String directionCode;
+
+    @Schema(description = "产品名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "RDMS产品平台")
+    private String name;
+
+    @Schema(description = "产品经理用户编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
+    private Long managerUserId;
+
+    @Schema(description = "产品描述", example = "面向研发管理的一体化产品")
+    private String description;
+
+    @Schema(description = "产品状态编码", requiredMode = Schema.RequiredMode.REQUIRED, example = "active")
+    private String statusCode;
+
+    @Schema(description = "最近一次状态动作原因", example = "阶段性暂停")
+    private String lastStatusReason;
+
+    @Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
+    private LocalDateTime createTime;
+
+    @Schema(description = "更新时间", requiredMode = Schema.RequiredMode.REQUIRED)
+    private LocalDateTime updateTime;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductSaveReqVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductSaveReqVO.java
@@ -0,0 +1,40 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.product;
+
+import com.njcn.rdms.framework.dict.validation.InDict;
+import com.njcn.rdms.module.system.enums.DictTypeConstants;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+@Schema(description = "管理后台 - 产品保存 Request VO")
+@Data
+public class ProductSaveReqVO {
+
+    @Schema(description = "产品编号", example = "1024")
+    private Long id;
+
+    @Schema(description = "产品编码，为空时由系统自动生成", example = "CNPD2026001")
+    @Size(max = 64, message = "产品编码长度不能超过64个字符")
+    private String code;
+
+    @Schema(description = "产品方向字典值", requiredMode = Schema.RequiredMode.REQUIRED, example = "direction_value")
+    @NotBlank(message = "产品方向不能为空")
+    @Size(max = 32, message = "产品方向长度不能超过32个字符")
+    @InDict(type = DictTypeConstants.OBJECT_DIRECTION)
+    private String directionCode;
+
+    @Schema(description = "产品名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "RDMS产品平台")
+    @NotBlank(message = "产品名称不能为空")
+    @Size(max = 128, message = "产品名称长度不能超过128个字符")
+    private String name;
+
+    @Schema(description = "产品经理用户编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
+    @NotNull(message = "产品经理不能为空")
+    private Long managerUserId;
+
+    @Schema(description = "产品描述", example = "面向研发管理的一体化产品")
+    private String description;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductStatusActionReqVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/product/ProductStatusActionReqVO.java
@@ -0,0 +1,26 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.product;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+@Schema(description = "管理后台 - 产品状态动作 Request VO")
+@Data
+public class ProductStatusActionReqVO {
+
+    @Schema(description = "产品编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
+    @NotNull(message = "产品编号不能为空")
+    private Long id;
+
+    @Schema(description = "动作编码，如 pause、resume、archive、abandon", requiredMode = Schema.RequiredMode.REQUIRED, example = "pause")
+    @NotBlank(message = "动作编码不能为空")
+    @Size(max = 32, message = "动作编码长度不能超过32个字符")
+    private String actionCode;
+
+    @Schema(description = "动作原因；是否必填由状态流转配置决定", example = "当前阶段受环境限制暂停推进")
+    @Size(max = 500, message = "动作原因长度不能超过500个字符")
+    private String reason;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/setting/ProductSettingActionRespVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/setting/ProductSettingActionRespVO.java
@@ -0,0 +1,21 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.setting;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Schema(description = "管理后台 - 产品设置生命周期动作 Response VO")
+@Data
+@NoArgsConstructor
+public class ProductSettingActionRespVO {
+
+    @Schema(description = "动作编码", example = "archive")
+    private String actionCode;
+
+    @Schema(description = "动作名称", example = "归档")
+    private String actionName;
+
+    @Schema(description = "是否必须填写原因", example = "true")
+    private Boolean needReason;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/setting/ProductSettingBaseInfoRespVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/setting/ProductSettingBaseInfoRespVO.java
@@ -0,0 +1,39 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.setting;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Schema(description = "管理后台 - 产品设置基础信息 Response VO")
+@Data
+@NoArgsConstructor
+public class ProductSettingBaseInfoRespVO {
+
+    @Schema(description = "产品编号", example = "1024")
+    private Long id;
+
+    @Schema(description = "产品编码", example = "CNPD2026001")
+    private String code;
+
+    @Schema(description = "产品方向字典值", example = "direction_value")
+    private String directionCode;
+
+    @Schema(description = "产品名称", example = "统一交付平台")
+    private String name;
+
+    @Schema(description = "产品经理用户编号", example = "10001")
+    private Long managerUserId;
+
+    @Schema(description = "产品经理昵称", example = "张三")
+    private String managerUserNickname;
+
+    @Schema(description = "产品描述", example = "产品描述")
+    private String description;
+
+    @Schema(description = "产品状态编码", example = "active")
+    private String statusCode;
+
+    @Schema(description = "最近一次状态动作原因", example = "恢复正常推进")
+    private String lastStatusReason;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/setting/ProductSettingBaseInfoUpdateReqVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/setting/ProductSettingBaseInfoUpdateReqVO.java
@@ -0,0 +1,28 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.setting;
+
+import com.njcn.rdms.framework.dict.validation.InDict;
+import com.njcn.rdms.module.system.enums.DictTypeConstants;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+@Schema(description = "管理后台 - 产品设置基础信息更新 Request VO")
+@Data
+public class ProductSettingBaseInfoUpdateReqVO {
+
+    @Schema(description = "产品方向字典值", requiredMode = Schema.RequiredMode.REQUIRED, example = "direction_value")
+    @NotBlank(message = "产品方向不能为空")
+    @Size(max = 32, message = "产品方向长度不能超过32个字符")
+    @InDict(type = DictTypeConstants.OBJECT_DIRECTION)
+    private String directionCode;
+
+    @Schema(description = "产品名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "RDMS产品平台")
+    @NotBlank(message = "产品名称不能为空")
+    @Size(max = 128, message = "产品名称长度不能超过128个字符")
+    private String name;
+
+    @Schema(description = "产品描述", example = "面向研发管理的一体化产品")
+    private String description;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/setting/ProductSettingLifecycleRespVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/setting/ProductSettingLifecycleRespVO.java
@@ -0,0 +1,32 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.setting;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+@Schema(description = "管理后台 - 产品设置生命周期 Response VO")
+@Data
+@NoArgsConstructor
+public class ProductSettingLifecycleRespVO {
+
+    @Schema(description = "当前状态编码", example = "active")
+    private String statusCode;
+
+    @Schema(description = "当前状态名称", example = "启用")
+    private String statusName;
+
+    @Schema(description = "最近一次状态动作原因", example = "恢复正常推进")
+    private String lastStatusReason;
+
+    @Schema(description = "是否终态", example = "false")
+    private Boolean terminal;
+
+    @Schema(description = "是否允许编辑", example = "true")
+    private Boolean allowEdit;
+
+    @Schema(description = "当前状态可执行动作")
+    private List<ProductSettingActionRespVO> availableActions;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/setting/ProductSettingRespVO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/admin/product/vo/setting/ProductSettingRespVO.java
@@ -0,0 +1,18 @@
+package com.njcn.rdms.module.project.controller.admin.product.vo.setting;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Schema(description = "管理后台 - 产品设置 Response VO")
+@Data
+@NoArgsConstructor
+public class ProductSettingRespVO {
+
+    @Schema(description = "产品基础信息")
+    private ProductSettingBaseInfoRespVO baseInfo;
+
+    @Schema(description = "产品生命周期信息")
+    private ProductSettingLifecycleRespVO lifecycle;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/app/package-info.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/app/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * 应用端控制器包
+ */
+package com.njcn.rdms.module.project.controller.app;
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/package-info.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/controller/package-info.java
@@ -0,0 +1,6 @@
+/**
+ * 提供 RESTful API 给前端：
+ * 1. admin 包：提供给管理后台 rdms-ui-admin 前端项目
+ * 2. app 包：提供给用户 APP rdms-ui-app 前端项目，它的 Controller 和 VO 都要添加 App 前缀，用于和管理后台进行区分
+ */
+package com.njcn.rdms.module.project.controller;
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/convert/package-info.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/convert/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * DTO、VO、DO 等对象转换包
+ */
+package com.njcn.rdms.module.project.convert;
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/dataobject/audit/BizAuditLogDO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/dataobject/audit/BizAuditLogDO.java
@@ -0,0 +1,63 @@
+package com.njcn.rdms.module.project.dal.dataobject.audit;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.njcn.rdms.framework.mybatis.core.dataobject.BaseDO;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * RDMS通用业务审计日志表
+ */
+@TableName("rdms_biz_audit_log")
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class BizAuditLogDO extends BaseDO {
+
+    /**
+     * 主键ID
+     */
+    @TableId
+    private Long id;
+    /**
+     * 业务对象类型
+     */
+    private String bizType;
+    /**
+     * 业务对象ID
+     */
+    private Long bizId;
+    /**
+     * 动作类型
+     */
+    private String actionType;
+    /**
+     * 原状态
+     */
+    private String fromStatus;
+    /**
+     * 目标状态
+     */
+    private String toStatus;
+    /**
+     * 关键字段变更摘要
+     */
+    private String fieldChanges;
+    /**
+     * 动作原因或说明
+     */
+    private String reason;
+    /**
+     * 操作人用户ID
+     */
+    private Long operatorUserId;
+    /**
+     * 操作人名称快照
+     */
+    private String operatorName;
+    /**
+     * 备注
+     */
+    private String remark;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/dataobject/member/UserObjectRoleDO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/dataobject/member/UserObjectRoleDO.java
@@ -0,0 +1,57 @@
+package com.njcn.rdms.module.project.dal.dataobject.member;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.njcn.rdms.framework.mybatis.core.dataobject.BaseDO;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.time.LocalDateTime;
+
+/**
+ * RDMS 对象成员角色关系表
+ */
+@TableName("rdms_user_object_role")
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class UserObjectRoleDO extends BaseDO {
+
+    /**
+     * 主键ID
+     */
+    @TableId
+    private Long id;
+    /**
+     * 用户ID
+     */
+    private Long userId;
+    /**
+     * 对象类型
+     */
+    private String objectType;
+    /**
+     * 对象ID
+     */
+    private Long objectId;
+    /**
+     * 对象角色ID
+     */
+    private Long roleId;
+    /**
+     * 状态（0有效 1失效）
+     */
+    private Integer status;
+    /**
+     * 加入时间
+     */
+    private LocalDateTime joinedTime;
+    /**
+     * 退出时间
+     */
+    private LocalDateTime leftTime;
+    /**
+     * 备注
+     */
+    private String remark;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/dataobject/package-info.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/dataobject/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * 数据对象包
+ */
+package com.njcn.rdms.module.project.dal.dataobject;
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/dataobject/product/ProductDO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/dataobject/product/ProductDO.java
@@ -0,0 +1,51 @@
+package com.njcn.rdms.module.project.dal.dataobject.product;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.njcn.rdms.framework.mybatis.core.dataobject.BaseDO;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * 产品主表
+ */
+@TableName("rdms_product")
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ProductDO extends BaseDO {
+
+    /**
+     * 产品编号
+     */
+    @TableId
+    private Long id;
+    /**
+     * 产品编码
+     */
+    private String code;
+    /**
+     * 产品方向字典值
+     */
+    private String directionCode;
+    /**
+     * 产品状态编码
+     */
+    private String statusCode;
+    /**
+     * 产品名称
+     */
+    private String name;
+    /**
+     * 产品经理用户编号
+     */
+    private Long managerUserId;
+    /**
+     * 产品描述
+     */
+    private String description;
+    /**
+     * 最近一次状态动作原因
+     */
+    private String lastStatusReason;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/dataobject/product/ProductStatusLogDO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/dataobject/product/ProductStatusLogDO.java
@@ -0,0 +1,63 @@
+package com.njcn.rdms.module.project.dal.dataobject.product;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.njcn.rdms.framework.mybatis.core.dataobject.BaseDO;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * 产品状态日志表
+ */
+@TableName("rdms_product_status_log")
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ProductStatusLogDO extends BaseDO {
+
+    /**
+     * 主键ID
+     */
+    @TableId
+    private Long id;
+    /**
+     * 产品ID
+     */
+    private Long productId;
+    /**
+     * 动作类型
+     */
+    private String actionType;
+    /**
+     * 变更前状态编码
+     */
+    private String fromStatus;
+    /**
+     * 变更后状态编码
+     */
+    private String toStatus;
+    /**
+     * 动作原因
+     */
+    private String reason;
+    /**
+     * 操作人用户ID
+     */
+    private Long operatorUserId;
+    /**
+     * 操作人名称快照
+     */
+    private String operatorName;
+    /**
+     * 产品编码快照
+     */
+    private String productCodeSnapshot;
+    /**
+     * 产品名称快照
+     */
+    private String productNameSnapshot;
+    /**
+     * 备注
+     */
+    private String remark;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/dataobject/status/ObjectStatusModelDO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/dataobject/status/ObjectStatusModelDO.java
@@ -0,0 +1,59 @@
+package com.njcn.rdms.module.project.dal.dataobject.status;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.njcn.rdms.framework.mybatis.core.dataobject.BaseDO;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * RDMS对象状态模型表
+ */
+@TableName("rdms_object_status_model")
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ObjectStatusModelDO extends BaseDO {
+
+    /**
+     * 主键ID
+     */
+    @TableId
+    private Long id;
+    /**
+     * 对象类型
+     */
+    private String objectType;
+    /**
+     * 状态编码
+     */
+    private String statusCode;
+    /**
+     * 状态名称
+     */
+    private String statusName;
+    /**
+     * 排序值
+     */
+    private Integer sort;
+    /**
+     * 配置状态
+     */
+    private Integer status;
+    /**
+     * 是否初始状态
+     */
+    private Boolean initialFlag;
+    /**
+     * 是否终态
+     */
+    private Boolean terminalFlag;
+    /**
+     * 是否允许编辑对象主数据
+     */
+    private Boolean allowEdit;
+    /**
+     * 备注
+     */
+    private String remark;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/dataobject/status/ObjectStatusTransitionDO.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/dataobject/status/ObjectStatusTransitionDO.java
@@ -0,0 +1,55 @@
+package com.njcn.rdms.module.project.dal.dataobject.status;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.njcn.rdms.framework.mybatis.core.dataobject.BaseDO;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * RDMS对象状态流转表
+ */
+@TableName("rdms_object_status_transition")
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class ObjectStatusTransitionDO extends BaseDO {
+
+    /**
+     * 主键ID
+     */
+    @TableId
+    private Long id;
+    /**
+     * 对象类型
+     */
+    private String objectType;
+    /**
+     * 动作编码
+     */
+    private String actionCode;
+    /**
+     * 动作名称
+     */
+    private String actionName;
+    /**
+     * 起始状态编码
+     */
+    private String fromStatusCode;
+    /**
+     * 目标状态编码
+     */
+    private String toStatusCode;
+    /**
+     * 是否必须填写原因
+     */
+    private Boolean needReason;
+    /**
+     * 配置状态
+     */
+    private Integer status;
+    /**
+     * 备注
+     */
+    private String remark;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/mysql/audit/BizAuditLogMapper.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/mysql/audit/BizAuditLogMapper.java
@@ -0,0 +1,55 @@
+package com.njcn.rdms.module.project.dal.mysql.audit;
+
+import com.njcn.rdms.framework.mybatis.core.dataobject.BaseDO;
+import com.njcn.rdms.framework.mybatis.core.mapper.BaseMapperX;
+import com.njcn.rdms.framework.mybatis.core.query.LambdaQueryWrapperX;
+import com.njcn.rdms.module.project.dal.dataobject.audit.BizAuditLogDO;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Mapper
+public interface BizAuditLogMapper extends BaseMapperX<BizAuditLogDO> {
+
+    default List<BizAuditLogDO> selectListByBiz(String bizType, Long bizId, String actionType, LocalDateTime[] operateTime) {
+        return selectList(new LambdaQueryWrapperX<BizAuditLogDO>()
+                .eq(BizAuditLogDO::getBizType, bizType)
+                .eq(BizAuditLogDO::getBizId, bizId)
+                .eqIfPresent(BizAuditLogDO::getActionType, actionType)
+                .betweenIfPresent(BaseDO::getCreateTime, operateTime)
+                .orderByDesc(BaseDO::getCreateTime)
+                .orderByDesc(BizAuditLogDO::getId));
+    }
+
+    default List<BizAuditLogDO> selectListByBizAndActions(String bizType, Long bizId, List<String> actionTypes,
+                                                          LocalDateTime startTime, LocalDateTime endTime) {
+        return selectList(new LambdaQueryWrapperX<BizAuditLogDO>()
+                .eq(BizAuditLogDO::getBizType, bizType)
+                .eq(BizAuditLogDO::getBizId, bizId)
+                .inIfPresent(BizAuditLogDO::getActionType, actionTypes)
+                .betweenIfPresent(BaseDO::getCreateTime, startTime, endTime)
+                .orderByDesc(BaseDO::getCreateTime)
+                .orderByDesc(BizAuditLogDO::getId));
+    }
+
+    default List<BizAuditLogDO> selectListByBizType(String bizType, String actionType, LocalDateTime[] operateTime) {
+        return selectList(new LambdaQueryWrapperX<BizAuditLogDO>()
+                .eq(BizAuditLogDO::getBizType, bizType)
+                .eqIfPresent(BizAuditLogDO::getActionType, actionType)
+                .betweenIfPresent(BaseDO::getCreateTime, operateTime)
+                .orderByDesc(BaseDO::getCreateTime)
+                .orderByDesc(BizAuditLogDO::getId));
+    }
+
+    default List<BizAuditLogDO> selectListByBizTypeAndActions(String bizType, List<String> actionTypes,
+                                                              LocalDateTime startTime, LocalDateTime endTime) {
+        return selectList(new LambdaQueryWrapperX<BizAuditLogDO>()
+                .eq(BizAuditLogDO::getBizType, bizType)
+                .inIfPresent(BizAuditLogDO::getActionType, actionTypes)
+                .betweenIfPresent(BaseDO::getCreateTime, startTime, endTime)
+                .orderByDesc(BaseDO::getCreateTime)
+                .orderByDesc(BizAuditLogDO::getId));
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/mysql/member/UserObjectRoleMapper.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/mysql/member/UserObjectRoleMapper.java
@@ -0,0 +1,55 @@
+package com.njcn.rdms.module.project.dal.mysql.member;
+
+import com.njcn.rdms.framework.mybatis.core.mapper.BaseMapperX;
+import com.njcn.rdms.framework.mybatis.core.query.LambdaQueryWrapperX;
+import com.njcn.rdms.module.project.dal.dataobject.member.UserObjectRoleDO;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.Collections;
+import java.util.List;
+
+@Mapper
+public interface UserObjectRoleMapper extends BaseMapperX<UserObjectRoleDO> {
+
+    default List<UserObjectRoleDO> selectListByObject(String objectType, Long objectId) {
+        return selectList(new LambdaQueryWrapperX<UserObjectRoleDO>()
+                .eq(UserObjectRoleDO::getObjectType, objectType)
+                .eq(UserObjectRoleDO::getObjectId, objectId)
+                .orderByAsc(UserObjectRoleDO::getStatus)
+                .orderByAsc(UserObjectRoleDO::getJoinedTime)
+                .orderByAsc(UserObjectRoleDO::getId));
+    }
+
+    default UserObjectRoleDO selectByObjectAndUserId(String objectType, Long objectId, Long userId) {
+        return selectOne(new LambdaQueryWrapperX<UserObjectRoleDO>()
+                .eq(UserObjectRoleDO::getObjectType, objectType)
+                .eq(UserObjectRoleDO::getObjectId, objectId)
+                .eq(UserObjectRoleDO::getUserId, userId));
+    }
+
+    default UserObjectRoleDO selectByIdAndObject(Long id, String objectType, Long objectId) {
+        return selectOne(new LambdaQueryWrapperX<UserObjectRoleDO>()
+                .eq(UserObjectRoleDO::getId, id)
+                .eq(UserObjectRoleDO::getObjectType, objectType)
+                .eq(UserObjectRoleDO::getObjectId, objectId));
+    }
+
+    default UserObjectRoleDO selectActiveByObjectAndUserId(String objectType, Long objectId, Long userId) {
+        return selectOne(new LambdaQueryWrapperX<UserObjectRoleDO>()
+                .eq(UserObjectRoleDO::getObjectType, objectType)
+                .eq(UserObjectRoleDO::getObjectId, objectId)
+                .eq(UserObjectRoleDO::getUserId, userId)
+                .eq(UserObjectRoleDO::getStatus, 0));
+    }
+
+    default List<UserObjectRoleDO> selectListByIdsAndObject(List<Long> ids, String objectType, Long objectId) {
+        if (ids == null || ids.isEmpty()) {
+            return Collections.emptyList();
+        }
+        return selectList(new LambdaQueryWrapperX<UserObjectRoleDO>()
+                .in(UserObjectRoleDO::getId, ids)
+                .eq(UserObjectRoleDO::getObjectType, objectType)
+                .eq(UserObjectRoleDO::getObjectId, objectId));
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/mysql/package-info.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/mysql/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * MyBatis Mapper 包
+ */
+package com.njcn.rdms.module.project.dal.mysql;
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/mysql/product/ProductMapper.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/mysql/product/ProductMapper.java
@@ -0,0 +1,61 @@
+package com.njcn.rdms.module.project.dal.mysql.product;
+
+import com.njcn.rdms.framework.common.pojo.PageResult;
+import com.njcn.rdms.framework.mybatis.core.dataobject.BaseDO;
+import com.njcn.rdms.framework.mybatis.core.mapper.BaseMapperX;
+import com.njcn.rdms.framework.mybatis.core.query.LambdaQueryWrapperX;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductPageReqVO;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductDO;
+import org.apache.ibatis.annotations.Mapper;
+import org.springframework.util.StringUtils;
+
+import java.util.List;
+
+@Mapper
+public interface ProductMapper extends BaseMapperX<ProductDO> {
+
+    default PageResult<ProductDO> selectPage(ProductPageReqVO reqVO) {
+        LambdaQueryWrapperX<ProductDO> queryWrapper = new LambdaQueryWrapperX<>();
+        if (StringUtils.hasText(reqVO.getKeyword())) {
+            queryWrapper.and(wrapper -> wrapper.like(ProductDO::getCode, reqVO.getKeyword())
+                    .or()
+                    .like(ProductDO::getName, reqVO.getKeyword()));
+        }
+        queryWrapper.eqIfPresent(ProductDO::getDirectionCode, reqVO.getDirectionCode())
+                .eqIfPresent(ProductDO::getManagerUserId, reqVO.getManagerUserId())
+                .eqIfPresent(ProductDO::getStatusCode, reqVO.getStatusCode())
+                .betweenIfPresent(BaseDO::getUpdateTime, reqVO.getUpdateTime())
+                .orderByDesc(BaseDO::getUpdateTime);
+        return selectPage(reqVO, queryWrapper);
+    }
+
+    default ProductDO selectByCode(String code) {
+        return selectOne(ProductDO::getCode, code);
+    }
+
+    default ProductDO selectByName(String name) {
+        return selectOne(ProductDO::getName, name);
+    }
+
+    default List<ProductDO> selectListByCodePrefix(String codePrefix) {
+        return selectList(new LambdaQueryWrapperX<ProductDO>()
+                .likeRight(ProductDO::getCode, codePrefix)
+                .orderByDesc(ProductDO::getCode));
+    }
+
+    default int updateStatusByIdAndStatus(Long id, String fromStatus, String toStatus, String lastStatusReason) {
+        ProductDO update = new ProductDO();
+        update.setStatusCode(toStatus);
+        update.setLastStatusReason(lastStatusReason);
+        return update(update, new LambdaQueryWrapperX<ProductDO>()
+                .eq(ProductDO::getId, id)
+                .eq(ProductDO::getStatusCode, fromStatus));
+    }
+
+    default int deleteByIdAndStatus(Long id, String statusCode) {
+        return delete(new LambdaQueryWrapperX<ProductDO>()
+                .eq(ProductDO::getId, id)
+                .eq(ProductDO::getStatusCode, statusCode));
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/mysql/product/ProductStatusLogMapper.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/mysql/product/ProductStatusLogMapper.java
@@ -0,0 +1,34 @@
+package com.njcn.rdms.module.project.dal.mysql.product;
+
+import com.njcn.rdms.framework.mybatis.core.dataobject.BaseDO;
+import com.njcn.rdms.framework.mybatis.core.mapper.BaseMapperX;
+import com.njcn.rdms.framework.mybatis.core.query.LambdaQueryWrapperX;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductStatusLogDO;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+@Mapper
+public interface ProductStatusLogMapper extends BaseMapperX<ProductStatusLogDO> {
+
+    default List<ProductStatusLogDO> selectListByProductId(Long productId, String actionType, LocalDateTime[] operateTime) {
+        return selectList(new LambdaQueryWrapperX<ProductStatusLogDO>()
+                .eq(ProductStatusLogDO::getProductId, productId)
+                .eqIfPresent(ProductStatusLogDO::getActionType, actionType)
+                .betweenIfPresent(BaseDO::getCreateTime, operateTime)
+                .orderByDesc(BaseDO::getCreateTime)
+                .orderByDesc(ProductStatusLogDO::getId));
+    }
+
+    default List<ProductStatusLogDO> selectListByProductIdAndActions(Long productId, List<String> actionTypes,
+                                                                     LocalDateTime startTime, LocalDateTime endTime) {
+        return selectList(new LambdaQueryWrapperX<ProductStatusLogDO>()
+                .eq(ProductStatusLogDO::getProductId, productId)
+                .inIfPresent(ProductStatusLogDO::getActionType, actionTypes)
+                .betweenIfPresent(BaseDO::getCreateTime, startTime, endTime)
+                .orderByDesc(BaseDO::getCreateTime)
+                .orderByDesc(ProductStatusLogDO::getId));
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/mysql/status/ObjectStatusModelMapper.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/mysql/status/ObjectStatusModelMapper.java
@@ -0,0 +1,32 @@
+package com.njcn.rdms.module.project.dal.mysql.status;
+
+import com.njcn.rdms.framework.mybatis.core.mapper.BaseMapperX;
+import com.njcn.rdms.framework.mybatis.core.query.LambdaQueryWrapperX;
+import com.njcn.rdms.module.project.dal.dataobject.status.ObjectStatusModelDO;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+
+@Mapper
+public interface ObjectStatusModelMapper extends BaseMapperX<ObjectStatusModelDO> {
+
+    default ObjectStatusModelDO selectByObjectTypeAndStatusCode(String objectType, String statusCode) {
+        return selectOne(new LambdaQueryWrapperX<ObjectStatusModelDO>()
+                .eq(ObjectStatusModelDO::getObjectType, objectType)
+                .eq(ObjectStatusModelDO::getStatusCode, statusCode));
+    }
+
+    default ObjectStatusModelDO selectByObjectTypeAndStatusCodeEnabled(String objectType, String statusCode) {
+        return selectOne(new LambdaQueryWrapperX<ObjectStatusModelDO>()
+                .eq(ObjectStatusModelDO::getObjectType, objectType)
+                .eq(ObjectStatusModelDO::getStatusCode, statusCode)
+                .eq(ObjectStatusModelDO::getStatus, 0));
+    }
+
+    default List<ObjectStatusModelDO> selectListByObjectType(String objectType) {
+        return selectList(new LambdaQueryWrapperX<ObjectStatusModelDO>()
+                .eq(ObjectStatusModelDO::getObjectType, objectType)
+                .orderByAsc(ObjectStatusModelDO::getSort));
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/mysql/status/ObjectStatusTransitionMapper.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/mysql/status/ObjectStatusTransitionMapper.java
@@ -0,0 +1,30 @@
+package com.njcn.rdms.module.project.dal.mysql.status;
+
+import com.njcn.rdms.framework.mybatis.core.mapper.BaseMapperX;
+import com.njcn.rdms.framework.mybatis.core.query.LambdaQueryWrapperX;
+import com.njcn.rdms.module.project.dal.dataobject.status.ObjectStatusTransitionDO;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+
+@Mapper
+public interface ObjectStatusTransitionMapper extends BaseMapperX<ObjectStatusTransitionDO> {
+
+    default ObjectStatusTransitionDO selectByObjectTypeAndFromStatusAndAction(String objectType,
+                                                                              String fromStatusCode,
+                                                                              String actionCode) {
+        return selectOne(new LambdaQueryWrapperX<ObjectStatusTransitionDO>()
+                .eq(ObjectStatusTransitionDO::getObjectType, objectType)
+                .eq(ObjectStatusTransitionDO::getFromStatusCode, fromStatusCode)
+                .eq(ObjectStatusTransitionDO::getActionCode, actionCode)
+                .eq(ObjectStatusTransitionDO::getStatus, 0));
+    }
+
+    default List<ObjectStatusTransitionDO> selectListByObjectTypeAndFromStatus(String objectType, String fromStatusCode) {
+        return selectList(new LambdaQueryWrapperX<ObjectStatusTransitionDO>()
+                .eq(ObjectStatusTransitionDO::getObjectType, objectType)
+                .eq(ObjectStatusTransitionDO::getFromStatusCode, fromStatusCode)
+                .eq(ObjectStatusTransitionDO::getStatus, 0));
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/package-info.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/dal/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * 持久层包
+ */
+package com.njcn.rdms.module.project.dal;
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/framework/rpc/config/RpcConfiguration.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/framework/rpc/config/RpcConfiguration.java
@@ -0,0 +1,14 @@
+package com.njcn.rdms.module.project.framework.rpc.config;
+
+import com.njcn.rdms.module.system.api.permission.ObjectPermissionApi;
+import com.njcn.rdms.module.system.api.user.AdminUserApi;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+import org.springframework.context.annotation.Configuration;
+
+/**
+ * Project 模块的 RPC 配置
+ */
+@Configuration(value = "projectRpcConfiguration", proxyBeanMethods = false)
+@EnableFeignClients(clients = {AdminUserApi.class, ObjectPermissionApi.class})
+public class RpcConfiguration {
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/framework/security/annotation/CheckObjectPermission.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/framework/security/annotation/CheckObjectPermission.java
@@ -0,0 +1,35 @@
+package com.njcn.rdms.module.project.framework.security.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * 对象级权限校验注解。
+ */
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface CheckObjectPermission {
+
+    /**
+     * 对象类型，例如 product。
+     */
+    String objectType();
+
+    /**
+     * 对象编号 SpEL 表达式。
+     */
+    String objectId();
+
+    /**
+     * 对象权限码。
+     */
+    String permission() default "";
+
+    /**
+     * 是否仅校验成员身份。
+     */
+    boolean memberOnly() default false;
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/framework/security/aop/ObjectPermissionAspect.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/framework/security/aop/ObjectPermissionAspect.java
@@ -0,0 +1,67 @@
+package com.njcn.rdms.module.project.framework.security.aop;
+
+import com.njcn.rdms.framework.common.util.spring.SpringExpressionUtils;
+import com.njcn.rdms.module.project.framework.security.annotation.CheckObjectPermission;
+import com.njcn.rdms.module.project.framework.security.service.ObjectPermissionService;
+import lombok.extern.slf4j.Slf4j;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static com.njcn.rdms.framework.common.exception.util.ServiceExceptionUtil.invalidParamException;
+
+/**
+ * 对象级权限切面。
+ */
+@Aspect
+@Component
+@Slf4j
+public class ObjectPermissionAspect {
+
+    private final Map<String, ObjectPermissionService> objectPermissionServiceMap;
+
+    public ObjectPermissionAspect(List<ObjectPermissionService> objectPermissionServices) {
+        this.objectPermissionServiceMap = objectPermissionServices.stream()
+                .collect(Collectors.toMap(ObjectPermissionService::getObjectType, Function.identity()));
+    }
+
+    @Around("@annotation(checkObjectPermission)")
+    public Object aroundPointCut(ProceedingJoinPoint joinPoint,
+                                 CheckObjectPermission checkObjectPermission) throws Throwable {
+        ObjectPermissionService permissionService = objectPermissionServiceMap.get(checkObjectPermission.objectType());
+        if (permissionService == null) {
+            throw invalidParamException("暂不支持对象类型：{}", checkObjectPermission.objectType());
+        }
+        Long objectId = resolveObjectId(joinPoint, checkObjectPermission.objectId());
+        permissionService.checkPermission(objectId, checkObjectPermission.permission(),
+                checkObjectPermission.memberOnly());
+        return joinPoint.proceed();
+    }
+
+    private Long resolveObjectId(ProceedingJoinPoint joinPoint, String expression) {
+        Object parsedValue = SpringExpressionUtils.parseExpression(joinPoint, expression);
+        if (parsedValue instanceof Number number) {
+            return number.longValue();
+        }
+        if (parsedValue instanceof String value && StringUtils.hasText(value)) {
+            try {
+                return Long.parseLong(value.trim());
+            } catch (NumberFormatException ex) {
+                log.warn("[resolveObjectId][expression({}) value({}) 不是合法数字]", expression, value);
+            }
+        }
+        if (Objects.isNull(parsedValue)) {
+            throw invalidParamException("对象编号不能为空");
+        }
+        throw invalidParamException("对象编号解析失败：{}", expression);
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/framework/security/config/SecurityConfiguration.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/framework/security/config/SecurityConfiguration.java
@@ -0,0 +1,39 @@
+package com.njcn.rdms.module.project.framework.security.config;
+
+import com.njcn.rdms.framework.security.config.AuthorizeRequestsCustomizer;
+import com.njcn.rdms.module.project.enums.ApiConstants;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configurers.AuthorizeHttpRequestsConfigurer;
+
+/**
+ * Project 模块的 Security 配置
+ */
+@Configuration(proxyBeanMethods = false, value = "projectSecurityConfiguration")
+public class SecurityConfiguration {
+
+    @Bean("projectAuthorizeRequestsCustomizer")
+    public AuthorizeRequestsCustomizer authorizeRequestsCustomizer() {
+        return new AuthorizeRequestsCustomizer() {
+
+            @Override
+            public void customize(AuthorizeHttpRequestsConfigurer<HttpSecurity>.AuthorizationManagerRequestMatcherRegistry registry) {
+                // Swagger 接口文档
+                registry.requestMatchers("/v3/api-docs/**").permitAll()
+                        .requestMatchers("/webjars/**").permitAll()
+                        .requestMatchers("/swagger-ui").permitAll()
+                        .requestMatchers("/swagger-ui/**").permitAll();
+                // Druid 监控
+                registry.requestMatchers("/druid/**").permitAll();
+                // Spring Boot Actuator 的安全配置
+                registry.requestMatchers("/actuator").permitAll()
+                        .requestMatchers("/actuator/**").permitAll();
+                // RPC 服务的安全配置
+                registry.requestMatchers(ApiConstants.PREFIX + "/**").permitAll();
+            }
+
+        };
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/framework/security/service/ObjectPermissionService.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/framework/security/service/ObjectPermissionService.java
@@ -0,0 +1,22 @@
+package com.njcn.rdms.module.project.framework.security.service;
+
+/**
+ * 对象级权限服务。
+ */
+public interface ObjectPermissionService {
+
+    /**
+     * 返回支持的对象类型。
+     */
+    String getObjectType();
+
+    /**
+     * 校验当前登录用户是否具备对象权限。
+     *
+     * @param objectId 对象编号
+     * @param permission 权限码
+     * @param memberOnly 是否只要求成员身份
+     */
+    void checkPermission(Long objectId, String permission, boolean memberOnly);
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/framework/security/service/ProductObjectPermissionService.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/framework/security/service/ProductObjectPermissionService.java
@@ -0,0 +1,85 @@
+package com.njcn.rdms.module.project.framework.security.service;
+
+import com.njcn.rdms.framework.security.core.util.SecurityFrameworkUtils;
+import com.njcn.rdms.module.project.dal.dataobject.member.UserObjectRoleDO;
+import com.njcn.rdms.module.project.dal.mysql.member.UserObjectRoleMapper;
+import com.njcn.rdms.module.project.enums.ErrorCodeConstants;
+import com.njcn.rdms.module.system.api.permission.ObjectPermissionApi;
+import com.njcn.rdms.module.system.enums.permission.PermissionScopeTypeEnum;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static com.njcn.rdms.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static com.njcn.rdms.framework.common.exception.util.ServiceExceptionUtil.invalidParamException;
+
+/**
+ * 产品对象权限服务。
+ */
+@Service
+public class ProductObjectPermissionService implements ObjectPermissionService {
+
+    private static final String PRODUCT_OBJECT_TYPE = "product";
+    private static final String ROLE_SCOPE_OBJECT = PermissionScopeTypeEnum.OBJECT.getScopeType();
+
+    @Resource
+    private UserObjectRoleMapper userObjectRoleMapper;
+    @Resource
+    private ObjectPermissionApi objectPermissionApi;
+
+    @Override
+    public String getObjectType() {
+        return PRODUCT_OBJECT_TYPE;
+    }
+
+    @Override
+    public void checkPermission(Long objectId, String permission, boolean memberOnly) {
+        if (objectId == null) {
+            throw invalidParamException("对象编号不能为空");
+        }
+        Long loginUserId = SecurityFrameworkUtils.getLoginUserId();
+        UserObjectRoleDO currentMember = userObjectRoleMapper
+                .selectActiveByObjectAndUserId(PRODUCT_OBJECT_TYPE, objectId, loginUserId);
+        if (currentMember == null) {
+            throw exception(ErrorCodeConstants.PRODUCT_OBJECT_PERMISSION_DENIED,
+                    buildDeniedPermission(permission, memberOnly));
+        }
+        if (memberOnly) {
+            return;
+        }
+        String normalizedPermission = normalizePermission(permission);
+        if (!getRolePermissions(currentMember.getRoleId()).contains(normalizedPermission)) {
+            throw exception(ErrorCodeConstants.PRODUCT_OBJECT_PERMISSION_DENIED, normalizedPermission);
+        }
+    }
+
+    private Set<String> getRolePermissions(Long roleId) {
+        Set<String> permissions = objectPermissionApi
+                .getObjectRolePermissions(roleId, ROLE_SCOPE_OBJECT, PRODUCT_OBJECT_TYPE)
+                .getCheckedData();
+        if (permissions == null || permissions.isEmpty()) {
+            return Collections.emptySet();
+        }
+        return permissions.stream()
+                .filter(StringUtils::hasText)
+                .map(String::trim)
+                .collect(Collectors.toCollection(LinkedHashSet::new));
+    }
+
+    private String normalizePermission(String permission) {
+        if (!StringUtils.hasText(permission)) {
+            throw invalidParamException("对象权限码不能为空");
+        }
+        return permission.trim();
+    }
+
+    private String buildDeniedPermission(String permission, boolean memberOnly) {
+        return memberOnly ? "member" : normalizePermission(permission);
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/package-info.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * 服务层包
+ */
+package com.njcn.rdms.module.project.service;
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductActivityQueryService.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductActivityQueryService.java
@@ -0,0 +1,305 @@
+package com.njcn.rdms.module.project.service.product;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.njcn.rdms.framework.common.pojo.PageResult;
+import com.njcn.rdms.framework.common.util.json.JsonUtils;
+import com.njcn.rdms.framework.common.util.object.PageUtils;
+import com.njcn.rdms.module.project.constant.ObjectActivityConstants;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityPageReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityRespVO;
+import com.njcn.rdms.module.project.dal.dataobject.audit.BizAuditLogDO;
+import com.njcn.rdms.module.project.dal.dataobject.member.UserObjectRoleDO;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductStatusLogDO;
+import com.njcn.rdms.module.project.dal.mysql.audit.BizAuditLogMapper;
+import com.njcn.rdms.module.project.dal.mysql.member.UserObjectRoleMapper;
+import com.njcn.rdms.module.project.dal.mysql.product.ProductStatusLogMapper;
+import com.njcn.rdms.module.system.api.permission.ObjectPermissionApi;
+import com.njcn.rdms.module.system.api.permission.dto.ObjectRoleRespDTO;
+import jakarta.annotation.Resource;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+@Service
+public class ProductActivityQueryService {
+
+    private static final String PRODUCT_OBJECT_TYPE = ObjectActivityConstants.PRODUCT_BIZ_TYPE;
+    private static final String MEMBER_BIZ_TYPE = ObjectActivityConstants.MEMBER_BIZ_TYPE;
+    private static final String ACTIVITY_ROLE_NAME_CACHE = "project_activity_role_name#10m";
+    private static final String ROLE_SCOPE_OBJECT = "object";
+
+    @Resource
+    private ProductStatusLogMapper productStatusLogMapper;
+    @Resource
+    private BizAuditLogMapper bizAuditLogMapper;
+    @Resource
+    private UserObjectRoleMapper userObjectRoleMapper;
+    @Resource
+    private CacheManager cacheManager;
+    @Resource
+    private ObjectPermissionApi objectPermissionApi;
+
+    public PageResult<ProductActivityRespVO> getProductActivities(Long productId, ProductActivityPageReqVO reqVO) {
+        List<ActivityItem> items = new ArrayList<>();
+        if (includeType(reqVO.getActivityType(), ObjectActivityConstants.ACTIVITY_TYPE_STATUS)) {
+            productStatusLogMapper.selectListByProductId(productId, reqVO.getActionType(), reqVO.getOperateTime())
+                    .forEach(log -> items.add(new ActivityItem(log.getId(), log.getCreateTime(), toStatusActivity(log))));
+        }
+        if (includeType(reqVO.getActivityType(), ObjectActivityConstants.ACTIVITY_TYPE_PRODUCT)) {
+            bizAuditLogMapper.selectListByBiz(PRODUCT_OBJECT_TYPE, productId, reqVO.getActionType(), reqVO.getOperateTime())
+                    .forEach(log -> items.add(new ActivityItem(log.getId(), log.getCreateTime(), toProductActivity(log))));
+        }
+        if (includeType(reqVO.getActivityType(), ObjectActivityConstants.ACTIVITY_TYPE_MEMBER)) {
+            appendMemberActivities(productId, reqVO, items);
+        }
+
+        items.sort(Comparator.comparing(ActivityItem::operateTime, Comparator.nullsLast(LocalDateTime::compareTo))
+                .thenComparing(ActivityItem::sourceId, Comparator.nullsLast(Long::compareTo))
+                .reversed());
+
+        List<ProductActivityRespVO> activities = items.stream()
+                .map(ActivityItem::respVO)
+                .toList();
+        PageResult<ProductActivityRespVO> pageResult = buildPageResult(activities, reqVO);
+        fillMemberRoleNames(pageResult.getList());
+        return pageResult;
+    }
+
+    private void appendMemberActivities(Long productId, ProductActivityPageReqVO reqVO, List<ActivityItem> items) {
+        List<BizAuditLogDO> memberLogs = bizAuditLogMapper
+                .selectListByBizType(MEMBER_BIZ_TYPE, reqVO.getActionType(), reqVO.getOperateTime());
+        if (memberLogs.isEmpty()) {
+            return;
+        }
+
+        List<Long> memberIds = memberLogs.stream()
+                .map(BizAuditLogDO::getBizId)
+                .filter(Objects::nonNull)
+                .distinct()
+                .toList();
+        if (memberIds.isEmpty()) {
+            return;
+        }
+
+        Map<Long, UserObjectRoleDO> memberMap = userObjectRoleMapper
+                .selectListByIdsAndObject(memberIds, PRODUCT_OBJECT_TYPE, productId)
+                .stream()
+                .collect(Collectors.toMap(UserObjectRoleDO::getId, Function.identity()));
+        memberLogs.stream()
+                .filter(log -> memberMap.containsKey(log.getBizId()))
+                .forEach(log -> items.add(new ActivityItem(log.getId(), log.getCreateTime(), toMemberActivity(log))));
+    }
+
+    private PageResult<ProductActivityRespVO> buildPageResult(List<ProductActivityRespVO> activities,
+                                                              ProductActivityPageReqVO reqVO) {
+        if (activities.isEmpty()) {
+            return PageResult.empty();
+        }
+        int start = PageUtils.getStart(reqVO);
+        if (start >= activities.size()) {
+            return PageResult.empty((long) activities.size());
+        }
+        int end = Math.min(start + reqVO.getPageSize(), activities.size());
+        return new PageResult<>(activities.subList(start, end), (long) activities.size());
+    }
+
+    private void fillMemberRoleNames(List<ProductActivityRespVO> activities) {
+        if (activities == null || activities.isEmpty()) {
+            return;
+        }
+        Set<Long> roleIds = new LinkedHashSet<>();
+        for (ProductActivityRespVO activity : activities) {
+            if (!Objects.equals(activity.getType(), ObjectActivityConstants.ACTIVITY_TYPE_MEMBER)) {
+                continue;
+            }
+            Long beforeRoleId = getFieldChangeLong(activity.getDetails(), "roleId", "before");
+            Long afterRoleId = getFieldChangeLong(activity.getDetails(), "roleId", "after");
+            if (beforeRoleId != null) {
+                roleIds.add(beforeRoleId);
+            }
+            if (afterRoleId != null) {
+                roleIds.add(afterRoleId);
+            }
+        }
+        if (roleIds.isEmpty()) {
+            return;
+        }
+        Map<Long, String> roleNameMap = loadRoleNameMap(roleIds);
+        for (ProductActivityRespVO activity : activities) {
+            if (!Objects.equals(activity.getType(), ObjectActivityConstants.ACTIVITY_TYPE_MEMBER)) {
+                continue;
+            }
+            activity.setDetails(appendRoleNames(activity.getDetails(), roleNameMap));
+        }
+    }
+
+    private Map<Long, String> loadRoleNameMap(Set<Long> roleIds) {
+        Map<Long, String> roleNameMap = new LinkedHashMap<>();
+        if (roleIds == null || roleIds.isEmpty()) {
+            return roleNameMap;
+        }
+        Cache cache = cacheManager == null ? null : cacheManager.getCache(ACTIVITY_ROLE_NAME_CACHE);
+        Set<Long> missIds = new LinkedHashSet<>();
+        for (Long roleId : roleIds) {
+            String roleName = cache == null ? null : cache.get(roleId, String.class);
+            if (roleName != null) {
+                roleNameMap.put(roleId, roleName);
+            } else {
+                missIds.add(roleId);
+            }
+        }
+        if (missIds.isEmpty()) {
+            return roleNameMap;
+        }
+        Map<Long, ObjectRoleRespDTO> roleMap = objectPermissionApi == null ? Map.of()
+                : objectPermissionApi.getObjectRoleMap(missIds, ROLE_SCOPE_OBJECT, PRODUCT_OBJECT_TYPE);
+        if (roleMap == null || roleMap.isEmpty()) {
+            return roleNameMap;
+        }
+        for (Long roleId : missIds) {
+            ObjectRoleRespDTO role = roleMap.get(roleId);
+            if (role == null || !StringUtils.hasText(role.getName())) {
+                continue;
+            }
+            roleNameMap.put(roleId, role.getName());
+            if (cache != null) {
+                cache.put(roleId, role.getName());
+            }
+        }
+        return roleNameMap;
+    }
+
+    private Long getFieldChangeLong(String fieldChanges, String fieldName, String valueField) {
+        JsonNode valueNode = getFieldChangeNode(fieldChanges, fieldName, valueField);
+        if (valueNode == null || valueNode.isNull()) {
+            return null;
+        }
+        if (valueNode.isNumber()) {
+            return valueNode.longValue();
+        }
+        if (valueNode.isTextual() && StringUtils.hasText(valueNode.textValue())) {
+            return Long.valueOf(valueNode.textValue().trim());
+        }
+        return null;
+    }
+
+    private JsonNode getFieldChangeNode(String fieldChanges, String fieldName, String valueField) {
+        if (!StringUtils.hasText(fieldChanges) || !JsonUtils.isJsonObject(fieldChanges)) {
+            return null;
+        }
+        JsonNode fieldNode = JsonUtils.parseTree(fieldChanges).path(fieldName);
+        if (fieldNode.isMissingNode()) {
+            return null;
+        }
+        JsonNode valueNode = fieldNode.path(valueField);
+        return valueNode.isMissingNode() ? null : valueNode;
+    }
+
+    private String appendRoleNames(String details, Map<Long, String> roleNameMap) {
+        if (!StringUtils.hasText(details) || !JsonUtils.isJsonObject(details)) {
+            return details;
+        }
+        Long beforeRoleId = getFieldChangeLong(details, "roleId", "before");
+        Long afterRoleId = getFieldChangeLong(details, "roleId", "after");
+        if (beforeRoleId == null && afterRoleId == null) {
+            return details;
+        }
+        JsonNode detailsNode = JsonUtils.parseTree(details);
+        if (!(detailsNode instanceof ObjectNode)) {
+            return details;
+        }
+        ObjectNode objectNode = ((ObjectNode) detailsNode).deepCopy();
+        ObjectNode roleNameNode = objectNode.putObject("roleName");
+        appendRoleName(roleNameNode, "before", beforeRoleId, roleNameMap);
+        appendRoleName(roleNameNode, "after", afterRoleId, roleNameMap);
+        return JsonUtils.toJsonString(objectNode);
+    }
+
+    private void appendRoleName(ObjectNode roleNameNode, String fieldName, Long roleId, Map<Long, String> roleNameMap) {
+        if (roleId == null) {
+            roleNameNode.putNull(fieldName);
+            return;
+        }
+        String roleName = roleNameMap.get(roleId);
+        if (StringUtils.hasText(roleName)) {
+            roleNameNode.put(fieldName, roleName);
+            return;
+        }
+        roleNameNode.putNull(fieldName);
+    }
+
+    private boolean includeType(String actual, String expected) {
+        return !StringUtils.hasText(actual) || Objects.equals(actual.trim(), expected);
+    }
+
+    private ProductActivityRespVO toStatusActivity(ProductStatusLogDO log) {
+        ProductActivityRespVO respVO = new ProductActivityRespVO();
+        respVO.setType(ObjectActivityConstants.ACTIVITY_TYPE_STATUS);
+        respVO.setActionType(log.getActionType());
+        respVO.setActionName(ObjectActivityConstants.resolveActionName(log.getActionType()));
+        respVO.setFromStatus(log.getFromStatus());
+        respVO.setToStatus(log.getToStatus());
+        respVO.setReason(log.getReason());
+        respVO.setOperatorUserId(log.getOperatorUserId());
+        respVO.setOperatorName(log.getOperatorName());
+        respVO.setOperateTime(log.getCreateTime());
+        respVO.setSummary(buildSummary(log.getOperatorName(), respVO.getActionName(), log.getReason()));
+        respVO.setDetails(JsonUtils.toJsonString(buildStatusDetails(log)));
+        return respVO;
+    }
+
+    private Map<String, Object> buildStatusDetails(ProductStatusLogDO log) {
+        Map<String, Object> details = new LinkedHashMap<>();
+        details.put("productCodeSnapshot", log.getProductCodeSnapshot());
+        details.put("productNameSnapshot", log.getProductNameSnapshot());
+        return details;
+    }
+
+    private ProductActivityRespVO toProductActivity(BizAuditLogDO log) {
+        ProductActivityRespVO respVO = new ProductActivityRespVO();
+        respVO.setType(ObjectActivityConstants.ACTIVITY_TYPE_PRODUCT);
+        respVO.setActionType(log.getActionType());
+        respVO.setActionName(ObjectActivityConstants.resolveActionName(log.getActionType()));
+        respVO.setFromStatus(log.getFromStatus());
+        respVO.setToStatus(log.getToStatus());
+        respVO.setReason(log.getReason());
+        respVO.setOperatorUserId(log.getOperatorUserId());
+        respVO.setOperatorName(log.getOperatorName());
+        respVO.setOperateTime(log.getCreateTime());
+        respVO.setSummary(buildSummary(log.getOperatorName(), respVO.getActionName(), log.getReason()));
+        respVO.setDetails(log.getFieldChanges());
+        return respVO;
+    }
+
+    private ProductActivityRespVO toMemberActivity(BizAuditLogDO log) {
+        ProductActivityRespVO respVO = toProductActivity(log);
+        respVO.setType(ObjectActivityConstants.ACTIVITY_TYPE_MEMBER);
+        return respVO;
+    }
+
+    private String buildSummary(String operatorName, String actionName, String reason) {
+        String actualOperatorName = StringUtils.hasText(operatorName) ? operatorName : "系统";
+        if (StringUtils.hasText(reason)) {
+            return String.format("%s执行了【%s】：%s", actualOperatorName, actionName, reason);
+        }
+        return String.format("%s执行了【%s】", actualOperatorName, actionName);
+    }
+
+    private record ActivityItem(Long sourceId, LocalDateTime operateTime, ProductActivityRespVO respVO) {
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductActivityTimelineQueryService.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductActivityTimelineQueryService.java
@@ -0,0 +1,522 @@
+package com.njcn.rdms.module.project.service.product;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.njcn.rdms.framework.common.pojo.PageResult;
+import com.njcn.rdms.framework.common.util.json.JsonUtils;
+import com.njcn.rdms.framework.common.util.object.PageUtils;
+import com.njcn.rdms.module.project.constant.ObjectActivityConstants;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityTimelinePageReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityTimelineRespVO;
+import com.njcn.rdms.module.project.dal.dataobject.audit.BizAuditLogDO;
+import com.njcn.rdms.module.project.dal.dataobject.member.UserObjectRoleDO;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductStatusLogDO;
+import com.njcn.rdms.module.project.dal.mysql.audit.BizAuditLogMapper;
+import com.njcn.rdms.module.project.dal.mysql.member.UserObjectRoleMapper;
+import com.njcn.rdms.module.project.dal.mysql.product.ProductStatusLogMapper;
+import com.njcn.rdms.module.system.api.permission.ObjectPermissionApi;
+import com.njcn.rdms.module.system.api.permission.dto.ObjectRoleRespDTO;
+import com.njcn.rdms.module.system.api.user.AdminUserApi;
+import com.njcn.rdms.module.system.api.user.dto.AdminUserRespDTO;
+import jakarta.annotation.Resource;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+import static com.njcn.rdms.framework.common.exception.util.ServiceExceptionUtil.invalidParamException;
+
+@Service
+public class ProductActivityTimelineQueryService {
+
+    /**
+     * 成员名称在读取时间线时再通过缓存转换，避免把昵称快照写进动态记录。
+     */
+    private static final String TIMELINE_USER_NICKNAME_CACHE = "project_timeline_user_nickname#10m";
+    private static final String TIMELINE_ROLE_NAME_CACHE = "project_timeline_role_name#10m";
+    private static final String ROLE_SCOPE_OBJECT = "object";
+    private static final String PRODUCT_OBJECT_TYPE = ObjectActivityConstants.PRODUCT_BIZ_TYPE;
+
+    @Resource
+    private ProductStatusLogMapper productStatusLogMapper;
+    @Resource
+    private BizAuditLogMapper bizAuditLogMapper;
+    @Resource
+    private UserObjectRoleMapper userObjectRoleMapper;
+    @Resource
+    private CacheManager cacheManager;
+    @Resource
+    private AdminUserApi adminUserApi;
+    @Resource
+    private ObjectPermissionApi objectPermissionApi;
+
+    public PageResult<ProductActivityTimelineRespVO> getProductActivityTimelinePage(
+            Long productId, ProductActivityTimelinePageReqVO reqVO) {
+        LocalDateTime[] timeRange = buildTimeRange(reqVO);
+        List<String> actionTypes = normalizeActionTypes(reqVO.getActionTypes());
+        List<ActivityItem> items = new ArrayList<>();
+
+        appendStatusActivities(productId, reqVO.getActivityType(), actionTypes, timeRange, items);
+        appendProductActivities(productId, reqVO.getActivityType(), actionTypes, timeRange, items);
+        appendMemberActivities(productId, reqVO.getActivityType(), actionTypes, timeRange, items);
+
+        items.sort(Comparator.comparing(ActivityItem::occurredAt, Comparator.nullsLast(LocalDateTime::compareTo))
+                .thenComparing(ActivityItem::sourceId, Comparator.nullsLast(Long::compareTo))
+                .reversed());
+        PageResult<ProductActivityTimelineRespVO> pageResult =
+                buildPageResult(items.stream().map(ActivityItem::respVO).toList(), reqVO);
+        fillTargetUserNames(pageResult.getList());
+        fillMemberRoleNames(pageResult.getList());
+        return pageResult;
+    }
+
+    private void appendStatusActivities(Long productId, String activityType, List<String> actionTypes,
+                                        LocalDateTime[] timeRange, List<ActivityItem> items) {
+        if (!includeType(activityType, ObjectActivityConstants.ACTIVITY_TYPE_STATUS)) {
+            return;
+        }
+        List<String> statusActions = limitActions(actionTypes, ObjectActivityConstants.STATUS_ACTION_TYPES);
+        if (shouldSkipByIntersection(actionTypes, statusActions)) {
+            return;
+        }
+        productStatusLogMapper.selectListByProductIdAndActions(productId, statusActions, timeRange[0], timeRange[1])
+                .forEach(log -> items.add(new ActivityItem(log.getId(), log.getCreateTime(), toStatusTimeline(log))));
+    }
+
+    private void appendProductActivities(Long productId, String activityType, List<String> actionTypes,
+                                         LocalDateTime[] timeRange, List<ActivityItem> items) {
+        if (!includeType(activityType, ObjectActivityConstants.ACTIVITY_TYPE_PRODUCT)) {
+            return;
+        }
+        List<String> productActions = limitActions(actionTypes, ObjectActivityConstants.PRODUCT_TIMELINE_ACTION_TYPES);
+        if (shouldSkipByIntersection(actionTypes, productActions)) {
+            return;
+        }
+        List<BizAuditLogDO> productLogs = bizAuditLogMapper.selectListByBizAndActions(
+                ObjectActivityConstants.PRODUCT_BIZ_TYPE, productId, productActions, timeRange[0], timeRange[1]);
+        Set<CreateSignature> createSignatures = buildCreateSignatures(productLogs);
+        for (BizAuditLogDO log : productLogs) {
+            if (ObjectActivityConstants.isStatusAction(log.getActionType())) {
+                continue;
+            }
+            if (isCreateInitManagerNoise(log, createSignatures)) {
+                continue;
+            }
+            if (!ObjectActivityConstants.PRODUCT_TIMELINE_ACTION_TYPES.contains(trim(log.getActionType()))) {
+                continue;
+            }
+            items.add(new ActivityItem(log.getId(), log.getCreateTime(), toProductTimeline(log)));
+        }
+    }
+
+    private void appendMemberActivities(Long productId, String activityType, List<String> actionTypes,
+                                        LocalDateTime[] timeRange, List<ActivityItem> items) {
+        if (!includeType(activityType, ObjectActivityConstants.ACTIVITY_TYPE_MEMBER)) {
+            return;
+        }
+        List<String> memberActions = limitActions(actionTypes, ObjectActivityConstants.MEMBER_TIMELINE_ACTION_TYPES);
+        if (shouldSkipByIntersection(actionTypes, memberActions)) {
+            return;
+        }
+        List<BizAuditLogDO> memberLogs = bizAuditLogMapper.selectListByBizTypeAndActions(
+                ObjectActivityConstants.MEMBER_BIZ_TYPE, memberActions, timeRange[0], timeRange[1]);
+        if (memberLogs.isEmpty()) {
+            return;
+        }
+        Map<Long, UserObjectRoleDO> memberMap = loadMemberMap(productId, memberLogs);
+        Set<CreateSignature> createSignatures = loadCreateSignatures(productId, timeRange);
+        for (BizAuditLogDO log : memberLogs) {
+            UserObjectRoleDO member = memberMap.get(log.getBizId());
+            if (member == null) {
+                continue;
+            }
+            if (!ObjectActivityConstants.MEMBER_TIMELINE_ACTION_TYPES.contains(trim(log.getActionType()))) {
+                continue;
+            }
+            if (isCreateInitMemberNoise(log, createSignatures)) {
+                continue;
+            }
+            items.add(new ActivityItem(log.getId(), log.getCreateTime(), toMemberTimeline(log, member)));
+        }
+    }
+
+    private LocalDateTime[] buildTimeRange(ProductActivityTimelinePageReqVO reqVO) {
+        if ((reqVO.getStartTime() == null) != (reqVO.getEndTime() == null)) {
+            throw invalidParamException("开始时间和结束时间必须同时传入");
+        }
+        if (reqVO.getStartTime() == null) {
+            LocalDateTime endTime = LocalDateTime.now();
+            return new LocalDateTime[]{endTime.minusDays(30), endTime};
+        }
+        if (reqVO.getStartTime().isAfter(reqVO.getEndTime())) {
+            throw invalidParamException("开始时间不能晚于结束时间");
+        }
+        return new LocalDateTime[]{reqVO.getStartTime(), reqVO.getEndTime()};
+    }
+
+    private List<String> normalizeActionTypes(List<String> actionTypes) {
+        if (actionTypes == null || actionTypes.isEmpty()) {
+            return null;
+        }
+        List<String> normalized = actionTypes.stream()
+                .filter(StringUtils::hasText)
+                .map(String::trim)
+                .distinct()
+                .toList();
+        return normalized.isEmpty() ? null : normalized;
+    }
+
+    private List<String> limitActions(List<String> actionTypes, List<String> allowedActions) {
+        if (actionTypes == null || actionTypes.isEmpty()) {
+            return allowedActions;
+        }
+        return actionTypes.stream()
+                .filter(allowedActions::contains)
+                .distinct()
+                .toList();
+    }
+
+    private boolean shouldSkipByIntersection(List<String> actualActions, List<String> limitedActions) {
+        return actualActions != null && actualActions.size() > 0 && limitedActions.isEmpty();
+    }
+
+    private boolean includeType(String actual, String expected) {
+        return !StringUtils.hasText(actual) || Objects.equals(actual.trim(), expected);
+    }
+
+    private Map<Long, UserObjectRoleDO> loadMemberMap(Long productId, List<BizAuditLogDO> memberLogs) {
+        List<Long> memberIds = memberLogs.stream()
+                .map(BizAuditLogDO::getBizId)
+                .filter(Objects::nonNull)
+                .distinct()
+                .toList();
+        if (memberIds.isEmpty()) {
+            return Map.of();
+        }
+        Map<Long, UserObjectRoleDO> memberMap = new LinkedHashMap<>();
+        for (UserObjectRoleDO member : userObjectRoleMapper.selectListByIdsAndObject(
+                memberIds, ObjectActivityConstants.PRODUCT_BIZ_TYPE, productId)) {
+            memberMap.put(member.getId(), member);
+        }
+        return memberMap;
+    }
+
+    private Set<CreateSignature> loadCreateSignatures(Long productId, LocalDateTime[] timeRange) {
+        List<BizAuditLogDO> productLogs = bizAuditLogMapper.selectListByBizAndActions(
+                ObjectActivityConstants.PRODUCT_BIZ_TYPE, productId,
+                ObjectActivityConstants.PRODUCT_TIMELINE_ACTION_TYPES, timeRange[0], timeRange[1]);
+        return buildCreateSignatures(productLogs);
+    }
+
+    private Set<CreateSignature> buildCreateSignatures(List<BizAuditLogDO> productLogs) {
+        Set<CreateSignature> signatures = new LinkedHashSet<>();
+        for (BizAuditLogDO log : productLogs) {
+            if (!Objects.equals(trim(log.getActionType()), ObjectActivityConstants.PRODUCT_ACTION_CREATE)) {
+                continue;
+            }
+            Long managerUserId = getFieldChangeLong(log.getFieldChanges(), "managerUserId", "after");
+            if (managerUserId == null || log.getCreateTime() == null) {
+                continue;
+            }
+            signatures.add(new CreateSignature(log.getCreateTime(), managerUserId));
+        }
+        return signatures;
+    }
+
+    private boolean isCreateInitManagerNoise(BizAuditLogDO log, Set<CreateSignature> createSignatures) {
+        if (!Objects.equals(trim(log.getActionType()), ObjectActivityConstants.PRODUCT_ACTION_CHANGE_MANAGER)) {
+            return false;
+        }
+        if (getFieldChangeLong(log.getFieldChanges(), "managerUserId", "before") != null) {
+            return false;
+        }
+        Long managerUserId = getFieldChangeLong(log.getFieldChanges(), "managerUserId", "after");
+        return managerUserId != null && log.getCreateTime() != null
+                && createSignatures.contains(new CreateSignature(log.getCreateTime(), managerUserId));
+    }
+
+    private boolean isCreateInitMemberNoise(BizAuditLogDO log, Set<CreateSignature> createSignatures) {
+        if (!Objects.equals(trim(log.getActionType()), ObjectActivityConstants.MEMBER_ACTION_ADD)) {
+            return false;
+        }
+        if (getFieldChangeLong(log.getFieldChanges(), "userId", "before") != null) {
+            return false;
+        }
+        Long userId = getFieldChangeLong(log.getFieldChanges(), "userId", "after");
+        return userId != null && log.getCreateTime() != null
+                && createSignatures.contains(new CreateSignature(log.getCreateTime(), userId));
+    }
+
+    private Long getFieldChangeLong(String fieldChanges, String fieldName, String valueField) {
+        JsonNode valueNode = getFieldChangeNode(fieldChanges, fieldName, valueField);
+        if (valueNode == null || valueNode.isNull()) {
+            return null;
+        }
+        if (valueNode.isNumber()) {
+            return valueNode.longValue();
+        }
+        if (valueNode.isTextual() && StringUtils.hasText(valueNode.textValue())) {
+            return Long.valueOf(valueNode.textValue().trim());
+        }
+        return null;
+    }
+
+    private JsonNode getFieldChangeNode(String fieldChanges, String fieldName, String valueField) {
+        if (!StringUtils.hasText(fieldChanges) || !JsonUtils.isJsonObject(fieldChanges)) {
+            return null;
+        }
+        JsonNode fieldNode = JsonUtils.parseTree(fieldChanges).path(fieldName);
+        if (fieldNode.isMissingNode()) {
+            return null;
+        }
+        JsonNode valueNode = fieldNode.path(valueField);
+        return valueNode.isMissingNode() ? null : valueNode;
+    }
+
+    private PageResult<ProductActivityTimelineRespVO> buildPageResult(List<ProductActivityTimelineRespVO> activities,
+                                                                      ProductActivityTimelinePageReqVO reqVO) {
+        if (activities.isEmpty()) {
+            return PageResult.empty();
+        }
+        int start = PageUtils.getStart(reqVO);
+        if (start >= activities.size()) {
+            return PageResult.empty((long) activities.size());
+        }
+        int end = Math.min(start + reqVO.getPageSize(), activities.size());
+        return new PageResult<>(activities.subList(start, end), (long) activities.size());
+    }
+
+    private void fillTargetUserNames(List<ProductActivityTimelineRespVO> activities) {
+        if (activities == null || activities.isEmpty()) {
+            return;
+        }
+        Set<Long> userIds = new LinkedHashSet<>();
+        for (ProductActivityTimelineRespVO activity : activities) {
+            if (activity != null && activity.getTargetUserId() != null) {
+                userIds.add(activity.getTargetUserId());
+            }
+        }
+        if (userIds.isEmpty()) {
+            return;
+        }
+        Map<Long, String> nicknameMap = loadUserNicknameMap(userIds);
+        for (ProductActivityTimelineRespVO activity : activities) {
+            if (activity == null || activity.getTargetUserId() == null) {
+                continue;
+            }
+            activity.setTargetUserName(nicknameMap.get(activity.getTargetUserId()));
+        }
+    }
+
+    private void fillMemberRoleNames(List<ProductActivityTimelineRespVO> activities) {
+        if (activities == null || activities.isEmpty()) {
+            return;
+        }
+        Set<Long> roleIds = new LinkedHashSet<>();
+        for (ProductActivityTimelineRespVO activity : activities) {
+            if (!Objects.equals(activity.getType(), ObjectActivityConstants.ACTIVITY_TYPE_MEMBER)) {
+                continue;
+            }
+            Long beforeRoleId = getFieldChangeLong(activity.getDetails(), "roleId", "before");
+            Long afterRoleId = getFieldChangeLong(activity.getDetails(), "roleId", "after");
+            if (beforeRoleId != null) {
+                roleIds.add(beforeRoleId);
+            }
+            if (afterRoleId != null) {
+                roleIds.add(afterRoleId);
+            }
+        }
+        if (roleIds.isEmpty()) {
+            return;
+        }
+        Map<Long, String> roleNameMap = loadRoleNameMap(roleIds);
+        for (ProductActivityTimelineRespVO activity : activities) {
+            if (!Objects.equals(activity.getType(), ObjectActivityConstants.ACTIVITY_TYPE_MEMBER)) {
+                continue;
+            }
+            activity.setDetails(appendRoleNames(activity.getDetails(), roleNameMap));
+        }
+    }
+
+    private Map<Long, String> loadUserNicknameMap(Set<Long> userIds) {
+        Map<Long, String> nicknameMap = new LinkedHashMap<>();
+        if (userIds == null || userIds.isEmpty()) {
+            return nicknameMap;
+        }
+        Cache cache = cacheManager == null ? null : cacheManager.getCache(TIMELINE_USER_NICKNAME_CACHE);
+        Set<Long> missIds = new LinkedHashSet<>();
+        for (Long userId : userIds) {
+            String nickname = cache == null ? null : cache.get(userId, String.class);
+            if (nickname != null) {
+                nicknameMap.put(userId, nickname);
+            } else {
+                missIds.add(userId);
+            }
+        }
+        if (missIds.isEmpty()) {
+            return nicknameMap;
+        }
+        Map<Long, AdminUserRespDTO> userMap = adminUserApi == null ? Map.of() : adminUserApi.getUserMap(missIds);
+        if (userMap == null || userMap.isEmpty()) {
+            return nicknameMap;
+        }
+        for (Long userId : missIds) {
+            AdminUserRespDTO user = userMap.get(userId);
+            if (user == null) {
+                continue;
+            }
+            nicknameMap.put(userId, user.getNickname());
+            if (cache != null && user.getNickname() != null) {
+                cache.put(userId, user.getNickname());
+            }
+        }
+        return nicknameMap;
+    }
+
+    private Map<Long, String> loadRoleNameMap(Set<Long> roleIds) {
+        Map<Long, String> roleNameMap = new LinkedHashMap<>();
+        if (roleIds == null || roleIds.isEmpty()) {
+            return roleNameMap;
+        }
+        Cache cache = cacheManager == null ? null : cacheManager.getCache(TIMELINE_ROLE_NAME_CACHE);
+        Set<Long> missIds = new LinkedHashSet<>();
+        for (Long roleId : roleIds) {
+            String roleName = cache == null ? null : cache.get(roleId, String.class);
+            if (roleName != null) {
+                roleNameMap.put(roleId, roleName);
+            } else {
+                missIds.add(roleId);
+            }
+        }
+        if (missIds.isEmpty()) {
+            return roleNameMap;
+        }
+        Map<Long, ObjectRoleRespDTO> roleMap = objectPermissionApi == null ? Map.of()
+                : objectPermissionApi.getObjectRoleMap(missIds, ROLE_SCOPE_OBJECT, PRODUCT_OBJECT_TYPE);
+        if (roleMap == null || roleMap.isEmpty()) {
+            return roleNameMap;
+        }
+        for (Long roleId : missIds) {
+            ObjectRoleRespDTO role = roleMap.get(roleId);
+            if (role == null || !StringUtils.hasText(role.getName())) {
+                continue;
+            }
+            roleNameMap.put(roleId, role.getName());
+            if (cache != null) {
+                cache.put(roleId, role.getName());
+            }
+        }
+        return roleNameMap;
+    }
+
+    private String appendRoleNames(String details, Map<Long, String> roleNameMap) {
+        if (!StringUtils.hasText(details) || !JsonUtils.isJsonObject(details)) {
+            return details;
+        }
+        Long beforeRoleId = getFieldChangeLong(details, "roleId", "before");
+        Long afterRoleId = getFieldChangeLong(details, "roleId", "after");
+        if (beforeRoleId == null && afterRoleId == null) {
+            return details;
+        }
+        JsonNode detailsNode = JsonUtils.parseTree(details);
+        if (!(detailsNode instanceof ObjectNode)) {
+            return details;
+        }
+        ObjectNode objectNode = ((ObjectNode) detailsNode).deepCopy();
+        ObjectNode roleNameNode = objectNode.putObject("roleName");
+        appendRoleName(roleNameNode, "before", beforeRoleId, roleNameMap);
+        appendRoleName(roleNameNode, "after", afterRoleId, roleNameMap);
+        return JsonUtils.toJsonString(objectNode);
+    }
+
+    private void appendRoleName(ObjectNode roleNameNode, String fieldName, Long roleId, Map<Long, String> roleNameMap) {
+        if (roleId == null) {
+            roleNameNode.putNull(fieldName);
+            return;
+        }
+        String roleName = roleNameMap.get(roleId);
+        if (StringUtils.hasText(roleName)) {
+            roleNameNode.put(fieldName, roleName);
+            return;
+        }
+        roleNameNode.putNull(fieldName);
+    }
+
+    private ProductActivityTimelineRespVO toStatusTimeline(ProductStatusLogDO log) {
+        ProductActivityTimelineRespVO respVO = new ProductActivityTimelineRespVO();
+        respVO.setId(ObjectActivityConstants.ACTIVITY_TYPE_STATUS + ":" + log.getId());
+        respVO.setType(ObjectActivityConstants.ACTIVITY_TYPE_STATUS);
+        respVO.setActionType(log.getActionType());
+        respVO.setActionName(ObjectActivityConstants.resolveActionName(log.getActionType()));
+        respVO.setOperatorUserId(log.getOperatorUserId());
+        respVO.setOperatorName(log.getOperatorName());
+        respVO.setOccurredAt(log.getCreateTime());
+        respVO.setSummary(buildSummary(log.getOperatorName(), respVO.getActionName(), log.getReason()));
+        respVO.setReason(log.getReason());
+        respVO.setFromStatus(log.getFromStatus());
+        respVO.setToStatus(log.getToStatus());
+        respVO.setDetails(JsonUtils.toJsonString(buildStatusDetails(log)));
+        return respVO;
+    }
+
+    private ProductActivityTimelineRespVO toProductTimeline(BizAuditLogDO log) {
+        ProductActivityTimelineRespVO respVO = new ProductActivityTimelineRespVO();
+        respVO.setId(ObjectActivityConstants.ACTIVITY_TYPE_PRODUCT + ":" + log.getId());
+        respVO.setType(ObjectActivityConstants.ACTIVITY_TYPE_PRODUCT);
+        respVO.setActionType(log.getActionType());
+        respVO.setActionName(ObjectActivityConstants.resolveActionName(log.getActionType()));
+        respVO.setOperatorUserId(log.getOperatorUserId());
+        respVO.setOperatorName(log.getOperatorName());
+        respVO.setOccurredAt(log.getCreateTime());
+        respVO.setSummary(buildSummary(log.getOperatorName(), respVO.getActionName(), log.getReason()));
+        respVO.setReason(log.getReason());
+        respVO.setFromStatus(log.getFromStatus());
+        respVO.setToStatus(log.getToStatus());
+        respVO.setDetails(log.getFieldChanges());
+        return respVO;
+    }
+
+    private ProductActivityTimelineRespVO toMemberTimeline(BizAuditLogDO log, UserObjectRoleDO member) {
+        ProductActivityTimelineRespVO respVO = toProductTimeline(log);
+        respVO.setId(ObjectActivityConstants.ACTIVITY_TYPE_MEMBER + ":" + log.getId());
+        respVO.setType(ObjectActivityConstants.ACTIVITY_TYPE_MEMBER);
+        respVO.setTargetUserId(member == null ? null : member.getUserId());
+        return respVO;
+    }
+
+    private Map<String, Object> buildStatusDetails(ProductStatusLogDO log) {
+        Map<String, Object> details = new LinkedHashMap<>();
+        details.put("productCodeSnapshot", log.getProductCodeSnapshot());
+        details.put("productNameSnapshot", log.getProductNameSnapshot());
+        return details;
+    }
+
+    private String buildSummary(String operatorName, String actionName, String reason) {
+        String actualOperatorName = StringUtils.hasText(operatorName) ? operatorName : "系统";
+        if (StringUtils.hasText(reason)) {
+            return String.format("%s执行了【%s】：%s", actualOperatorName, actionName, reason);
+        }
+        return String.format("%s执行了【%s】", actualOperatorName, actionName);
+    }
+
+    private String trim(String value) {
+        return StringUtils.hasText(value) ? value.trim() : null;
+    }
+
+    private record CreateSignature(LocalDateTime occurredAt, Long userId) {
+    }
+
+    private record ActivityItem(Long sourceId, LocalDateTime occurredAt, ProductActivityTimelineRespVO respVO) {
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductMemberService.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductMemberService.java
@@ -0,0 +1,50 @@
+package com.njcn.rdms.module.project.service.product;
+
+import com.njcn.rdms.module.project.controller.admin.product.vo.member.ProductMemberInactiveReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.member.ProductMemberRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.member.ProductMemberSaveReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.member.ProductMemberUpdateReqVO;
+
+import java.util.List;
+
+/**
+ * 产品团队 Service 接口
+ */
+public interface ProductMemberService {
+
+    /**
+     * 获取产品团队成员列表
+     *
+     * @param productId 产品编号
+     * @return 成员列表
+     */
+    List<ProductMemberRespVO> getProductMemberList(Long productId);
+
+    /**
+     * 新增产品团队成员
+     *
+     * @param productId 产品编号
+     * @param reqVO 请求参数
+     * @return 团队关系编号
+     */
+    Long createProductMember(Long productId, ProductMemberSaveReqVO reqVO);
+
+    /**
+     * 调整产品团队成员角色
+     *
+     * @param productId 产品编号
+     * @param memberId 成员关系编号
+     * @param reqVO 请求参数
+     */
+    void updateProductMember(Long productId, Long memberId, ProductMemberUpdateReqVO reqVO);
+
+    /**
+     * 移出产品团队成员
+     *
+     * @param productId 产品编号
+     * @param memberId 成员关系编号
+     * @param reqVO 请求参数
+     */
+    void inactiveProductMember(Long productId, Long memberId, ProductMemberInactiveReqVO reqVO);
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductMemberServiceImpl.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductMemberServiceImpl.java
@@ -0,0 +1,415 @@
+package com.njcn.rdms.module.project.service.product;
+
+import com.njcn.rdms.framework.common.util.json.JsonUtils;
+import com.njcn.rdms.framework.security.core.util.SecurityFrameworkUtils;
+import com.njcn.rdms.module.project.constant.ObjectActivityConstants;
+import com.njcn.rdms.module.project.controller.admin.product.vo.member.ProductMemberInactiveReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.member.ProductMemberRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.member.ProductMemberSaveReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.member.ProductMemberUpdateReqVO;
+import com.njcn.rdms.module.project.framework.security.annotation.CheckObjectPermission;
+import com.njcn.rdms.module.project.dal.dataobject.audit.BizAuditLogDO;
+import com.njcn.rdms.module.project.dal.dataobject.member.UserObjectRoleDO;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductDO;
+import com.njcn.rdms.module.project.dal.mysql.audit.BizAuditLogMapper;
+import com.njcn.rdms.module.project.dal.mysql.member.UserObjectRoleMapper;
+import com.njcn.rdms.module.project.dal.mysql.product.ProductMapper;
+import com.njcn.rdms.module.project.enums.ErrorCodeConstants;
+import com.njcn.rdms.module.system.api.permission.ObjectPermissionApi;
+import com.njcn.rdms.module.system.api.permission.dto.ObjectRoleRespDTO;
+import com.njcn.rdms.module.system.api.user.AdminUserApi;
+import com.njcn.rdms.module.system.api.user.dto.AdminUserRespDTO;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+
+import java.time.LocalDateTime;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static com.njcn.rdms.framework.common.exception.util.ServiceExceptionUtil.exception;
+
+/**
+ * 产品团队 Service 实现类
+ */
+@Service
+public class ProductMemberServiceImpl implements ProductMemberService {
+
+    private static final String PRODUCT_OBJECT_TYPE = "product";
+    private static final String ROLE_SCOPE_OBJECT = "object";
+    private static final String PRODUCT_QUERY_PERMISSION = "project:product:query";
+    private static final String PRODUCT_UPDATE_PERMISSION = "project:product:update";
+
+    private static final Integer MEMBER_STATUS_ACTIVE = 0;
+    private static final Integer MEMBER_STATUS_INACTIVE = 1;
+
+    private static final String PRODUCT_MANAGER_ROLE_CODE = "product_manager";
+
+    @Resource
+    private ProductMapper productMapper;
+    @Resource
+    private UserObjectRoleMapper userObjectRoleMapper;
+    @Resource
+    private ObjectPermissionApi objectPermissionApi;
+    @Resource
+    private BizAuditLogMapper bizAuditLogMapper;
+    @Resource
+    private AdminUserApi adminUserApi;
+
+    @Override
+    @CheckObjectPermission(objectType = PRODUCT_OBJECT_TYPE, objectId = "#productId",
+            permission = PRODUCT_QUERY_PERMISSION)
+    public List<ProductMemberRespVO> getProductMemberList(Long productId) {
+        ProductDO product = validateProductExists(productId);
+        List<UserObjectRoleDO> members = userObjectRoleMapper.selectListByObject(PRODUCT_OBJECT_TYPE, productId);
+        Map<Long, ObjectRoleRespDTO> roleMap = getRoleMap(members.stream().map(UserObjectRoleDO::getRoleId).collect(Collectors.toSet()));
+        Map<Long, AdminUserRespDTO> userMap = getUserMap(members.stream().map(UserObjectRoleDO::getUserId).collect(Collectors.toSet()));
+        return members.stream().map(member -> {
+            ProductMemberRespVO respVO = new ProductMemberRespVO();
+            respVO.setId(member.getId());
+            respVO.setUserId(member.getUserId());
+            AdminUserRespDTO user = userMap.get(member.getUserId());
+            respVO.setUserNickname(user == null ? null : user.getNickname());
+            respVO.setRoleId(member.getRoleId());
+            ObjectRoleRespDTO role = roleMap.get(member.getRoleId());
+            respVO.setRoleName(role == null ? null : role.getName());
+            respVO.setRoleCode(role == null ? null : role.getCode());
+            respVO.setManagerFlag(Objects.equals(member.getUserId(), product.getManagerUserId())
+                    && Objects.equals(member.getStatus(), MEMBER_STATUS_ACTIVE));
+            respVO.setStatus(member.getStatus());
+            respVO.setJoinedTime(member.getJoinedTime());
+            respVO.setLeftTime(member.getLeftTime());
+            respVO.setRemark(member.getRemark());
+            return respVO;
+        }).collect(Collectors.toList());
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    @CheckObjectPermission(objectType = PRODUCT_OBJECT_TYPE, objectId = "#productId",
+            permission = PRODUCT_UPDATE_PERMISSION)
+    public Long createProductMember(Long productId, ProductMemberSaveReqVO reqVO) {
+        ProductDO product = validateProductExists(productId);
+        ObjectRoleRespDTO targetRole = validateProductRole(reqVO.getRoleId());
+        UserObjectRoleDO existingMember = userObjectRoleMapper
+                .selectByObjectAndUserId(PRODUCT_OBJECT_TYPE, productId, reqVO.getUserId());
+        if (existingMember != null && Objects.equals(existingMember.getStatus(), MEMBER_STATUS_ACTIVE)) {
+            throw exception(ErrorCodeConstants.PRODUCT_MEMBER_ALREADY_EXISTS);
+        }
+
+        UserObjectRoleDO member;
+        UserObjectRoleDO before = null;
+        LocalDateTime now = LocalDateTime.now();
+        if (existingMember == null) {
+            member = new UserObjectRoleDO();
+            member.setUserId(reqVO.getUserId());
+            member.setObjectType(PRODUCT_OBJECT_TYPE);
+            member.setObjectId(productId);
+            member.setRoleId(targetRole.getId());
+            member.setStatus(MEMBER_STATUS_ACTIVE);
+            member.setJoinedTime(now);
+            member.setLeftTime(null);
+            member.setRemark(normalizeNullableText(reqVO.getRemark()));
+            userObjectRoleMapper.insert(member);
+        } else {
+            before = cloneMember(existingMember);
+            member = existingMember;
+            member.setRoleId(targetRole.getId());
+            member.setStatus(MEMBER_STATUS_ACTIVE);
+            member.setJoinedTime(now);
+            member.setLeftTime(null);
+            member.setRemark(normalizeNullableText(reqVO.getRemark()));
+            userObjectRoleMapper.updateById(member);
+        }
+
+        writeMemberAuditLog(member, ObjectActivityConstants.MEMBER_ACTION_ADD, before, member, null);
+        if (isManagerRole(targetRole)) {
+            transferManager(product, member, reqVO.getPreviousManagerUserId(), reqVO.getPreviousManagerRoleId(), null);
+        }
+        return member.getId();
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    @CheckObjectPermission(objectType = PRODUCT_OBJECT_TYPE, objectId = "#productId",
+            permission = PRODUCT_UPDATE_PERMISSION)
+    public void updateProductMember(Long productId, Long memberId, ProductMemberUpdateReqVO reqVO) {
+        ProductDO product = validateProductExists(productId);
+        UserObjectRoleDO member = validateMemberExists(productId, memberId);
+        if (!Objects.equals(member.getStatus(), MEMBER_STATUS_ACTIVE)) {
+            throw exception(ErrorCodeConstants.PRODUCT_MEMBER_NOT_ACTIVE);
+        }
+
+        ObjectRoleRespDTO targetRole = validateProductRole(reqVO.getRoleId());
+        UserObjectRoleDO before = cloneMember(member);
+        member.setRemark(normalizeNullableText(reqVO.getRemark()));
+
+        if (isManagerRole(targetRole)) {
+            member.setRoleId(targetRole.getId());
+            userObjectRoleMapper.updateById(member);
+            transferManager(product, member, reqVO.getPreviousManagerUserId(),
+                    reqVO.getPreviousManagerRoleId(), normalizeNullableText(reqVO.getReason()));
+        } else {
+            if (Objects.equals(member.getUserId(), product.getManagerUserId())) {
+                throw exception(ErrorCodeConstants.PRODUCT_MANAGER_MEMBER_NOT_ALLOW_DOWNGRADE);
+            }
+            member.setRoleId(targetRole.getId());
+            userObjectRoleMapper.updateById(member);
+        }
+
+        writeMemberAuditLog(member, ObjectActivityConstants.MEMBER_ACTION_UPDATE,
+                before, member, normalizeNullableText(reqVO.getReason()));
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    @CheckObjectPermission(objectType = PRODUCT_OBJECT_TYPE, objectId = "#productId",
+            permission = PRODUCT_UPDATE_PERMISSION)
+    public void inactiveProductMember(Long productId, Long memberId, ProductMemberInactiveReqVO reqVO) {
+        ProductDO product = validateProductExists(productId);
+        UserObjectRoleDO member = validateMemberExists(productId, memberId);
+        if (!Objects.equals(member.getStatus(), MEMBER_STATUS_ACTIVE)) {
+            throw exception(ErrorCodeConstants.PRODUCT_MEMBER_NOT_ACTIVE);
+        }
+        if (Objects.equals(member.getUserId(), product.getManagerUserId())) {
+            throw exception(ErrorCodeConstants.PRODUCT_MANAGER_MEMBER_NOT_ALLOW_REMOVE);
+        }
+
+        UserObjectRoleDO before = cloneMember(member);
+        member.setStatus(MEMBER_STATUS_INACTIVE);
+        member.setLeftTime(LocalDateTime.now());
+        userObjectRoleMapper.updateById(member);
+
+        writeMemberAuditLog(member, ObjectActivityConstants.MEMBER_ACTION_REMOVE, before, member,
+                normalizeNullableText(reqVO.getReason()));
+    }
+
+    private ProductDO validateProductExists(Long productId) {
+        if (productId == null) {
+            throw exception(ErrorCodeConstants.PRODUCT_NOT_EXISTS);
+        }
+        ProductDO product = productMapper.selectById(productId);
+        if (product == null) {
+            throw exception(ErrorCodeConstants.PRODUCT_NOT_EXISTS);
+        }
+        return product;
+    }
+
+    private UserObjectRoleDO validateMemberExists(Long productId, Long memberId) {
+        UserObjectRoleDO member = userObjectRoleMapper.selectByIdAndObject(memberId, PRODUCT_OBJECT_TYPE, productId);
+        if (member == null) {
+            throw exception(ErrorCodeConstants.PRODUCT_MEMBER_NOT_EXISTS);
+        }
+        return member;
+    }
+
+    private ObjectRoleRespDTO validateProductRole(Long roleId) {
+        ObjectRoleRespDTO role = objectPermissionApi
+                .getObjectRoleById(roleId, ROLE_SCOPE_OBJECT, PRODUCT_OBJECT_TYPE)
+                .getCheckedData();
+        if (role == null) {
+            throw exception(ErrorCodeConstants.PRODUCT_MEMBER_ROLE_INVALID);
+        }
+        return role;
+    }
+
+    private void transferManager(ProductDO product,
+                                 UserObjectRoleDO targetManagerMember,
+                                 Long previousManagerUserId,
+                                 Long previousManagerRoleId,
+                                 String reason) {
+        Long currentManagerUserId = product.getManagerUserId();
+        Long targetManagerUserId = targetManagerMember.getUserId();
+        if (Objects.equals(currentManagerUserId, targetManagerUserId)) {
+            product.setManagerUserId(targetManagerUserId);
+            productMapper.updateById(product);
+            return;
+        }
+
+        ObjectRoleRespDTO previousManagerRole = validatePreviousManagerTransfer(currentManagerUserId,
+                previousManagerUserId, previousManagerRoleId);
+        transferPreviousManager(product.getId(), previousManagerUserId, previousManagerRole.getId(), reason);
+
+        product.setManagerUserId(targetManagerUserId);
+        productMapper.updateById(product);
+        writeManagerChangeAuditLog(product.getId(), currentManagerUserId, targetManagerUserId, reason);
+    }
+
+    private ObjectRoleRespDTO validatePreviousManagerTransfer(Long currentManagerUserId,
+                                                              Long previousManagerUserId,
+                                                              Long previousManagerRoleId) {
+        if (currentManagerUserId == null
+                || previousManagerUserId == null
+                || previousManagerRoleId == null) {
+            throw exception(ErrorCodeConstants.PRODUCT_MANAGER_TRANSFER_INFO_REQUIRED);
+        }
+        if (!Objects.equals(currentManagerUserId, previousManagerUserId)) {
+            throw exception(ErrorCodeConstants.PRODUCT_MANAGER_TRANSFER_SOURCE_INVALID);
+        }
+        ObjectRoleRespDTO previousManagerRole = validateProductRole(previousManagerRoleId);
+        if (isManagerRole(previousManagerRole)) {
+            throw exception(ErrorCodeConstants.PRODUCT_MANAGER_TRANSFER_ROLE_INVALID);
+        }
+        return previousManagerRole;
+    }
+
+    private void transferPreviousManager(Long productId, Long previousManagerUserId, Long previousManagerRoleId, String reason) {
+        UserObjectRoleDO existingMember = userObjectRoleMapper
+                .selectByObjectAndUserId(PRODUCT_OBJECT_TYPE, productId, previousManagerUserId);
+        UserObjectRoleDO before = existingMember == null ? null : cloneMember(existingMember);
+        LocalDateTime now = LocalDateTime.now();
+        UserObjectRoleDO member;
+        String actionType;
+        if (existingMember == null) {
+            member = new UserObjectRoleDO();
+            member.setUserId(previousManagerUserId);
+            member.setObjectType(PRODUCT_OBJECT_TYPE);
+            member.setObjectId(productId);
+            member.setRoleId(previousManagerRoleId);
+            member.setStatus(MEMBER_STATUS_ACTIVE);
+            member.setJoinedTime(now);
+            member.setLeftTime(null);
+            member.setRemark(null);
+            userObjectRoleMapper.insert(member);
+            actionType = ObjectActivityConstants.MEMBER_ACTION_ADD;
+        } else {
+            member = existingMember;
+            member.setRoleId(previousManagerRoleId);
+            member.setStatus(MEMBER_STATUS_ACTIVE);
+            member.setLeftTime(null);
+            if (!Objects.equals(before.getStatus(), MEMBER_STATUS_ACTIVE)) {
+                member.setJoinedTime(now);
+                actionType = ObjectActivityConstants.MEMBER_ACTION_ADD;
+            } else {
+                actionType = ObjectActivityConstants.MEMBER_ACTION_UPDATE;
+            }
+            userObjectRoleMapper.updateById(member);
+        }
+        writeMemberAuditLog(member, actionType, before, member, reason);
+    }
+
+    private boolean isManagerRole(ObjectRoleRespDTO role) {
+        return Objects.equals(PRODUCT_MANAGER_ROLE_CODE, role.getCode());
+    }
+
+    private Map<Long, ObjectRoleRespDTO> getRoleMap(Set<Long> roleIds) {
+        if (roleIds.isEmpty()) {
+            return Collections.emptyMap();
+        }
+        List<ObjectRoleRespDTO> roles = objectPermissionApi
+                .getObjectRoleList(roleIds, ROLE_SCOPE_OBJECT, PRODUCT_OBJECT_TYPE)
+                .getCheckedData();
+        if (roles == null || roles.isEmpty()) {
+            return Collections.emptyMap();
+        }
+        return roles.stream().collect(Collectors.toMap(ObjectRoleRespDTO::getId, Function.identity()));
+    }
+
+    private Map<Long, AdminUserRespDTO> getUserMap(Set<Long> userIds) {
+        if (userIds.isEmpty()) {
+            return Collections.emptyMap();
+        }
+        return adminUserApi.getUserMap(userIds);
+    }
+
+    private void writeMemberAuditLog(UserObjectRoleDO member,
+                                     String actionType,
+                                     UserObjectRoleDO before,
+                                     UserObjectRoleDO after,
+                                     String reason) {
+        BizAuditLogDO auditLog = new BizAuditLogDO();
+        auditLog.setBizType(ObjectActivityConstants.MEMBER_BIZ_TYPE);
+        auditLog.setBizId(member.getId());
+        auditLog.setActionType(actionType);
+        auditLog.setFieldChanges(buildMemberFieldChanges(before, after));
+        auditLog.setReason(reason);
+        auditLog.setOperatorUserId(SecurityFrameworkUtils.getLoginUserId());
+        auditLog.setOperatorName(defaultText(SecurityFrameworkUtils.getLoginUserNickname()));
+        bizAuditLogMapper.insert(auditLog);
+    }
+
+    private void writeManagerChangeAuditLog(Long productId, Long beforeManagerUserId, Long afterManagerUserId, String reason) {
+        if (Objects.equals(beforeManagerUserId, afterManagerUserId)) {
+            return;
+        }
+        BizAuditLogDO auditLog = new BizAuditLogDO();
+        auditLog.setBizType(PRODUCT_OBJECT_TYPE);
+        auditLog.setBizId(productId);
+        auditLog.setActionType(ObjectActivityConstants.PRODUCT_ACTION_CHANGE_MANAGER);
+        auditLog.setFieldChanges(buildManagerFieldChanges(beforeManagerUserId, afterManagerUserId));
+        auditLog.setReason(reason);
+        auditLog.setOperatorUserId(SecurityFrameworkUtils.getLoginUserId());
+        auditLog.setOperatorName(defaultText(SecurityFrameworkUtils.getLoginUserNickname()));
+        bizAuditLogMapper.insert(auditLog);
+    }
+
+    private String buildMemberFieldChanges(UserObjectRoleDO before, UserObjectRoleDO after) {
+        Map<String, Object> fieldChanges = new LinkedHashMap<>();
+        appendFieldChange(fieldChanges, "userId", valueOf(before, UserObjectRoleDO::getUserId),
+                valueOf(after, UserObjectRoleDO::getUserId));
+        appendFieldChange(fieldChanges, "roleId", valueOf(before, UserObjectRoleDO::getRoleId),
+                valueOf(after, UserObjectRoleDO::getRoleId));
+        appendFieldChange(fieldChanges, "status", valueOf(before, UserObjectRoleDO::getStatus),
+                valueOf(after, UserObjectRoleDO::getStatus));
+        appendFieldChange(fieldChanges, "joinedTime", valueOf(before, UserObjectRoleDO::getJoinedTime),
+                valueOf(after, UserObjectRoleDO::getJoinedTime));
+        appendFieldChange(fieldChanges, "leftTime", valueOf(before, UserObjectRoleDO::getLeftTime),
+                valueOf(after, UserObjectRoleDO::getLeftTime));
+        appendFieldChange(fieldChanges, "remark", valueOf(before, UserObjectRoleDO::getRemark),
+                valueOf(after, UserObjectRoleDO::getRemark));
+        return fieldChanges.isEmpty() ? null : JsonUtils.toJsonString(fieldChanges);
+    }
+
+    private String buildManagerFieldChanges(Long beforeManagerUserId, Long afterManagerUserId) {
+        Map<String, Object> fieldChanges = new LinkedHashMap<>();
+        appendFieldChange(fieldChanges, "managerUserId", beforeManagerUserId, afterManagerUserId);
+        return JsonUtils.toJsonString(fieldChanges);
+    }
+
+    private UserObjectRoleDO cloneMember(UserObjectRoleDO source) {
+        UserObjectRoleDO clone = new UserObjectRoleDO();
+        clone.setId(source.getId());
+        clone.setUserId(source.getUserId());
+        clone.setObjectType(source.getObjectType());
+        clone.setObjectId(source.getObjectId());
+        clone.setRoleId(source.getRoleId());
+        clone.setStatus(source.getStatus());
+        clone.setJoinedTime(source.getJoinedTime());
+        clone.setLeftTime(source.getLeftTime());
+        clone.setRemark(source.getRemark());
+        return clone;
+    }
+
+    private <T> T valueOf(UserObjectRoleDO member, Function<UserObjectRoleDO, T> getter) {
+        return member == null ? null : getter.apply(member);
+    }
+
+    private void appendFieldChange(Map<String, Object> fieldChanges, String fieldName, Object before, Object after) {
+        if (Objects.equals(before, after)) {
+            return;
+        }
+        Map<String, Object> value = new LinkedHashMap<>();
+        value.put("before", before);
+        value.put("after", after);
+        fieldChanges.put(fieldName, value);
+    }
+
+    private String normalizeNullableText(String value) {
+        if (!StringUtils.hasText(value)) {
+            return null;
+        }
+        return value.trim();
+    }
+
+    private String defaultText(String value) {
+        return StringUtils.hasText(value) ? value : "";
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductService.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductService.java
@@ -0,0 +1,78 @@
+package com.njcn.rdms.module.project.service.product;
+
+import com.njcn.rdms.framework.common.pojo.PageResult;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductContextRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductDeleteReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductPageReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductSaveReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductStatusActionReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.setting.ProductSettingBaseInfoUpdateReqVO;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductDO;
+
+/**
+ * 产品 Service 接口
+ */
+public interface ProductService {
+
+    /**
+     * 创建产品
+     *
+     * @param createReqVO 创建请求
+     * @return 产品编号
+     */
+    Long createProduct(ProductSaveReqVO createReqVO);
+
+    /**
+     * 更新产品
+     *
+     * @param updateReqVO 更新请求
+     */
+    void updateProduct(ProductSaveReqVO updateReqVO);
+
+    /**
+     * 更新产品设置页基础信息
+     *
+     * @param productId 产品编号
+     * @param reqVO 更新请求
+     */
+    void updateProductBaseInfo(Long productId, ProductSettingBaseInfoUpdateReqVO reqVO);
+
+    /**
+     * 获取产品详情
+     *
+     * @param id 产品编号
+     * @return 产品信息
+     */
+    ProductDO getProduct(Long id);
+
+    /**
+     * 获取产品上下文
+     *
+     * @param id 产品编号
+     * @return 产品上下文
+     */
+    ProductContextRespVO getProductContext(Long id);
+
+    /**
+     * 获取产品分页
+     *
+     * @param pageReqVO 分页请求
+     * @return 分页结果
+     */
+    PageResult<ProductDO> getProductPage(ProductPageReqVO pageReqVO);
+
+    /**
+     * 变更产品状态
+     *
+     * @param reqVO 状态动作请求
+     */
+    void changeProductStatus(ProductStatusActionReqVO reqVO);
+
+    /**
+     * 删除产品
+     *
+     * @param reqVO 删除请求
+     */
+    void deleteProduct(ProductDeleteReqVO reqVO);
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductServiceImpl.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductServiceImpl.java
@@ -0,0 +1,578 @@
+package com.njcn.rdms.module.project.service.product;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.njcn.rdms.framework.common.pojo.PageResult;
+import com.njcn.rdms.framework.common.util.json.JsonUtils;
+import com.njcn.rdms.framework.common.util.object.BeanUtils;
+import com.njcn.rdms.framework.security.core.util.SecurityFrameworkUtils;
+import com.njcn.rdms.module.project.constant.ObjectActivityConstants;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductContextNavRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductContextProductRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductContextRoleRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductContextRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductDeleteReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductPageReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductSaveReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductStatusActionReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.setting.ProductSettingBaseInfoUpdateReqVO;
+import com.njcn.rdms.module.project.framework.security.annotation.CheckObjectPermission;
+import com.njcn.rdms.module.project.dal.dataobject.audit.BizAuditLogDO;
+import com.njcn.rdms.module.project.dal.dataobject.member.UserObjectRoleDO;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductDO;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductStatusLogDO;
+import com.njcn.rdms.module.project.dal.dataobject.status.ObjectStatusTransitionDO;
+import com.njcn.rdms.module.project.dal.mysql.audit.BizAuditLogMapper;
+import com.njcn.rdms.module.project.dal.mysql.member.UserObjectRoleMapper;
+import com.njcn.rdms.module.project.dal.mysql.product.ProductMapper;
+import com.njcn.rdms.module.project.dal.mysql.product.ProductStatusLogMapper;
+import com.njcn.rdms.module.project.dal.mysql.status.ObjectStatusTransitionMapper;
+import com.njcn.rdms.module.project.enums.ErrorCodeConstants;
+import com.njcn.rdms.module.system.api.permission.ObjectPermissionApi;
+import com.njcn.rdms.module.system.api.permission.dto.ObjectMenuRespDTO;
+import com.njcn.rdms.module.system.api.permission.dto.ObjectRolePermissionRespDTO;
+import com.njcn.rdms.module.system.api.permission.dto.ObjectRoleRespDTO;
+import com.njcn.rdms.module.system.api.user.AdminUserApi;
+import com.njcn.rdms.module.system.enums.permission.MenuTypeEnum;
+import com.njcn.rdms.module.system.enums.permission.PermissionScopeTypeEnum;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import static com.njcn.rdms.framework.common.exception.util.ServiceExceptionUtil.exception;
+import static com.njcn.rdms.framework.common.exception.util.ServiceExceptionUtil.invalidParamException;
+
+/**
+ * 产品 Service 实现类
+ */
+@Service
+public class ProductServiceImpl implements ProductService {
+
+    private static final String PRODUCT_OBJECT_TYPE = "product";
+    private static final String ROLE_SCOPE_OBJECT = PermissionScopeTypeEnum.OBJECT.getScopeType();
+    private static final String PRODUCT_MANAGER_ROLE_CODE = "product_manager";
+
+    private static final String PRODUCT_ACTIVE_STATUS = "active";
+    private static final String PRODUCT_PAUSED_STATUS = "paused";
+    private static final String PRODUCT_ARCHIVED_STATUS = "archived";
+    private static final String PRODUCT_ABANDONED_STATUS = "abandoned";
+
+    private static final Integer MEMBER_STATUS_ACTIVE = 0;
+
+    private static final String PRODUCT_CODE_PREFIX = "CNPD";
+    private static final String PRODUCT_QUERY_PERMISSION = "project:product:query";
+    private static final String PRODUCT_UPDATE_PERMISSION = "project:product:update";
+    private static final String PRODUCT_STATUS_PERMISSION = "project:product:status";
+    private static final String PRODUCT_DELETE_PERMISSION = "project:product:delete";
+    private static final String PRODUCT_DELETE_CONFIRM_TEXT = "DELETE";
+
+    @Resource
+    private ProductMapper productMapper;
+    @Resource
+    private ProductStatusLogMapper productStatusLogMapper;
+    @Resource
+    private BizAuditLogMapper bizAuditLogMapper;
+    @Resource
+    private ObjectStatusTransitionMapper objectStatusTransitionMapper;
+    @Resource
+    private UserObjectRoleMapper userObjectRoleMapper;
+    @Resource
+    private ObjectPermissionApi objectPermissionApi;
+    @Resource
+    private AdminUserApi adminUserApi;
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Long createProduct(ProductSaveReqVO createReqVO) {
+        validateCreateReqVO(createReqVO);
+        validateManagerUser(createReqVO.getManagerUserId());
+
+        ProductDO product = new ProductDO();
+        product.setCode(generateProductCode(createReqVO.getCode()));
+        product.setDirectionCode(createReqVO.getDirectionCode());
+        product.setStatusCode(PRODUCT_ACTIVE_STATUS);
+        product.setName(createReqVO.getName().trim());
+        product.setManagerUserId(createReqVO.getManagerUserId());
+        product.setDescription(normalizeNullableText(createReqVO.getDescription()));
+        productMapper.insert(product);
+
+        initManagerMemberRelation(product);
+        writeBizAuditLog(product, ObjectActivityConstants.PRODUCT_ACTION_CREATE, null, PRODUCT_ACTIVE_STATUS,
+                buildProductFieldChanges(null, product), null);
+        return product.getId();
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    @CheckObjectPermission(objectType = PRODUCT_OBJECT_TYPE, objectId = "#updateReqVO.id",
+            permission = PRODUCT_UPDATE_PERMISSION)
+    public void updateProduct(ProductSaveReqVO updateReqVO) {
+        if (updateReqVO.getId() == null) {
+            throw invalidParamException("产品编号不能为空");
+        }
+        ProductDO product = validateProductExists(updateReqVO.getId());
+        validateProductCodeUnchanged(product, updateReqVO.getCode());
+        validateManagerUserUnchanged(product, updateReqVO.getManagerUserId());
+        applyProductBaseInfoUpdate(product, updateReqVO.getDirectionCode(), updateReqVO.getName(), updateReqVO.getDescription());
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    @CheckObjectPermission(objectType = PRODUCT_OBJECT_TYPE, objectId = "#productId",
+            permission = PRODUCT_UPDATE_PERMISSION)
+    public void updateProductBaseInfo(Long productId, ProductSettingBaseInfoUpdateReqVO reqVO) {
+        ProductDO product = validateProductExists(productId);
+        applyProductBaseInfoUpdate(product, reqVO.getDirectionCode(), reqVO.getName(), reqVO.getDescription());
+    }
+
+    @Override
+    @CheckObjectPermission(objectType = PRODUCT_OBJECT_TYPE, objectId = "#id",
+            permission = PRODUCT_QUERY_PERMISSION)
+    public ProductDO getProduct(Long id) {
+        return validateProductExists(id);
+    }
+
+    @Override
+    @CheckObjectPermission(objectType = PRODUCT_OBJECT_TYPE, objectId = "#id", memberOnly = true)
+    public ProductContextRespVO getProductContext(Long id) {
+        ProductDO product = validateProductExists(id);
+
+        Long loginUserId = SecurityFrameworkUtils.getLoginUserId();
+        UserObjectRoleDO currentMember = userObjectRoleMapper
+                .selectActiveByObjectAndUserId(PRODUCT_OBJECT_TYPE, id, loginUserId);
+        ProductContextRespVO respVO = new ProductContextRespVO();
+        respVO.setCurrentProduct(buildCurrentProduct(product));
+        if (currentMember == null) {
+            respVO.setNavs(Collections.emptyList());
+            respVO.setButtons(Collections.emptyList());
+            return respVO;
+        }
+
+        ObjectRolePermissionRespDTO permissionDetail = objectPermissionApi
+                .getObjectRolePermissionDetail(currentMember.getRoleId(), ROLE_SCOPE_OBJECT, PRODUCT_OBJECT_TYPE)
+                .getCheckedData();
+        ObjectRoleRespDTO currentRole = permissionDetail == null ? null : permissionDetail.getCurrentRole();
+        List<ObjectMenuRespDTO> menus = permissionDetail == null || permissionDetail.getMenus() == null
+                ? Collections.emptyList()
+                : permissionDetail.getMenus();
+        respVO.setCurrentRole(buildCurrentRole(currentMember, currentRole));
+        respVO.setNavs(buildContextNavs(menus));
+        respVO.setButtons(buildContextButtons(menus));
+        return respVO;
+    }
+
+    @Override
+    public PageResult<ProductDO> getProductPage(ProductPageReqVO pageReqVO) {
+        return productMapper.selectPage(pageReqVO);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    @CheckObjectPermission(objectType = PRODUCT_OBJECT_TYPE, objectId = "#reqVO.id",
+            permission = PRODUCT_STATUS_PERMISSION)
+    public void changeProductStatus(ProductStatusActionReqVO reqVO) {
+        ProductDO product = validateProductExists(reqVO.getId());
+        String actionCode = reqVO.getActionCode().trim();
+        ObjectStatusTransitionDO transition = validateProductTransition(product.getStatusCode(), actionCode);
+        String reason = normalizeNullableText(reqVO.getReason());
+        validateTransitionReason(transition, reason);
+
+        String fromStatus = product.getStatusCode();
+        String toStatus = transition.getToStatusCode();
+        int updateCount = productMapper.updateStatusByIdAndStatus(product.getId(), fromStatus, toStatus, reason);
+        if (updateCount != 1) {
+            throw exception(ErrorCodeConstants.PRODUCT_STATUS_CONCURRENT_MODIFIED);
+        }
+        product.setStatusCode(toStatus);
+        product.setLastStatusReason(reason);
+
+        writeProductStatusLog(product, actionCode, fromStatus, toStatus, reason);
+        writeBizAuditLog(product, actionCode, fromStatus, toStatus, null, reason);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    @CheckObjectPermission(objectType = PRODUCT_OBJECT_TYPE, objectId = "#reqVO.id",
+            permission = PRODUCT_DELETE_PERMISSION)
+    public void deleteProduct(ProductDeleteReqVO reqVO) {
+        ProductDO product = validateProductExists(reqVO.getId());
+        validateDeleteConfirmText(reqVO.getConfirmText());
+        if (!Objects.equals(product.getName(), reqVO.getProductName().trim())) {
+            throw exception(ErrorCodeConstants.PRODUCT_DELETE_NAME_MISMATCH);
+        }
+
+        String reason = reqVO.getReason().trim();
+        String fromStatus = product.getStatusCode();
+        int deleteCount = productMapper.deleteByIdAndStatus(reqVO.getId(), fromStatus);
+        if (deleteCount != 1) {
+            throw exception(ErrorCodeConstants.PRODUCT_STATUS_CONCURRENT_MODIFIED);
+        }
+
+        writeProductStatusLog(product, ObjectActivityConstants.PRODUCT_ACTION_DELETE, fromStatus, null, reason);
+        writeBizAuditLog(product, ObjectActivityConstants.PRODUCT_ACTION_DELETE, fromStatus, null, null, reason);
+    }
+
+    @VisibleForTesting
+    void validateCreateReqVO(ProductSaveReqVO createReqVO) {
+        validateProductCodeUnique(null, createReqVO.getCode());
+        validateProductNameUnique(null, createReqVO.getName());
+    }
+
+    @VisibleForTesting
+    ProductDO validateProductExists(Long id) {
+        if (id == null) {
+            throw exception(ErrorCodeConstants.PRODUCT_NOT_EXISTS);
+        }
+        ProductDO product = productMapper.selectById(id);
+        if (product == null) {
+            throw exception(ErrorCodeConstants.PRODUCT_NOT_EXISTS);
+        }
+        return product;
+    }
+
+    @VisibleForTesting
+    void validateProductCodeUnique(Long id, String code) {
+        if (!StringUtils.hasText(code)) {
+            return;
+        }
+        String normalizedCode = code.trim();
+        ProductDO product = productMapper.selectByCode(normalizedCode);
+        if (product == null) {
+            return;
+        }
+        if (id == null || !product.getId().equals(id)) {
+            throw exception(ErrorCodeConstants.PRODUCT_CODE_DUPLICATE, normalizedCode);
+        }
+    }
+
+    @VisibleForTesting
+    void validateProductNameUnique(Long id, String name) {
+        String normalizedName = name.trim();
+        ProductDO product = productMapper.selectByName(normalizedName);
+        if (product == null) {
+            return;
+        }
+        if (id == null || !product.getId().equals(id)) {
+            throw exception(ErrorCodeConstants.PRODUCT_NAME_DUPLICATE, normalizedName);
+        }
+    }
+
+    @VisibleForTesting
+    void validateManagerUser(Long managerUserId) {
+        adminUserApi.validateUser(managerUserId);
+    }
+
+    @VisibleForTesting
+    void validateProductCodeUnchanged(ProductDO product, String code) {
+        if (!StringUtils.hasText(code)) {
+            return;
+        }
+        if (!Objects.equals(product.getCode(), code.trim())) {
+            throw exception(ErrorCodeConstants.PRODUCT_CODE_NOT_MODIFIABLE);
+        }
+    }
+
+    @VisibleForTesting
+    void validateManagerUserUnchanged(ProductDO product, Long managerUserId) {
+        if (!Objects.equals(product.getManagerUserId(), managerUserId)) {
+            throw exception(ErrorCodeConstants.PRODUCT_MANAGER_NOT_MODIFIABLE);
+        }
+    }
+
+    @VisibleForTesting
+    void validateProductEditable(ProductDO product, ProductSaveReqVO updateReqVO) {
+        validateProductEditable(product, updateReqVO.getDirectionCode(), updateReqVO.getName());
+    }
+
+    @VisibleForTesting
+    void validateProductEditable(ProductDO product, String directionCode, String name) {
+        if (PRODUCT_ARCHIVED_STATUS.equals(product.getStatusCode())
+                || PRODUCT_ABANDONED_STATUS.equals(product.getStatusCode())) {
+            throw exception(ErrorCodeConstants.PRODUCT_STATUS_NOT_ALLOW_EDIT);
+        }
+        if (!PRODUCT_PAUSED_STATUS.equals(product.getStatusCode())) {
+            return;
+        }
+        if (!Objects.equals(product.getDirectionCode(), directionCode)
+                || !Objects.equals(product.getName(), name.trim())) {
+            throw exception(ErrorCodeConstants.PRODUCT_PAUSED_ONLY_ALLOW_LIMITED_UPDATE);
+        }
+    }
+
+    @VisibleForTesting
+    ObjectStatusTransitionDO validateProductTransition(String fromStatusCode, String actionCode) {
+        ObjectStatusTransitionDO transition = objectStatusTransitionMapper
+                .selectByObjectTypeAndFromStatusAndAction(PRODUCT_OBJECT_TYPE, fromStatusCode, actionCode);
+        if (transition == null) {
+            throw exception(ErrorCodeConstants.PRODUCT_STATUS_ACTION_NOT_ALLOWED, actionCode);
+        }
+        return transition;
+    }
+
+    @VisibleForTesting
+    void validateTransitionReason(ObjectStatusTransitionDO transition, String reason) {
+        if (Boolean.TRUE.equals(transition.getNeedReason()) && !StringUtils.hasText(reason)) {
+            throw exception(ErrorCodeConstants.PRODUCT_STATUS_ACTION_REASON_REQUIRED, transition.getActionCode());
+        }
+    }
+
+    @VisibleForTesting
+    void validateDeleteConfirmText(String confirmText) {
+        String normalizedConfirmText = normalizeNullableText(confirmText);
+        if (!Objects.equals(PRODUCT_DELETE_CONFIRM_TEXT, normalizedConfirmText)) {
+            throw exception(ErrorCodeConstants.PRODUCT_DELETE_CONFIRM_TEXT_INVALID);
+        }
+    }
+
+    private String generateProductCode(String code) {
+        String normalizedCode = normalizeNullableText(code);
+        if (StringUtils.hasText(normalizedCode)) {
+            validateProductCodeUnique(null, normalizedCode);
+            return normalizedCode;
+        }
+
+        String year = String.valueOf(LocalDate.now().getYear());
+        String codePrefix = PRODUCT_CODE_PREFIX + year;
+        int nextSequence = 1;
+        for (ProductDO product : productMapper.selectListByCodePrefix(codePrefix)) {
+            String existedCode = product.getCode();
+            if (!StringUtils.hasText(existedCode) || !existedCode.matches(codePrefix + "\\d{3}")) {
+                continue;
+            }
+            nextSequence = Integer.parseInt(existedCode.substring(codePrefix.length())) + 1;
+            break;
+        }
+        if (nextSequence > 999) {
+            throw invalidParamException("{} 年产品自动编码序号已用尽", year);
+        }
+        String generatedCode = codePrefix + String.format("%03d", nextSequence);
+        validateProductCodeUnique(null, generatedCode);
+        return generatedCode;
+    }
+
+    private void initManagerMemberRelation(ProductDO product) {
+        ObjectRoleRespDTO managerRole = objectPermissionApi
+                .getObjectRoleByCode(PRODUCT_MANAGER_ROLE_CODE, ROLE_SCOPE_OBJECT, PRODUCT_OBJECT_TYPE)
+                .getCheckedData();
+        if (managerRole == null) {
+            throw invalidParamException("未找到产品经理对象角色配置：{}", PRODUCT_MANAGER_ROLE_CODE);
+        }
+
+        UserObjectRoleDO member = new UserObjectRoleDO();
+        member.setUserId(product.getManagerUserId());
+        member.setObjectType(PRODUCT_OBJECT_TYPE);
+        member.setObjectId(product.getId());
+        member.setRoleId(managerRole.getId());
+        member.setStatus(MEMBER_STATUS_ACTIVE);
+        member.setJoinedTime(LocalDateTime.now());
+        member.setLeftTime(null);
+        userObjectRoleMapper.insert(member);
+
+        writeMemberInitAuditLog(member);
+        writeManagerInitAuditLog(product.getId(), product.getManagerUserId());
+    }
+
+    private ProductContextProductRespVO buildCurrentProduct(ProductDO product) {
+        return BeanUtils.toBean(product, ProductContextProductRespVO.class);
+    }
+
+    private ProductContextRoleRespVO buildCurrentRole(UserObjectRoleDO currentMember, ObjectRoleRespDTO currentRole) {
+        ProductContextRoleRespVO roleRespVO = new ProductContextRoleRespVO();
+        roleRespVO.setRoleId(currentMember.getRoleId());
+        if (currentRole != null) {
+            roleRespVO.setRoleCode(currentRole.getCode());
+            roleRespVO.setRoleName(currentRole.getName());
+        }
+        return roleRespVO;
+    }
+
+    private List<ProductContextNavRespVO> buildContextNavs(List<ObjectMenuRespDTO> menus) {
+        if (menus.isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        List<ProductContextNavRespVO> navs = menus.stream()
+                .filter(menu -> !MenuTypeEnum.BUTTON.getType().equals(menu.getType()))
+                .filter(menu -> !Boolean.FALSE.equals(menu.getVisible()))
+                .map(menu -> {
+                    ProductContextNavRespVO nav = new ProductContextNavRespVO();
+                    nav.setId(menu.getId());
+                    nav.setName(menu.getName());
+                    nav.setPath(menu.getPath());
+                    nav.setIcon(menu.getIcon());
+                    nav.setSort(menu.getSort());
+                    return nav;
+                })
+                .collect(Collectors.toCollection(ArrayList::new));
+
+        navs.sort(Comparator.comparing(ProductContextNavRespVO::getSort, Comparator.nullsLast(Integer::compareTo))
+                .thenComparing(ProductContextNavRespVO::getId, Comparator.nullsLast(Long::compareTo)));
+        return navs;
+    }
+
+    private List<String> buildContextButtons(List<ObjectMenuRespDTO> menus) {
+        if (menus.isEmpty()) {
+            return Collections.emptyList();
+        }
+        return menus.stream()
+                .filter(menu -> MenuTypeEnum.BUTTON.getType().equals(menu.getType()))
+                .map(ObjectMenuRespDTO::getPermission)
+                .filter(StringUtils::hasText)
+                .map(String::trim)
+                .distinct()
+                .sorted()
+                .collect(Collectors.toList());
+    }
+
+    private void writeProductStatusLog(ProductDO product, String actionType, String fromStatus,
+                                       String toStatus, String reason) {
+        ProductStatusLogDO statusLog = new ProductStatusLogDO();
+        statusLog.setProductId(product.getId());
+        statusLog.setActionType(actionType);
+        statusLog.setFromStatus(fromStatus);
+        statusLog.setToStatus(toStatus);
+        statusLog.setReason(defaultText(reason));
+        statusLog.setOperatorUserId(SecurityFrameworkUtils.getLoginUserId());
+        statusLog.setOperatorName(defaultText(SecurityFrameworkUtils.getLoginUserNickname()));
+        statusLog.setProductCodeSnapshot(product.getCode());
+        statusLog.setProductNameSnapshot(product.getName());
+        productStatusLogMapper.insert(statusLog);
+    }
+
+    private void writeBizAuditLog(ProductDO product, String actionType, String fromStatus, String toStatus,
+                                  String fieldChanges, String reason) {
+        BizAuditLogDO auditLog = new BizAuditLogDO();
+        auditLog.setBizType(PRODUCT_OBJECT_TYPE);
+        auditLog.setBizId(product.getId());
+        auditLog.setActionType(actionType);
+        auditLog.setFromStatus(fromStatus);
+        auditLog.setToStatus(toStatus);
+        auditLog.setFieldChanges(fieldChanges);
+        auditLog.setReason(reason);
+        auditLog.setOperatorUserId(SecurityFrameworkUtils.getLoginUserId());
+        auditLog.setOperatorName(defaultText(SecurityFrameworkUtils.getLoginUserNickname()));
+        bizAuditLogMapper.insert(auditLog);
+    }
+
+    private void writeMemberInitAuditLog(UserObjectRoleDO member) {
+        BizAuditLogDO auditLog = new BizAuditLogDO();
+        auditLog.setBizType(ObjectActivityConstants.MEMBER_BIZ_TYPE);
+        auditLog.setBizId(member.getId());
+        auditLog.setActionType(ObjectActivityConstants.MEMBER_ACTION_ADD);
+        auditLog.setFieldChanges(buildMemberFieldChanges(member));
+        auditLog.setOperatorUserId(SecurityFrameworkUtils.getLoginUserId());
+        auditLog.setOperatorName(defaultText(SecurityFrameworkUtils.getLoginUserNickname()));
+        bizAuditLogMapper.insert(auditLog);
+    }
+
+    private void writeManagerInitAuditLog(Long productId, Long managerUserId) {
+        BizAuditLogDO auditLog = new BizAuditLogDO();
+        auditLog.setBizType(PRODUCT_OBJECT_TYPE);
+        auditLog.setBizId(productId);
+        auditLog.setActionType(ObjectActivityConstants.PRODUCT_ACTION_CHANGE_MANAGER);
+        auditLog.setFieldChanges(buildManagerFieldChanges(null, managerUserId));
+        auditLog.setOperatorUserId(SecurityFrameworkUtils.getLoginUserId());
+        auditLog.setOperatorName(defaultText(SecurityFrameworkUtils.getLoginUserNickname()));
+        bizAuditLogMapper.insert(auditLog);
+    }
+
+    private ProductDO cloneProduct(ProductDO source) {
+        ProductDO target = new ProductDO();
+        target.setId(source.getId());
+        target.setCode(source.getCode());
+        target.setDirectionCode(source.getDirectionCode());
+        target.setStatusCode(source.getStatusCode());
+        target.setName(source.getName());
+        target.setManagerUserId(source.getManagerUserId());
+        target.setDescription(source.getDescription());
+        target.setLastStatusReason(source.getLastStatusReason());
+        return target;
+    }
+
+    private void applyProductBaseInfoUpdate(ProductDO product, String directionCode, String name, String description) {
+        validateProductEditable(product, directionCode, name);
+        validateProductNameUnique(product.getId(), name);
+
+        ProductDO before = cloneProduct(product);
+        product.setDirectionCode(directionCode);
+        product.setName(name.trim());
+        product.setDescription(normalizeNullableText(description));
+        productMapper.updateById(product);
+
+        writeBizAuditLog(product, ObjectActivityConstants.PRODUCT_ACTION_UPDATE, before.getStatusCode(), product.getStatusCode(),
+                buildProductFieldChanges(before, product), null);
+    }
+
+    private String buildProductFieldChanges(ProductDO before, ProductDO after) {
+        Map<String, Object> fieldChanges = new LinkedHashMap<>();
+        appendFieldChange(fieldChanges, "code", valueOf(before, ProductDO::getCode), valueOf(after, ProductDO::getCode));
+        appendFieldChange(fieldChanges, "directionCode", valueOf(before, ProductDO::getDirectionCode),
+                valueOf(after, ProductDO::getDirectionCode));
+        appendFieldChange(fieldChanges, "statusCode", valueOf(before, ProductDO::getStatusCode),
+                valueOf(after, ProductDO::getStatusCode));
+        appendFieldChange(fieldChanges, "name", valueOf(before, ProductDO::getName), valueOf(after, ProductDO::getName));
+        appendFieldChange(fieldChanges, "managerUserId", valueOf(before, ProductDO::getManagerUserId),
+                valueOf(after, ProductDO::getManagerUserId));
+        appendFieldChange(fieldChanges, "description", valueOf(before, ProductDO::getDescription),
+                valueOf(after, ProductDO::getDescription));
+        appendFieldChange(fieldChanges, "lastStatusReason", valueOf(before, ProductDO::getLastStatusReason),
+                valueOf(after, ProductDO::getLastStatusReason));
+        return fieldChanges.isEmpty() ? null : JsonUtils.toJsonString(fieldChanges);
+    }
+
+    private String buildMemberFieldChanges(UserObjectRoleDO member) {
+        Map<String, Object> fieldChanges = new LinkedHashMap<>();
+        appendFieldChange(fieldChanges, "userId", null, member.getUserId());
+        appendFieldChange(fieldChanges, "roleId", null, member.getRoleId());
+        appendFieldChange(fieldChanges, "status", null, member.getStatus());
+        appendFieldChange(fieldChanges, "joinedTime", null, member.getJoinedTime());
+        appendFieldChange(fieldChanges, "leftTime", null, member.getLeftTime());
+        appendFieldChange(fieldChanges, "remark", null, member.getRemark());
+        return JsonUtils.toJsonString(fieldChanges);
+    }
+
+    private String buildManagerFieldChanges(Long beforeManagerUserId, Long afterManagerUserId) {
+        Map<String, Object> fieldChanges = new LinkedHashMap<>();
+        appendFieldChange(fieldChanges, "managerUserId", beforeManagerUserId, afterManagerUserId);
+        return JsonUtils.toJsonString(fieldChanges);
+    }
+
+    private <T> T valueOf(ProductDO product, Function<ProductDO, T> getter) {
+        return product == null ? null : getter.apply(product);
+    }
+
+    private void appendFieldChange(Map<String, Object> fieldChanges, String fieldName, Object before, Object after) {
+        if (Objects.equals(before, after)) {
+            return;
+        }
+        Map<String, Object> value = new LinkedHashMap<>();
+        value.put("before", before);
+        value.put("after", after);
+        fieldChanges.put(fieldName, value);
+    }
+
+    private String normalizeNullableText(String value) {
+        if (!StringUtils.hasText(value)) {
+            return null;
+        }
+        return value.trim();
+    }
+
+    private String defaultText(String value) {
+        return StringUtils.hasText(value) ? value : "";
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductSettingService.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductSettingService.java
@@ -0,0 +1,42 @@
+package com.njcn.rdms.module.project.service.product;
+
+import com.njcn.rdms.framework.common.pojo.PageResult;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityPageReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityTimelinePageReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityTimelineRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.setting.ProductSettingRespVO;
+
+/**
+ * 产品设置 Service 接口
+ */
+public interface ProductSettingService {
+
+    /**
+     * 获取产品设置
+     *
+     * @param productId 产品编号
+     * @return 产品设置
+     */
+    ProductSettingRespVO getProductSettings(Long productId);
+
+    /**
+     * 获取产品动态
+     *
+     * @param productId 产品编号
+     * @param reqVO 查询参数
+     * @return 产品动态分页
+     */
+    PageResult<ProductActivityRespVO> getProductActivities(Long productId, ProductActivityPageReqVO reqVO);
+
+    /**
+     * 获取产品动态时间线分页
+     *
+     * @param productId 产品编号
+     * @param reqVO 查询参数
+     * @return 产品动态时间线分页
+     */
+    PageResult<ProductActivityTimelineRespVO> getProductActivityTimelinePage(
+            Long productId, ProductActivityTimelinePageReqVO reqVO);
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductSettingServiceImpl.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductSettingServiceImpl.java
@@ -0,0 +1,106 @@
+package com.njcn.rdms.module.project.service.product;
+
+import com.njcn.rdms.framework.common.pojo.CommonResult;
+import com.njcn.rdms.framework.common.pojo.PageResult;
+import com.njcn.rdms.module.project.framework.security.annotation.CheckObjectPermission;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityPageReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityTimelinePageReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityTimelineRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.setting.ProductSettingBaseInfoRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.setting.ProductSettingLifecycleRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.setting.ProductSettingRespVO;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductDO;
+import com.njcn.rdms.module.project.dal.mysql.product.ProductMapper;
+import com.njcn.rdms.module.project.enums.ErrorCodeConstants;
+import com.njcn.rdms.module.system.api.user.AdminUserApi;
+import com.njcn.rdms.module.system.api.user.dto.AdminUserRespDTO;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+import static com.njcn.rdms.framework.common.exception.util.ServiceExceptionUtil.exception;
+
+@Service
+public class ProductSettingServiceImpl implements ProductSettingService {
+
+    private static final String PRODUCT_OBJECT_TYPE = "product";
+    private static final String PRODUCT_QUERY_PERMISSION = "project:product:query";
+
+    @Resource
+    private ProductMapper productMapper;
+    @Resource
+    private AdminUserApi adminUserApi;
+    @Resource
+    private ProductStatusViewService productStatusViewService;
+    @Resource
+    private ProductActivityQueryService productActivityQueryService;
+    @Resource
+    private ProductActivityTimelineQueryService productActivityTimelineQueryService;
+
+    @Override
+    @CheckObjectPermission(objectType = PRODUCT_OBJECT_TYPE, objectId = "#productId",
+            permission = PRODUCT_QUERY_PERMISSION)
+    public ProductSettingRespVO getProductSettings(Long productId) {
+        ProductDO product = validateProductExists(productId);
+        ProductSettingRespVO respVO = new ProductSettingRespVO();
+        respVO.setBaseInfo(buildBaseInfo(product));
+        respVO.setLifecycle(buildLifecycle(product));
+        return respVO;
+    }
+
+    @Override
+    @CheckObjectPermission(objectType = PRODUCT_OBJECT_TYPE, objectId = "#productId",
+            permission = PRODUCT_QUERY_PERMISSION)
+    public PageResult<ProductActivityRespVO> getProductActivities(Long productId, ProductActivityPageReqVO reqVO) {
+        validateProductExists(productId);
+        return productActivityQueryService.getProductActivities(productId, reqVO);
+    }
+
+    @Override
+    @CheckObjectPermission(objectType = PRODUCT_OBJECT_TYPE, objectId = "#productId",
+            permission = PRODUCT_QUERY_PERMISSION)
+    public PageResult<ProductActivityTimelineRespVO> getProductActivityTimelinePage(
+            Long productId, ProductActivityTimelinePageReqVO reqVO) {
+        validateProductExists(productId);
+        return productActivityTimelineQueryService.getProductActivityTimelinePage(productId, reqVO);
+    }
+
+    private ProductDO validateProductExists(Long productId) {
+        if (productId == null) {
+            throw exception(ErrorCodeConstants.PRODUCT_NOT_EXISTS);
+        }
+        ProductDO product = productMapper.selectById(productId);
+        if (product == null) {
+            throw exception(ErrorCodeConstants.PRODUCT_NOT_EXISTS);
+        }
+        return product;
+    }
+
+    private ProductSettingBaseInfoRespVO buildBaseInfo(ProductDO product) {
+        ProductSettingBaseInfoRespVO baseInfo = new ProductSettingBaseInfoRespVO();
+        baseInfo.setId(product.getId());
+        baseInfo.setCode(product.getCode());
+        baseInfo.setDirectionCode(product.getDirectionCode());
+        baseInfo.setName(product.getName());
+        baseInfo.setManagerUserId(product.getManagerUserId());
+        baseInfo.setManagerUserNickname(getManagerNickname(product.getManagerUserId()));
+        baseInfo.setDescription(product.getDescription());
+        baseInfo.setStatusCode(product.getStatusCode());
+        baseInfo.setLastStatusReason(product.getLastStatusReason());
+        return baseInfo;
+    }
+
+    private ProductSettingLifecycleRespVO buildLifecycle(ProductDO product) {
+        return productStatusViewService.getLifecycle(product.getStatusCode(), product.getLastStatusReason());
+    }
+
+    private String getManagerNickname(Long managerUserId) {
+        if (managerUserId == null) {
+            return null;
+        }
+        CommonResult<AdminUserRespDTO> result = adminUserApi.getUser(managerUserId);
+        AdminUserRespDTO user = result == null ? null : result.getCheckedData();
+        return user == null ? null : user.getNickname();
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductStatusViewService.java
+++ b/rdms-project/rdms-project-boot/src/main/java/com/njcn/rdms/module/project/service/product/ProductStatusViewService.java
@@ -0,0 +1,60 @@
+package com.njcn.rdms.module.project.service.product;
+
+import com.njcn.rdms.module.project.controller.admin.product.vo.setting.ProductSettingActionRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.setting.ProductSettingLifecycleRespVO;
+import com.njcn.rdms.module.project.dal.dataobject.status.ObjectStatusModelDO;
+import com.njcn.rdms.module.project.dal.dataobject.status.ObjectStatusTransitionDO;
+import com.njcn.rdms.module.project.dal.mysql.status.ObjectStatusModelMapper;
+import com.njcn.rdms.module.project.dal.mysql.status.ObjectStatusTransitionMapper;
+import com.njcn.rdms.module.project.enums.ErrorCodeConstants;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+import java.util.Collections;
+import java.util.List;
+
+import static com.njcn.rdms.framework.common.exception.util.ServiceExceptionUtil.exception;
+
+@Service
+public class ProductStatusViewService {
+
+    private static final String PRODUCT_OBJECT_TYPE = "product";
+
+    @Resource
+    private ObjectStatusModelMapper objectStatusModelMapper;
+    @Resource
+    private ObjectStatusTransitionMapper objectStatusTransitionMapper;
+
+    public ProductSettingLifecycleRespVO getLifecycle(String statusCode, String lastStatusReason) {
+        ObjectStatusModelDO statusModel = objectStatusModelMapper
+                .selectByObjectTypeAndStatusCodeEnabled(PRODUCT_OBJECT_TYPE, statusCode);
+        if (statusModel == null) {
+            throw exception(ErrorCodeConstants.PRODUCT_STATUS_MODEL_NOT_EXISTS_OR_DISABLED);
+        }
+
+        ProductSettingLifecycleRespVO lifecycle = new ProductSettingLifecycleRespVO();
+        lifecycle.setStatusCode(statusModel.getStatusCode());
+        lifecycle.setStatusName(statusModel.getStatusName());
+        lifecycle.setTerminal(statusModel.getTerminalFlag());
+        lifecycle.setAllowEdit(statusModel.getAllowEdit());
+        lifecycle.setLastStatusReason(lastStatusReason);
+        lifecycle.setAvailableActions(buildAvailableActions(statusCode));
+        return lifecycle;
+    }
+
+    private List<ProductSettingActionRespVO> buildAvailableActions(String statusCode) {
+        List<ObjectStatusTransitionDO> transitions = objectStatusTransitionMapper
+                .selectListByObjectTypeAndFromStatus(PRODUCT_OBJECT_TYPE, statusCode);
+        if (transitions == null || transitions.isEmpty()) {
+            return Collections.emptyList();
+        }
+        return transitions.stream().map(transition -> {
+            ProductSettingActionRespVO action = new ProductSettingActionRespVO();
+            action.setActionCode(transition.getActionCode());
+            action.setActionName(transition.getActionName());
+            action.setNeedReason(transition.getNeedReason());
+            return action;
+        }).toList();
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/main/resources/application-dev.yaml
+++ b/rdms-project/rdms-project-boot/src/main/resources/application-dev.yaml
@@ -0,0 +1,92 @@
+#################### 注册中心 + 配置中心相关配置 ####################
+
+spring:
+  cloud:
+    nacos:
+      server-addr: 192.168.1.103:18848 # Nacos 服务器地址
+      username: # Nacos 账号
+      password: # Nacos 密码
+      discovery: # 【配置中心】配置项
+        namespace: dev # 命名空间。这里使用 dev 开发环境
+        group: DEFAULT_GROUP # 使用的 Nacos 配置分组，默认为 DEFAULT_GROUP
+        metadata:
+          version: 1.0.0 # 服务实例的版本号，可用于灰度发布
+      config: # 【注册中心】配置项
+        namespace: dev # 命名空间。这里使用 dev 开发环境
+        group: DEFAULT_GROUP # 使用的 Nacos 配置分组，默认为 DEFAULT_GROUP
+
+#################### 数据库相关配置 ####################
+  # 数据源配置项
+  autoconfigure:
+    exclude:
+  datasource:
+    druid: # Druid 【监控】相关的全局配置
+      web-stat-filter:
+        enabled: true
+      stat-view-servlet:
+        enabled: true
+        allow: # 设置白名单，不填则允许所有访问
+        url-pattern: /druid/*
+        login-username: # 控制台管理用户名和密码
+        login-password:
+      filter:
+        stat:
+          enabled: true
+          log-slow-sql: true # 慢 SQL 记录
+          slow-sql-millis: 100
+          merge-sql: true
+        wall:
+          config:
+            multi-statement-allow: true
+    dynamic: # 多数据源配置
+      druid: # Druid 【连接池】相关的全局配置
+        initial-size: 5 # 初始连接数
+        min-idle: 10 # 最小连接池数量
+        max-active: 20 # 最大连接池数量
+        max-wait: 60000 # 配置获取连接等待超时的时间，单位：毫秒（1 分钟）
+        time-between-eviction-runs-millis: 60000 # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位：毫秒（1 分钟）
+        min-evictable-idle-time-millis: 600000 # 配置一个连接在池中最小生存的时间，单位：毫秒（10 分钟）
+        max-evictable-idle-time-millis: 1800000 # 配置一个连接在池中最大生存的时间，单位：毫秒（30 分钟）
+        validation-query: SELECT 1 FROM DUAL # 配置检测连接是否有效
+        test-while-idle: true
+        test-on-borrow: false
+        test-on-return: false
+        pool-prepared-statements: true # 是否开启 PreparedStatement 缓存
+        max-pool-prepared-statement-per-connection-size: 20 # 每个连接缓存的 PreparedStatement 数量
+      primary: master
+      datasource:
+        master:
+          url: jdbc:mysql://192.168.1.22:13306/rdms_v3?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&nullCatalogMeansCurrent=true&rewriteBatchedStatements=true # MySQL Connector/J 8.X 连接的示例
+          username: root
+          password: njcnpqs
+
+  # Redis 配置。Redisson 默认的配置足够使用，一般不需要进行调优
+  data:
+    redis:
+      host: 192.168.1.22 # 地址
+      port: 16379 # 端口
+      database: 1 # 数据库索引
+#      password: njcnpqs # 密码，建议生产环境开启
+
+
+#################### 监控相关配置 ####################
+
+# Actuator 监控端点的配置项
+management:
+  endpoints:
+    web:
+      base-path: /actuator # Actuator 提供的 API 接口的根目录。默认为 /actuator
+      exposure:
+        include: '*' # 需要开放的端点。默认值只打开 health 和 info 两个端点。通过设置 *，可以开放所有端点。
+
+
+# 日志文件配置
+logging:
+  file:
+    name: ${user.home}/logs/${spring.application.name}.log # 日志文件名，全路径
+
+#################### RDMS 相关配置 ####################
+
+# RDMS 配置项，设置当前项目所有自定义的配置
+rdms:
+  demo: true # 开启演示模式
--- a/rdms-project/rdms-project-boot/src/main/resources/application-local.yaml
+++ b/rdms-project/rdms-project-boot/src/main/resources/application-local.yaml
@@ -0,0 +1,98 @@
+#################### 注册中心 + 配置中心相关配置 ####################
+spring:
+  cloud:
+    nacos:
+      server-addr: 192.168.1.103:18848 # Nacos 服务器地址
+      username: # Nacos 账号
+      password: # Nacos 密码
+      discovery: # 【配置中心】配置项
+        namespace: dev # 命名空间。这里使用 dev 开发环境
+        group: DEFAULT_GROUP # 使用的 Nacos 配置分组，默认为 DEFAULT_GROUP
+        metadata:
+          version: 1.0.0 # 服务实例的版本号，可用于灰度发布
+      config: # 【注册中心】配置项
+        namespace: dev # 命名空间。这里使用 dev 开发环境
+        group: DEFAULT_GROUP # 使用的 Nacos 配置分组，默认为 DEFAULT_GROUP
+
+#################### 数据库相关配置 ####################
+  # 数据源配置项
+  autoconfigure:
+    exclude:
+  datasource:
+    druid: # Druid 【监控】相关的全局配置
+      web-stat-filter:
+        enabled: true
+      stat-view-servlet:
+        enabled: true
+        allow: # 设置白名单，不填则允许所有访问
+        url-pattern: /druid/*
+        login-username: # 控制台管理用户名和密码
+        login-password:
+      filter:
+        stat:
+          enabled: true
+          log-slow-sql: true # 慢 SQL 记录
+          slow-sql-millis: 100
+          merge-sql: true
+        wall:
+          config:
+            multi-statement-allow: true
+    dynamic: # 多数据源配置
+      druid: # Druid 【连接池】相关的全局配置
+        initial-size: 5 # 初始连接数
+        min-idle: 10 # 最小连接池数量
+        max-active: 20 # 最大连接池数量
+        max-wait: 60000 # 配置获取连接等待超时的时间，单位：毫秒（1 分钟）
+        time-between-eviction-runs-millis: 60000 # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位：毫秒（1 分钟）
+        min-evictable-idle-time-millis: 600000 # 配置一个连接在池中最小生存的时间，单位：毫秒（10 分钟）
+        max-evictable-idle-time-millis: 1800000 # 配置一个连接在池中最大生存的时间，单位：毫秒（30 分钟）
+        validation-query: SELECT 1 FROM DUAL # 配置检测连接是否有效
+        test-while-idle: true
+        test-on-borrow: false
+        test-on-return: false
+        pool-prepared-statements: true # 是否开启 PreparedStatement 缓存
+        max-pool-prepared-statement-per-connection-size: 20 # 每个连接缓存的 PreparedStatement 数量
+      primary: master
+      datasource:
+        master:
+          url: jdbc:mysql://192.168.1.22:13306/rdms_v3?useSSL=false&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&nullCatalogMeansCurrent=true&rewriteBatchedStatements=true # MySQL Connector/J 8.X 连接的示例
+          username: root
+          password: njcnpqs
+
+  # Redis 配置。Redisson 默认的配置足够使用，一般不需要进行调优
+  data:
+    redis:
+      host: 127.0.0.1 # 地址
+      port: 16379 # 端口
+      database: 1 # 数据库索引
+#      password: njcnpqs # 密码，建议生产环境开启
+
+
+#################### 监控相关配置 ####################
+
+# Actuator 监控端点的配置项
+management:
+  endpoints:
+    web:
+      base-path: /actuator # Actuator 提供的 API 接口的根目录。默认为 /actuator
+      exposure:
+        include: '*' # 需要开放的端点。默认值只打开 health 和 info 两个端点。通过设置 *，可以开放所有端点。
+
+
+# 日志文件配置
+logging:
+  level:
+    # 配置本模块 MyBatis Mapper 打印日志
+    com.njcn.rdms.module.project.dal.mysql: debug
+    org.springframework.context.support.PostProcessorRegistrationDelegate: ERROR
+
+# RDMS 配置项，设置当前项目所有自定义的本地扩展配置
+rdms:
+  env: # 多环境的配置项
+    tag: ${HOSTNAME}
+  captcha:
+    enable: false
+  security:
+    mock-enable: true
+  access-log: # 访问日志的配置项
+    enable: true
--- a/rdms-project/rdms-project-boot/src/main/resources/application.yaml
+++ b/rdms-project/rdms-project-boot/src/main/resources/application.yaml
@@ -0,0 +1,105 @@
+spring:
+  application:
+    name: rdms-project-server
+  profiles:
+    active: local
+  main:
+    allow-circular-references: true # 允许循环依赖，因为项目当前沿用三层架构组织方式。
+    allow-bean-definition-overriding: true # 允许 Bean 覆盖，例如 Feign 等会存在重复定义的服务
+  config:
+    import:
+      - optional:classpath:application-${spring.profiles.active}.yaml # 加载【本地】配置
+      - optional:nacos:${spring.application.name}-${spring.profiles.active}.yaml # 加载【Nacos】的配置
+  # Servlet 配置
+  servlet:
+    # 文件上传相关配置项
+    multipart:
+      max-file-size: 16MB # 单个文件大小
+      max-request-size: 32MB # 设置总上传的文件大小
+  # Jackson 配置项
+  jackson:
+    serialization:
+      write-dates-as-timestamps: true # 设置 LocalDateTime 的格式，使用时间戳
+      write-date-timestamps-as-nanoseconds: false # 设置不使用 nanoseconds 的格式，例如 1611460870401
+      write-durations-as-timestamps: true # 设置 Duration 的格式，使用时间戳
+      fail-on-empty-beans: false # 允许序列化无属性的 Bean
+  # Cache 配置项
+  cache:
+    type: REDIS
+    redis:
+      time-to-live: 1h # 设置过期时间为 1 小时
+  data:
+    redis:
+      repositories:
+        enabled: false # 项目未使用到 Spring Data Redis 的 Repository，所以直接禁用，保证启动速度
+  # 热部署配置
+  devtools:
+    restart:
+      enabled: true
+
+server:
+  port: 48082
+
+logging:
+  file:
+    name: ${user.home}/logs/${spring.application.name}.log # 日志文件名，全路径
+
+--- #################### 接口文档配置 ####################
+springdoc:
+  api-docs:
+    enabled: true # 1. 是否开启 Swagger 接口文档的元数据
+    path: /v3/api-docs
+  swagger-ui:
+    enabled: true # 2.1 是否开启 Swagger 文档的官方 UI 界面
+    path: /swagger-ui
+  default-flat-param-object: true
+
+knife4j:
+  enable: true
+  setting:
+    language: zh_cn
+
+# MyBatis Plus 的配置项
+mybatis-plus:
+  configuration:
+    map-underscore-to-camel-case: true # 虽然默认为 true，但是还是显示指定下。
+  global-config:
+    db-config:
+      id-type: ASSIGN_ID # 分配 ID，默认使用雪花算法
+      logic-delete-value: 1 # 逻辑已删除值（默认为 1）
+      logic-not-delete-value: 0 # 逻辑未删除值（默认为 0）
+    banner: false # 关闭控制台的 Banner 打印
+  type-aliases-package: ${rdms.info.base-package}.dal.dataobject
+  encryptor:
+    password: cDHvwsYb9eyLNBHp # 加解密秘钥，生产环境务必通过 Nacos 注入，切勿硬编码
+
+mybatis-plus-join:
+  banner: false # 关闭控制台的 Banner 打印
+
+# VO 转换（数据翻译）相关
+easy-trans:
+  is-enable-global: false # 默认禁用全局翻译，避免额外性能开销
+
+--- #################### RDMS 相关配置 ####################
+rdms:
+  info:
+    version: 1.0.0
+    base-package: com.njcn.rdms.module.project
+  web:
+    admin-ui:
+      url: https://www.baidu.com # Admin 管理后台 UI 的占位地址，联调时替换成实际前端入口
+  xss:
+    enable: false
+    exclude-urls:
+      - ${management.endpoints.web.base-path}/** # 不处理 Actuator 的请求
+  swagger:
+    title: 项目交付域管理后台
+    description: 提供项目集、项目、产品、需求、任务、工单、执行等管理能力
+    author: RDMS
+    version: ${rdms.info.version}
+    url: https://example.com
+    email: dev@example.com
+    license: Apache 2.0
+    license-url: https://www.apache.org/licenses/LICENSE-2.0.html
+
+debug: false
--- a/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/framework/security/aop/ObjectPermissionAspectTest.java
+++ b/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/framework/security/aop/ObjectPermissionAspectTest.java
@@ -0,0 +1,80 @@
+package com.njcn.rdms.module.project.framework.security.aop;
+
+import com.njcn.rdms.framework.test.core.ut.BaseMockitoUnitTest;
+import com.njcn.rdms.module.project.framework.security.annotation.CheckObjectPermission;
+import com.njcn.rdms.module.project.framework.security.service.ObjectPermissionService;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.springframework.aop.aspectj.annotation.AspectJProxyFactory;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+class ObjectPermissionAspectTest extends BaseMockitoUnitTest {
+
+    @Mock
+    private ObjectPermissionService objectPermissionService;
+
+    @Test
+    void around_shouldResolveProductIdFromMethodArgument() {
+        when(objectPermissionService.getObjectType()).thenReturn("product");
+        DemoService proxy = createProxy();
+
+        String result = proxy.getProduct(1001L);
+
+        assertEquals("ok", result);
+        verify(objectPermissionService, times(1))
+                .checkPermission(1001L, "project:product:query", false);
+    }
+
+    @Test
+    void around_shouldResolveProductIdFromReqVoAndPassMemberOnlyFlag() {
+        when(objectPermissionService.getObjectType()).thenReturn("product");
+        DemoService proxy = createProxy();
+        DemoReqVO reqVO = new DemoReqVO();
+        reqVO.setId(1002L);
+
+        String result = proxy.getProductContext(reqVO);
+
+        assertEquals("context", result);
+        verify(objectPermissionService, times(1))
+                .checkPermission(1002L, "", true);
+    }
+
+    private DemoService createProxy() {
+        AspectJProxyFactory proxyFactory = new AspectJProxyFactory(new DemoService());
+        proxyFactory.addAspect(new ObjectPermissionAspect(java.util.List.of(objectPermissionService)));
+        return proxyFactory.getProxy();
+    }
+
+    static class DemoService {
+
+        @CheckObjectPermission(objectType = "product", objectId = "#productId", permission = "project:product:query")
+        public String getProduct(Long productId) {
+            return "ok";
+        }
+
+        @CheckObjectPermission(objectType = "product", objectId = "#reqVO.id", memberOnly = true)
+        public String getProductContext(DemoReqVO reqVO) {
+            return "context";
+        }
+
+    }
+
+    static class DemoReqVO {
+
+        private Long id;
+
+        public Long getId() {
+            return id;
+        }
+
+        public void setId(Long id) {
+            this.id = id;
+        }
+
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/framework/security/service/ProductObjectPermissionServiceTest.java
+++ b/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/framework/security/service/ProductObjectPermissionServiceTest.java
@@ -0,0 +1,114 @@
+package com.njcn.rdms.module.project.framework.security.service;
+
+import com.njcn.rdms.framework.common.exception.ServiceException;
+import com.njcn.rdms.framework.security.core.util.SecurityFrameworkUtils;
+import com.njcn.rdms.framework.test.core.ut.BaseMockitoUnitTest;
+import com.njcn.rdms.module.project.dal.dataobject.member.UserObjectRoleDO;
+import com.njcn.rdms.module.project.dal.mysql.member.UserObjectRoleMapper;
+import com.njcn.rdms.module.project.enums.ErrorCodeConstants;
+import com.njcn.rdms.module.system.api.permission.ObjectPermissionApi;
+import com.njcn.rdms.module.system.enums.permission.PermissionScopeTypeEnum;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+
+import java.util.Set;
+
+import static com.njcn.rdms.framework.common.pojo.CommonResult.success;
+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.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+
+class ProductObjectPermissionServiceTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private ProductObjectPermissionService permissionService;
+    @Mock
+    private UserObjectRoleMapper userObjectRoleMapper;
+    @Mock
+    private ObjectPermissionApi objectPermissionApi;
+
+    @Test
+    void checkPermission_whenMemberOnlyAndCurrentUserIsMember_shouldPass() {
+        Long productId = 1001L;
+        Long loginUserId = 2001L;
+        when(userObjectRoleMapper.selectActiveByObjectAndUserId("product", productId, loginUserId))
+                .thenReturn(createMember(productId, loginUserId, 3001L));
+
+        try (MockedStatic<SecurityFrameworkUtils> mockedStatic = mockLoginUser(loginUserId)) {
+            assertDoesNotThrow(() -> permissionService.checkPermission(productId, null, true));
+        }
+
+        verifyNoInteractions(objectPermissionApi);
+    }
+
+    @Test
+    void checkPermission_whenCurrentRolePermissionsContainTarget_shouldPass() {
+        Long productId = 1002L;
+        Long loginUserId = 2002L;
+        when(userObjectRoleMapper.selectActiveByObjectAndUserId("product", productId, loginUserId))
+                .thenReturn(createMember(productId, loginUserId, 3002L));
+        when(objectPermissionApi.getObjectRolePermissions(3002L,
+                PermissionScopeTypeEnum.OBJECT.getScopeType(), "product"))
+                .thenReturn(success(Set.of("project:product:query")));
+
+        try (MockedStatic<SecurityFrameworkUtils> mockedStatic = mockLoginUser(loginUserId)) {
+            assertDoesNotThrow(() -> permissionService.checkPermission(productId, "project:product:query", false));
+        }
+    }
+
+    @Test
+    void checkPermission_whenCurrentRoleDoesNotContainPermission_shouldThrowException() {
+        Long productId = 1003L;
+        Long loginUserId = 2003L;
+        when(userObjectRoleMapper.selectActiveByObjectAndUserId("product", productId, loginUserId))
+                .thenReturn(createMember(productId, loginUserId, 3003L));
+        when(objectPermissionApi.getObjectRolePermissions(3003L,
+                PermissionScopeTypeEnum.OBJECT.getScopeType(), "product"))
+                .thenReturn(success(Set.of("project:product:update")));
+
+        try (MockedStatic<SecurityFrameworkUtils> mockedStatic = mockLoginUser(loginUserId)) {
+            ServiceException ex = assertThrows(ServiceException.class,
+                    () -> permissionService.checkPermission(productId, "project:product:delete", false));
+            assertEquals(ErrorCodeConstants.PRODUCT_OBJECT_PERMISSION_DENIED.getCode(), ex.getCode());
+        }
+    }
+
+    @Test
+    void checkPermission_whenCurrentUserIsNotMember_shouldThrowException() {
+        Long productId = 1004L;
+        Long loginUserId = 2004L;
+        when(userObjectRoleMapper.selectActiveByObjectAndUserId("product", productId, loginUserId))
+                .thenReturn(null);
+
+        try (MockedStatic<SecurityFrameworkUtils> mockedStatic = mockLoginUser(loginUserId)) {
+            ServiceException ex = assertThrows(ServiceException.class,
+                    () -> permissionService.checkPermission(productId, "project:product:query", false));
+            assertEquals(ErrorCodeConstants.PRODUCT_OBJECT_PERMISSION_DENIED.getCode(), ex.getCode());
+        }
+
+        verifyNoInteractions(objectPermissionApi);
+    }
+
+    private UserObjectRoleDO createMember(Long productId, Long loginUserId, Long roleId) {
+        UserObjectRoleDO member = new UserObjectRoleDO();
+        member.setId(9001L);
+        member.setUserId(loginUserId);
+        member.setObjectType("product");
+        member.setObjectId(productId);
+        member.setRoleId(roleId);
+        member.setStatus(0);
+        return member;
+    }
+
+    private MockedStatic<SecurityFrameworkUtils> mockLoginUser(Long loginUserId) {
+        MockedStatic<SecurityFrameworkUtils> mockedStatic = mockStatic(SecurityFrameworkUtils.class);
+        mockedStatic.when(SecurityFrameworkUtils::getLoginUserId).thenReturn(loginUserId);
+        return mockedStatic;
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/service/product/ProductActivityQueryServiceTest.java
+++ b/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/service/product/ProductActivityQueryServiceTest.java
@@ -0,0 +1,213 @@
+package com.njcn.rdms.module.project.service.product;
+
+import com.njcn.rdms.framework.common.pojo.PageResult;
+import com.njcn.rdms.framework.common.util.json.JsonUtils;
+import com.njcn.rdms.framework.test.core.ut.BaseMockitoUnitTest;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityPageReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityRespVO;
+import com.njcn.rdms.module.project.dal.dataobject.audit.BizAuditLogDO;
+import com.njcn.rdms.module.project.dal.dataobject.member.UserObjectRoleDO;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductStatusLogDO;
+import com.njcn.rdms.module.project.dal.mysql.audit.BizAuditLogMapper;
+import com.njcn.rdms.module.project.dal.mysql.member.UserObjectRoleMapper;
+import com.njcn.rdms.module.project.dal.mysql.product.ProductStatusLogMapper;
+import com.njcn.rdms.module.system.api.permission.ObjectPermissionApi;
+import com.njcn.rdms.module.system.api.permission.dto.ObjectRoleRespDTO;
+import org.junit.jupiter.api.Test;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anySet;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+class ProductActivityQueryServiceTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private ProductActivityQueryService productActivityQueryService;
+    @Mock
+    private ProductStatusLogMapper productStatusLogMapper;
+    @Mock
+    private BizAuditLogMapper bizAuditLogMapper;
+    @Mock
+    private UserObjectRoleMapper userObjectRoleMapper;
+    @Mock
+    private CacheManager cacheManager;
+    @Mock
+    private Cache roleNameCache;
+    @Mock
+    private ObjectPermissionApi objectPermissionApi;
+
+    @Test
+    void getProductActivities_shouldMergeStatusProductAndMemberActivities() {
+        Long productId = 1001L;
+        ProductActivityPageReqVO reqVO = new ProductActivityPageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+
+        ProductStatusLogDO statusLog = new ProductStatusLogDO();
+        statusLog.setId(11L);
+        statusLog.setProductId(productId);
+        statusLog.setActionType("pause");
+        statusLog.setOperatorName("张三");
+        statusLog.setReason("资源不足");
+        statusLog.setCreateTime(LocalDateTime.of(2026, 4, 21, 10, 0, 0));
+
+        BizAuditLogDO productAudit = new BizAuditLogDO();
+        productAudit.setId(22L);
+        productAudit.setBizType("product");
+        productAudit.setBizId(productId);
+        productAudit.setActionType("update");
+        productAudit.setOperatorName("李四");
+        productAudit.setCreateTime(LocalDateTime.of(2026, 4, 21, 11, 0, 0));
+
+        BizAuditLogDO memberAudit = new BizAuditLogDO();
+        memberAudit.setId(33L);
+        memberAudit.setBizType("rdms_user_object_role");
+        memberAudit.setBizId(9001L);
+        memberAudit.setActionType("add_member");
+        memberAudit.setOperatorName("王五");
+        memberAudit.setCreateTime(LocalDateTime.of(2026, 4, 21, 12, 0, 0));
+
+        UserObjectRoleDO member = new UserObjectRoleDO();
+        member.setId(9001L);
+        member.setObjectType("product");
+        member.setObjectId(productId);
+
+        when(productStatusLogMapper.selectListByProductId(productId, null, null))
+                .thenReturn(List.of(statusLog));
+        when(bizAuditLogMapper.selectListByBiz("product", productId, null, null))
+                .thenReturn(List.of(productAudit));
+        when(bizAuditLogMapper.selectListByBizType("rdms_user_object_role", null, null))
+                .thenReturn(List.of(memberAudit));
+        when(userObjectRoleMapper.selectListByIdsAndObject(List.of(9001L), "product", productId))
+                .thenReturn(List.of(member));
+
+        PageResult<ProductActivityRespVO> result = productActivityQueryService.getProductActivities(productId, reqVO);
+
+        assertEquals(3L, result.getTotal());
+        assertEquals("member", result.getList().get(0).getType());
+        assertEquals("product", result.getList().get(1).getType());
+        assertEquals("status", result.getList().get(2).getType());
+    }
+
+    @Test
+    void getProductActivities_shouldIgnoreOrphanMemberAuditAndFilterByType() {
+        Long productId = 1002L;
+        ProductActivityPageReqVO reqVO = new ProductActivityPageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+        reqVO.setActivityType("member");
+
+        BizAuditLogDO orphanMemberAudit = new BizAuditLogDO();
+        orphanMemberAudit.setId(44L);
+        orphanMemberAudit.setBizType("rdms_user_object_role");
+        orphanMemberAudit.setBizId(9900L);
+        orphanMemberAudit.setActionType("remove_member");
+        orphanMemberAudit.setCreateTime(LocalDateTime.of(2026, 4, 21, 9, 0, 0));
+
+        when(bizAuditLogMapper.selectListByBizType("rdms_user_object_role", null, null))
+                .thenReturn(List.of(orphanMemberAudit));
+        when(userObjectRoleMapper.selectListByIdsAndObject(List.of(9900L), "product", productId))
+                .thenReturn(List.of());
+
+        PageResult<ProductActivityRespVO> result = productActivityQueryService.getProductActivities(productId, reqVO);
+
+        assertEquals(0L, result.getTotal());
+        assertEquals(0, result.getList().size());
+    }
+
+    @Test
+    void getProductActivities_shouldAppendRoleNameToMemberDetails() {
+        Long productId = 1003L;
+        ProductActivityPageReqVO reqVO = new ProductActivityPageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+        reqVO.setActivityType("member");
+
+        BizAuditLogDO memberAudit = new BizAuditLogDO();
+        memberAudit.setId(55L);
+        memberAudit.setBizType("rdms_user_object_role");
+        memberAudit.setBizId(9002L);
+        memberAudit.setActionType("update_member");
+        memberAudit.setFieldChanges("{\"roleId\":{\"before\":3201,\"after\":3202}}");
+        memberAudit.setCreateTime(LocalDateTime.of(2026, 4, 21, 13, 0, 0));
+
+        UserObjectRoleDO member = new UserObjectRoleDO();
+        member.setId(9002L);
+        member.setObjectType("product");
+        member.setObjectId(productId);
+
+        when(bizAuditLogMapper.selectListByBizType("rdms_user_object_role", null, null))
+                .thenReturn(List.of(memberAudit));
+        when(userObjectRoleMapper.selectListByIdsAndObject(List.of(9002L), "product", productId))
+                .thenReturn(List.of(member));
+        when(cacheManager.getCache("project_activity_role_name#10m")).thenReturn(roleNameCache);
+        when(roleNameCache.get(3201L, String.class)).thenReturn("产品经理");
+        when(roleNameCache.get(3202L, String.class)).thenReturn("产品成员");
+
+        PageResult<ProductActivityRespVO> result = productActivityQueryService.getProductActivities(productId, reqVO);
+
+        assertEquals("产品经理", JsonUtils.parseTree(result.getList().get(0).getDetails())
+                .path("roleName").path("before").asText());
+        assertEquals("产品成员", JsonUtils.parseTree(result.getList().get(0).getDetails())
+                .path("roleName").path("after").asText());
+        verify(objectPermissionApi, never()).getObjectRoleMap(anySet(), any(), any());
+    }
+
+    @Test
+    void getProductActivities_shouldLoadAndCacheRoleNameWhenCacheMiss() {
+        Long productId = 1004L;
+        ProductActivityPageReqVO reqVO = new ProductActivityPageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+        reqVO.setActivityType("member");
+
+        BizAuditLogDO memberAudit = new BizAuditLogDO();
+        memberAudit.setId(66L);
+        memberAudit.setBizType("rdms_user_object_role");
+        memberAudit.setBizId(9003L);
+        memberAudit.setActionType("add_member");
+        memberAudit.setFieldChanges("{\"roleId\":{\"before\":null,\"after\":3203}}");
+        memberAudit.setCreateTime(LocalDateTime.of(2026, 4, 21, 14, 0, 0));
+
+        UserObjectRoleDO member = new UserObjectRoleDO();
+        member.setId(9003L);
+        member.setObjectType("product");
+        member.setObjectId(productId);
+
+        when(bizAuditLogMapper.selectListByBizType("rdms_user_object_role", null, null))
+                .thenReturn(List.of(memberAudit));
+        when(userObjectRoleMapper.selectListByIdsAndObject(List.of(9003L), "product", productId))
+                .thenReturn(List.of(member));
+        when(cacheManager.getCache("project_activity_role_name#10m")).thenReturn(roleNameCache);
+        when(roleNameCache.get(3203L, String.class)).thenReturn(null);
+        when(objectPermissionApi.getObjectRoleMap(java.util.Set.of(3203L), "object", "product"))
+                .thenReturn(Map.of(3203L, buildRole(3203L, "观察者")));
+
+        PageResult<ProductActivityRespVO> result = productActivityQueryService.getProductActivities(productId, reqVO);
+
+        assertEquals("观察者", JsonUtils.parseTree(result.getList().get(0).getDetails())
+                .path("roleName").path("after").asText());
+        verify(roleNameCache).put(3203L, "观察者");
+    }
+
+    private ObjectRoleRespDTO buildRole(Long id, String name) {
+        ObjectRoleRespDTO role = new ObjectRoleRespDTO();
+        role.setId(id);
+        role.setName(name);
+        role.setScopeType("object");
+        role.setObjectType("product");
+        return role;
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/service/product/ProductActivityTimelineQueryServiceTest.java
+++ b/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/service/product/ProductActivityTimelineQueryServiceTest.java
@@ -0,0 +1,424 @@
+package com.njcn.rdms.module.project.service.product;
+
+import com.njcn.rdms.framework.common.exception.ServiceException;
+import com.njcn.rdms.framework.common.pojo.PageResult;
+import com.njcn.rdms.framework.common.util.json.JsonUtils;
+import com.njcn.rdms.framework.test.core.ut.BaseMockitoUnitTest;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityTimelinePageReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityTimelineRespVO;
+import com.njcn.rdms.module.project.dal.dataobject.audit.BizAuditLogDO;
+import com.njcn.rdms.module.project.dal.dataobject.member.UserObjectRoleDO;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductStatusLogDO;
+import com.njcn.rdms.module.project.dal.mysql.audit.BizAuditLogMapper;
+import com.njcn.rdms.module.project.dal.mysql.member.UserObjectRoleMapper;
+import com.njcn.rdms.module.project.dal.mysql.product.ProductStatusLogMapper;
+import com.njcn.rdms.module.system.api.permission.ObjectPermissionApi;
+import com.njcn.rdms.module.system.api.permission.dto.ObjectRoleRespDTO;
+import com.njcn.rdms.module.system.api.user.AdminUserApi;
+import com.njcn.rdms.module.system.api.user.dto.AdminUserRespDTO;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.BeanWrapperImpl;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+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.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.anySet;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+class ProductActivityTimelineQueryServiceTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private ProductActivityTimelineQueryService productActivityTimelineQueryService;
+    @Mock
+    private ProductStatusLogMapper productStatusLogMapper;
+    @Mock
+    private BizAuditLogMapper bizAuditLogMapper;
+    @Mock
+    private UserObjectRoleMapper userObjectRoleMapper;
+    @Mock
+    private CacheManager cacheManager;
+    @Mock
+    private Cache userNicknameCache;
+    @Mock
+    private Cache roleNameCache;
+    @Mock
+    private AdminUserApi adminUserApi;
+    @Mock
+    private ObjectPermissionApi objectPermissionApi;
+
+    @Test
+    void getProductActivityTimelinePage_whenTimeRangeMissingEnd_shouldThrowInvalidParam() {
+        ProductActivityTimelinePageReqVO reqVO = new ProductActivityTimelinePageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+        reqVO.setStartTime(LocalDateTime.of(2026, 4, 1, 0, 0, 0));
+
+        ServiceException ex = assertThrows(ServiceException.class,
+                () -> productActivityTimelineQueryService.getProductActivityTimelinePage(1001L, reqVO));
+
+        assertTrue(ex.getMessage().contains("开始时间和结束时间必须同时传入"));
+    }
+
+    @Test
+    void getProductActivityTimelinePage_shouldUseDefaultRecent30DaysAndActionTypes() {
+        Long productId = 1001L;
+        ProductActivityTimelinePageReqVO reqVO = new ProductActivityTimelinePageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+        reqVO.setActivityType("status");
+        reqVO.setActionTypes(List.of("pause", "archive"));
+
+        when(productStatusLogMapper.selectListByProductIdAndActions(eq(productId), eq(List.of("pause", "archive")),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of());
+
+        PageResult<ProductActivityTimelineRespVO> result =
+                productActivityTimelineQueryService.getProductActivityTimelinePage(productId, reqVO);
+
+        ArgumentCaptor<LocalDateTime> startCaptor = ArgumentCaptor.forClass(LocalDateTime.class);
+        ArgumentCaptor<LocalDateTime> endCaptor = ArgumentCaptor.forClass(LocalDateTime.class);
+        verify(productStatusLogMapper).selectListByProductIdAndActions(eq(productId), eq(List.of("pause", "archive")),
+                startCaptor.capture(), endCaptor.capture());
+
+        assertEquals(0L, result.getTotal());
+        assertTrue(Duration.between(startCaptor.getValue(), endCaptor.getValue()).toDays() >= 29);
+        assertTrue(Duration.between(startCaptor.getValue(), endCaptor.getValue()).toDays() <= 31);
+    }
+
+    @Test
+    void getProductActivityTimelinePage_shouldKeepSingleCreateAndIgnoreInitNoise() {
+        Long productId = 1002L;
+        ProductActivityTimelinePageReqVO reqVO = new ProductActivityTimelinePageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+
+        BizAuditLogDO createLog = buildProductLog(21L, productId, "create",
+                "{\"managerUserId\":{\"before\":null,\"after\":2001}}",
+                LocalDateTime.of(2026, 4, 23, 10, 0, 0));
+        BizAuditLogDO managerInitLog = buildProductLog(22L, productId, "change_manager",
+                "{\"managerUserId\":{\"before\":null,\"after\":2001}}",
+                LocalDateTime.of(2026, 4, 23, 10, 0, 0));
+        BizAuditLogDO memberInitLog = buildMemberLog(31L, 9001L, "add_member",
+                "{\"userId\":{\"before\":null,\"after\":2001}}",
+                LocalDateTime.of(2026, 4, 23, 10, 0, 0));
+
+        when(productStatusLogMapper.selectListByProductIdAndActions(eq(productId), any(),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of());
+        when(bizAuditLogMapper.selectListByBizAndActions(eq("product"), eq(productId), any(),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of(managerInitLog, createLog));
+        when(bizAuditLogMapper.selectListByBizTypeAndActions(eq("rdms_user_object_role"), any(),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of(memberInitLog));
+        when(userObjectRoleMapper.selectListByIdsAndObject(List.of(9001L), "product", productId))
+                .thenReturn(List.of(buildMember(9001L, productId, 2001L)));
+
+        PageResult<ProductActivityTimelineRespVO> result =
+                productActivityTimelineQueryService.getProductActivityTimelinePage(productId, reqVO);
+
+        assertEquals(1L, result.getTotal());
+        assertEquals("product", result.getList().get(0).getType());
+        assertEquals("create", result.getList().get(0).getActionType());
+    }
+
+    @Test
+    void getProductActivityTimelinePage_shouldPreferStatusLogOverProductStatusAudit() {
+        Long productId = 1003L;
+        ProductActivityTimelinePageReqVO reqVO = new ProductActivityTimelinePageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+
+        ProductStatusLogDO statusLog = buildStatusLog(11L, productId, "pause",
+                "active", "paused", LocalDateTime.of(2026, 4, 22, 9, 0, 0));
+        BizAuditLogDO statusAudit = buildProductLog(12L, productId, "pause", null,
+                LocalDateTime.of(2026, 4, 22, 9, 0, 0));
+
+        when(productStatusLogMapper.selectListByProductIdAndActions(eq(productId), any(),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of(statusLog));
+        when(bizAuditLogMapper.selectListByBizAndActions(eq("product"), eq(productId), any(),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of(statusAudit));
+        when(bizAuditLogMapper.selectListByBizTypeAndActions(eq("rdms_user_object_role"), any(),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of());
+
+        PageResult<ProductActivityTimelineRespVO> result =
+                productActivityTimelineQueryService.getProductActivityTimelinePage(productId, reqVO);
+
+        assertEquals(1L, result.getTotal());
+        assertEquals("status:11", result.getList().get(0).getId());
+    }
+
+    @Test
+    void getProductActivityTimelinePage_shouldFilterMemberActionsByIntersection() {
+        Long productId = 1004L;
+        ProductActivityTimelinePageReqVO reqVO = new ProductActivityTimelinePageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+        reqVO.setActivityType("member");
+        reqVO.setActionTypes(List.of("remove_member"));
+
+        when(bizAuditLogMapper.selectListByBizTypeAndActions(eq("rdms_user_object_role"), eq(List.of("remove_member")),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of());
+
+        PageResult<ProductActivityTimelineRespVO> result =
+                productActivityTimelineQueryService.getProductActivityTimelinePage(productId, reqVO);
+
+        assertEquals(0L, result.getTotal());
+        verify(bizAuditLogMapper).selectListByBizTypeAndActions(eq("rdms_user_object_role"),
+                eq(List.of("remove_member")), any(LocalDateTime.class), any(LocalDateTime.class));
+    }
+
+    @Test
+    void getProductActivityTimelinePage_shouldExcludeUpdateMemberAction() {
+        Long productId = 1005L;
+        ProductActivityTimelinePageReqVO reqVO = new ProductActivityTimelinePageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+
+        BizAuditLogDO updateMemberLog = buildMemberLog(41L, 9002L, "update_member",
+                "{\"remark\":{\"before\":\"旧\",\"after\":\"新\"}}",
+                LocalDateTime.of(2026, 4, 21, 15, 0, 0));
+
+        when(productStatusLogMapper.selectListByProductIdAndActions(eq(productId), any(),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of());
+        when(bizAuditLogMapper.selectListByBizAndActions(eq("product"), eq(productId), any(),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of());
+        when(bizAuditLogMapper.selectListByBizTypeAndActions(eq("rdms_user_object_role"), any(),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of(updateMemberLog));
+        when(userObjectRoleMapper.selectListByIdsAndObject(List.of(9002L), "product", productId))
+                .thenReturn(List.of(buildMember(9002L, productId, 2002L)));
+
+        PageResult<ProductActivityTimelineRespVO> result =
+                productActivityTimelineQueryService.getProductActivityTimelinePage(productId, reqVO);
+
+        assertEquals(0L, result.getTotal());
+    }
+
+    @Test
+    void getProductActivityTimelinePage_shouldExposeTargetUserIdForMemberActivity() {
+        Long productId = 1006L;
+        ProductActivityTimelinePageReqVO reqVO = new ProductActivityTimelinePageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+        reqVO.setActivityType("member");
+
+        BizAuditLogDO addMemberLog = buildMemberLog(51L, 9003L, "add_member",
+                "{\"userId\":{\"before\":null,\"after\":2003}}",
+                LocalDateTime.of(2026, 4, 21, 16, 0, 0));
+        UserObjectRoleDO member = buildMember(9003L, productId, 2003L);
+
+        when(bizAuditLogMapper.selectListByBizTypeAndActions(eq("rdms_user_object_role"), any(),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of(addMemberLog));
+        when(userObjectRoleMapper.selectListByIdsAndObject(List.of(9003L), "product", productId))
+                .thenReturn(List.of(member));
+
+        PageResult<ProductActivityTimelineRespVO> result =
+                productActivityTimelineQueryService.getProductActivityTimelinePage(productId, reqVO);
+
+        assertEquals(1L, result.getTotal());
+        assertEquals(2003L, result.getList().get(0).getTargetUserId());
+    }
+
+    @Test
+    void getProductActivityTimelinePage_shouldReadTargetUserNameFromCacheFirst() {
+        Long productId = 1007L;
+        ProductActivityTimelinePageReqVO reqVO = new ProductActivityTimelinePageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+        reqVO.setActivityType("member");
+
+        BizAuditLogDO addMemberLog = buildMemberLog(61L, 9004L, "add_member",
+                "{\"userId\":{\"before\":null,\"after\":2004}}",
+                LocalDateTime.of(2026, 4, 21, 17, 0, 0));
+        UserObjectRoleDO member = buildMember(9004L, productId, 2004L);
+        when(bizAuditLogMapper.selectListByBizTypeAndActions(eq("rdms_user_object_role"), any(),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of(addMemberLog));
+        when(userObjectRoleMapper.selectListByIdsAndObject(List.of(9004L), "product", productId))
+                .thenReturn(List.of(member));
+        when(cacheManager.getCache("project_timeline_user_nickname#10m")).thenReturn(userNicknameCache);
+        when(userNicknameCache.get(2004L, String.class)).thenReturn("成员丁");
+
+        PageResult<ProductActivityTimelineRespVO> result =
+                productActivityTimelineQueryService.getProductActivityTimelinePage(productId, reqVO);
+
+        assertEquals("成员丁", new BeanWrapperImpl(result.getList().get(0)).getPropertyValue("targetUserName"));
+        verify(adminUserApi, never()).getUserMap(anySet());
+    }
+
+    @Test
+    void getProductActivityTimelinePage_shouldLoadAndCacheTargetUserNameWhenCacheMiss() {
+        Long productId = 1008L;
+        ProductActivityTimelinePageReqVO reqVO = new ProductActivityTimelinePageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+        reqVO.setActivityType("member");
+
+        BizAuditLogDO removeMemberLog = buildMemberLog(71L, 9005L, "remove_member",
+                "{\"userId\":{\"before\":2005,\"after\":2005}}",
+                LocalDateTime.of(2026, 4, 21, 18, 0, 0));
+        UserObjectRoleDO member = buildMember(9005L, productId, 2005L);
+        when(bizAuditLogMapper.selectListByBizTypeAndActions(eq("rdms_user_object_role"), any(),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of(removeMemberLog));
+        when(userObjectRoleMapper.selectListByIdsAndObject(List.of(9005L), "product", productId))
+                .thenReturn(List.of(member));
+        when(cacheManager.getCache("project_timeline_user_nickname#10m")).thenReturn(userNicknameCache);
+        when(userNicknameCache.get(2005L, String.class)).thenReturn(null);
+        when(adminUserApi.getUserMap(java.util.Set.of(2005L))).thenReturn(Map.of(2005L, buildUser(2005L, "成员戊")));
+
+        PageResult<ProductActivityTimelineRespVO> result =
+                productActivityTimelineQueryService.getProductActivityTimelinePage(productId, reqVO);
+
+        assertEquals("成员戊", new BeanWrapperImpl(result.getList().get(0)).getPropertyValue("targetUserName"));
+        verify(userNicknameCache).put(2005L, "成员戊");
+    }
+
+    @Test
+    void getProductActivityTimelinePage_shouldReadRoleNameFromCacheFirst() {
+        Long productId = 1009L;
+        ProductActivityTimelinePageReqVO reqVO = new ProductActivityTimelinePageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+        reqVO.setActivityType("member");
+
+        BizAuditLogDO addMemberLog = buildMemberLog(81L, 9006L, "add_member",
+                "{\"roleId\":{\"before\":null,\"after\":3101},\"userId\":{\"before\":null,\"after\":2006}}",
+                LocalDateTime.of(2026, 4, 21, 19, 0, 0));
+        when(bizAuditLogMapper.selectListByBizTypeAndActions(eq("rdms_user_object_role"), any(),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of(addMemberLog));
+        when(userObjectRoleMapper.selectListByIdsAndObject(List.of(9006L), "product", productId))
+                .thenReturn(List.of(buildMember(9006L, productId, 2006L)));
+        when(cacheManager.getCache("project_timeline_user_nickname#10m")).thenReturn(userNicknameCache);
+        when(cacheManager.getCache("project_timeline_role_name#10m")).thenReturn(roleNameCache);
+        when(roleNameCache.get(3101L, String.class)).thenReturn("产品经理");
+
+        PageResult<ProductActivityTimelineRespVO> result =
+                productActivityTimelineQueryService.getProductActivityTimelinePage(productId, reqVO);
+
+        assertEquals("产品经理", JsonUtils.parseTree(result.getList().get(0).getDetails())
+                .path("roleName").path("after").asText());
+        verify(objectPermissionApi, never()).getObjectRoleMap(anySet(), any(), any());
+    }
+
+    @Test
+    void getProductActivityTimelinePage_shouldLoadAndCacheRoleNameWhenCacheMiss() {
+        Long productId = 1010L;
+        ProductActivityTimelinePageReqVO reqVO = new ProductActivityTimelinePageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+        reqVO.setActivityType("member");
+
+        BizAuditLogDO removeMemberLog = buildMemberLog(91L, 9007L, "remove_member",
+                "{\"roleId\":{\"before\":3102,\"after\":3102},\"userId\":{\"before\":2007,\"after\":2007}}",
+                LocalDateTime.of(2026, 4, 21, 20, 0, 0));
+        when(bizAuditLogMapper.selectListByBizTypeAndActions(eq("rdms_user_object_role"), any(),
+                any(LocalDateTime.class), any(LocalDateTime.class)))
+                .thenReturn(List.of(removeMemberLog));
+        when(userObjectRoleMapper.selectListByIdsAndObject(List.of(9007L), "product", productId))
+                .thenReturn(List.of(buildMember(9007L, productId, 2007L)));
+        when(cacheManager.getCache("project_timeline_user_nickname#10m")).thenReturn(userNicknameCache);
+        when(cacheManager.getCache("project_timeline_role_name#10m")).thenReturn(roleNameCache);
+        when(roleNameCache.get(3102L, String.class)).thenReturn(null);
+        when(objectPermissionApi.getObjectRoleMap(java.util.Set.of(3102L), "object", "product"))
+                .thenReturn(Map.of(3102L, buildRole(3102L, "产品成员")));
+
+        PageResult<ProductActivityTimelineRespVO> result =
+                productActivityTimelineQueryService.getProductActivityTimelinePage(productId, reqVO);
+
+        assertEquals("产品成员", JsonUtils.parseTree(result.getList().get(0).getDetails())
+                .path("roleName").path("before").asText());
+        verify(roleNameCache).put(3102L, "产品成员");
+    }
+
+    private BizAuditLogDO buildProductLog(Long id, Long productId, String actionType,
+                                          String fieldChanges, LocalDateTime createTime) {
+        BizAuditLogDO log = new BizAuditLogDO();
+        log.setId(id);
+        log.setBizType("product");
+        log.setBizId(productId);
+        log.setActionType(actionType);
+        log.setFieldChanges(fieldChanges);
+        log.setOperatorUserId(100L);
+        log.setOperatorName("张三");
+        log.setCreateTime(createTime);
+        return log;
+    }
+
+    private BizAuditLogDO buildMemberLog(Long id, Long memberId, String actionType,
+                                         String fieldChanges, LocalDateTime createTime) {
+        BizAuditLogDO log = new BizAuditLogDO();
+        log.setId(id);
+        log.setBizType("rdms_user_object_role");
+        log.setBizId(memberId);
+        log.setActionType(actionType);
+        log.setFieldChanges(fieldChanges);
+        log.setOperatorUserId(100L);
+        log.setOperatorName("张三");
+        log.setCreateTime(createTime);
+        return log;
+    }
+
+    private ProductStatusLogDO buildStatusLog(Long id, Long productId, String actionType,
+                                              String fromStatus, String toStatus, LocalDateTime createTime) {
+        ProductStatusLogDO log = new ProductStatusLogDO();
+        log.setId(id);
+        log.setProductId(productId);
+        log.setActionType(actionType);
+        log.setFromStatus(fromStatus);
+        log.setToStatus(toStatus);
+        log.setOperatorUserId(101L);
+        log.setOperatorName("李四");
+        log.setCreateTime(createTime);
+        return log;
+    }
+
+    private UserObjectRoleDO buildMember(Long id, Long productId, Long userId) {
+        UserObjectRoleDO member = new UserObjectRoleDO();
+        member.setId(id);
+        member.setObjectType("product");
+        member.setObjectId(productId);
+        member.setUserId(userId);
+        return member;
+    }
+
+    private AdminUserRespDTO buildUser(Long id, String nickname) {
+        AdminUserRespDTO user = new AdminUserRespDTO();
+        user.setId(id);
+        user.setNickname(nickname);
+        return user;
+    }
+
+    private ObjectRoleRespDTO buildRole(Long id, String name) {
+        ObjectRoleRespDTO role = new ObjectRoleRespDTO();
+        role.setId(id);
+        role.setName(name);
+        role.setScopeType("object");
+        role.setObjectType("product");
+        return role;
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/service/product/ProductMemberServiceImplTest.java
+++ b/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/service/product/ProductMemberServiceImplTest.java
@@ -0,0 +1,166 @@
+package com.njcn.rdms.module.project.service.product;
+
+import com.njcn.rdms.framework.common.exception.ServiceException;
+import com.njcn.rdms.framework.test.core.ut.BaseMockitoUnitTest;
+import com.njcn.rdms.module.project.controller.admin.product.vo.member.ProductMemberRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.member.ProductMemberSaveReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.member.ProductMemberUpdateReqVO;
+import com.njcn.rdms.module.project.dal.dataobject.audit.BizAuditLogDO;
+import com.njcn.rdms.module.project.dal.dataobject.member.UserObjectRoleDO;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductDO;
+import com.njcn.rdms.module.project.dal.mysql.audit.BizAuditLogMapper;
+import com.njcn.rdms.module.project.dal.mysql.member.UserObjectRoleMapper;
+import com.njcn.rdms.module.project.dal.mysql.product.ProductMapper;
+import com.njcn.rdms.module.project.enums.ErrorCodeConstants;
+import com.njcn.rdms.module.system.api.permission.ObjectPermissionApi;
+import com.njcn.rdms.module.system.api.permission.dto.ObjectRoleRespDTO;
+import com.njcn.rdms.module.system.api.user.AdminUserApi;
+import com.njcn.rdms.module.system.api.user.dto.AdminUserRespDTO;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static com.njcn.rdms.framework.common.pojo.CommonResult.success;
+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.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+class ProductMemberServiceImplTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private ProductMemberServiceImpl productMemberService;
+    @Mock
+    private ProductMapper productMapper;
+    @Mock
+    private UserObjectRoleMapper userObjectRoleMapper;
+    @Mock
+    private ObjectPermissionApi objectPermissionApi;
+    @Mock
+    private BizAuditLogMapper bizAuditLogMapper;
+    @Mock
+    private AdminUserApi adminUserApi;
+
+    @Test
+    void getProductMemberList_shouldFillRoleNameAndRoleCodeFromObjectPermissionApi() {
+        Long productId = 1001L;
+        ProductDO product = createProduct(productId, 2001L);
+        UserObjectRoleDO manager = createMember(9001L, productId, 2001L, 3101L, 0);
+        UserObjectRoleDO member = createMember(9002L, productId, 2002L, 3102L, 0);
+        when(productMapper.selectById(productId)).thenReturn(product);
+        when(userObjectRoleMapper.selectListByObject("product", productId)).thenReturn(List.of(manager, member));
+        when(objectPermissionApi.getObjectRoleList(Set.of(3101L, 3102L), "object", "product"))
+                .thenReturn(success(List.of(
+                        createRole(3101L, "product_manager", "产品经理"),
+                        createRole(3102L, "product_member", "产品成员")
+                )));
+        when(adminUserApi.getUserMap(Set.of(2001L, 2002L))).thenReturn(Map.of(
+                2001L, createUser("经理甲"),
+                2002L, createUser("成员乙")
+        ));
+
+        List<ProductMemberRespVO> respVOList = productMemberService.getProductMemberList(productId);
+
+        assertEquals(2, respVOList.size());
+        assertEquals("产品经理", respVOList.get(0).getRoleName());
+        assertEquals("product_manager", respVOList.get(0).getRoleCode());
+        assertEquals(Boolean.TRUE, respVOList.get(0).getManagerFlag());
+        assertEquals("产品成员", respVOList.get(1).getRoleName());
+        assertEquals("product_member", respVOList.get(1).getRoleCode());
+        assertFalse(respVOList.get(1).getManagerFlag());
+    }
+
+    @Test
+    void createProductMember_whenRoleSummaryMissing_shouldThrowRoleInvalid() {
+        Long productId = 1002L;
+        ProductMemberSaveReqVO reqVO = new ProductMemberSaveReqVO();
+        reqVO.setUserId(2003L);
+        reqVO.setRoleId(3999L);
+        when(productMapper.selectById(productId)).thenReturn(createProduct(productId, 2001L));
+        when(objectPermissionApi.getObjectRoleById(3999L, "object", "product")).thenReturn(success(null));
+
+        ServiceException ex = assertThrows(ServiceException.class,
+                () -> productMemberService.createProductMember(productId, reqVO));
+
+        assertEquals(ErrorCodeConstants.PRODUCT_MEMBER_ROLE_INVALID.getCode(), ex.getCode());
+        verify(userObjectRoleMapper, never()).selectByObjectAndUserId(any(), any(), any());
+    }
+
+    @Test
+    void updateProductMember_whenPreviousManagerRoleCodeStillManager_shouldThrowException() {
+        Long productId = 1003L;
+        Long memberId = 9003L;
+        Long currentManagerUserId = 2001L;
+        Long targetManagerRoleId = 3201L;
+        Long previousManagerRoleId = 3202L;
+        ProductMemberUpdateReqVO reqVO = new ProductMemberUpdateReqVO();
+        reqVO.setRoleId(targetManagerRoleId);
+        reqVO.setPreviousManagerUserId(currentManagerUserId);
+        reqVO.setPreviousManagerRoleId(previousManagerRoleId);
+        reqVO.setReason("角色交接");
+
+        ProductDO product = createProduct(productId, currentManagerUserId);
+        UserObjectRoleDO member = createMember(memberId, productId, 2002L, 3203L, 0);
+        when(productMapper.selectById(productId)).thenReturn(product);
+        when(userObjectRoleMapper.selectByIdAndObject(memberId, "product", productId)).thenReturn(member);
+        when(objectPermissionApi.getObjectRoleById(targetManagerRoleId, "object", "product"))
+                .thenReturn(success(createRole(targetManagerRoleId, "product_manager", "产品经理")));
+        when(objectPermissionApi.getObjectRoleById(previousManagerRoleId, "object", "product"))
+                .thenReturn(success(createRole(previousManagerRoleId, "product_manager", "产品经理")));
+
+        ServiceException ex = assertThrows(ServiceException.class,
+                () -> productMemberService.updateProductMember(productId, memberId, reqVO));
+
+        assertEquals(ErrorCodeConstants.PRODUCT_MANAGER_TRANSFER_ROLE_INVALID.getCode(), ex.getCode());
+        verify(userObjectRoleMapper).updateById(member);
+        verify(productMapper, never()).updateById(any(ProductDO.class));
+        verify(bizAuditLogMapper, never()).insert(any(BizAuditLogDO.class));
+    }
+
+    private ProductDO createProduct(Long productId, Long managerUserId) {
+        ProductDO product = new ProductDO();
+        product.setId(productId);
+        product.setManagerUserId(managerUserId);
+        product.setStatusCode("active");
+        product.setName("测试产品");
+        product.setCode("CNPD2026001");
+        return product;
+    }
+
+    private UserObjectRoleDO createMember(Long memberId, Long productId, Long userId, Long roleId, Integer status) {
+        UserObjectRoleDO member = new UserObjectRoleDO();
+        member.setId(memberId);
+        member.setObjectType("product");
+        member.setObjectId(productId);
+        member.setUserId(userId);
+        member.setRoleId(roleId);
+        member.setStatus(status);
+        member.setJoinedTime(LocalDateTime.now());
+        return member;
+    }
+
+    private ObjectRoleRespDTO createRole(Long roleId, String roleCode, String roleName) {
+        ObjectRoleRespDTO role = new ObjectRoleRespDTO();
+        role.setId(roleId);
+        role.setCode(roleCode);
+        role.setName(roleName);
+        role.setScopeType("object");
+        role.setObjectType("product");
+        return role;
+    }
+
+    private AdminUserRespDTO createUser(String nickname) {
+        AdminUserRespDTO user = new AdminUserRespDTO();
+        user.setNickname(nickname);
+        return user;
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/service/product/ProductServiceImplTest.java
+++ b/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/service/product/ProductServiceImplTest.java
@@ -0,0 +1,484 @@
+package com.njcn.rdms.module.project.service.product;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.njcn.rdms.framework.common.exception.ServiceException;
+import com.njcn.rdms.framework.security.core.util.SecurityFrameworkUtils;
+import com.njcn.rdms.framework.common.util.json.JsonUtils;
+import com.njcn.rdms.framework.test.core.ut.BaseMockitoUnitTest;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductContextRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductDeleteReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductSaveReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.product.ProductStatusActionReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.setting.ProductSettingBaseInfoUpdateReqVO;
+import com.njcn.rdms.module.project.dal.dataobject.audit.BizAuditLogDO;
+import com.njcn.rdms.module.project.dal.dataobject.member.UserObjectRoleDO;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductDO;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductStatusLogDO;
+import com.njcn.rdms.module.project.dal.dataobject.status.ObjectStatusTransitionDO;
+import com.njcn.rdms.module.project.dal.mysql.audit.BizAuditLogMapper;
+import com.njcn.rdms.module.project.dal.mysql.member.UserObjectRoleMapper;
+import com.njcn.rdms.module.project.dal.mysql.product.ProductMapper;
+import com.njcn.rdms.module.project.dal.mysql.product.ProductStatusLogMapper;
+import com.njcn.rdms.module.project.dal.mysql.status.ObjectStatusTransitionMapper;
+import com.njcn.rdms.module.project.enums.ErrorCodeConstants;
+import com.njcn.rdms.module.system.api.permission.ObjectPermissionApi;
+import com.njcn.rdms.module.system.api.permission.dto.ObjectMenuRespDTO;
+import com.njcn.rdms.module.system.api.permission.dto.ObjectRolePermissionRespDTO;
+import com.njcn.rdms.module.system.api.permission.dto.ObjectRoleRespDTO;
+import com.njcn.rdms.module.system.api.user.AdminUserApi;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.MockedStatic;
+import org.mockito.Mock;
+
+import java.util.List;
+import java.util.Set;
+
+import static com.njcn.rdms.framework.common.pojo.CommonResult.success;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+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;
+
+class ProductServiceImplTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private ProductServiceImpl productService;
+    @Mock
+    private ProductMapper productMapper;
+    @Mock
+    private ProductStatusLogMapper productStatusLogMapper;
+    @Mock
+    private BizAuditLogMapper bizAuditLogMapper;
+    @Mock
+    private ObjectStatusTransitionMapper objectStatusTransitionMapper;
+    @Mock
+    private UserObjectRoleMapper userObjectRoleMapper;
+    @Mock
+    private ObjectPermissionApi objectPermissionApi;
+    @Mock
+    private AdminUserApi adminUserApi;
+
+    @Test
+    void updateProductBaseInfo_shouldOnlyUpdateBaseInfoAndRecordFieldChanges() {
+        Long productId = 1002L;
+        ProductDO product = createProduct(productId, "direction_value", "旧产品", 2003L, "旧描述", "active");
+        ProductSettingBaseInfoUpdateReqVO reqVO = new ProductSettingBaseInfoUpdateReqVO();
+        reqVO.setDirectionCode("direction_value_updated");
+        reqVO.setName("新产品");
+        reqVO.setDescription("  新描述  ");
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+        when(productMapper.selectByName("新产品")).thenReturn(null);
+
+        productService.updateProductBaseInfo(productId, reqVO);
+
+        ProductDO updated = captureUpdatedProduct();
+        assertProductBaseInfoUpdated(updated, "CNPD2026002", 2003L, "active",
+                "direction_value_updated", "新产品", "新描述");
+
+        BizAuditLogDO auditLog = captureAuditLog();
+        assertAuditFieldChanges(auditLog, productId, "direction_value", "direction_value_updated",
+                "旧产品", "新产品", "旧描述", "新描述");
+    }
+
+    @Test
+    void updateProduct_shouldReuseBaseInfoUpdateFlow() {
+        Long productId = 1003L;
+        ProductDO product = createProduct(productId, "direction_value", "旧产品", 2004L, "旧描述", "active");
+        ProductSaveReqVO reqVO = new ProductSaveReqVO();
+        reqVO.setId(productId);
+        reqVO.setCode("CNPD2026003");
+        reqVO.setDirectionCode("direction_value_updated");
+        reqVO.setName("新产品");
+        reqVO.setManagerUserId(2004L);
+        reqVO.setDescription("  新描述  ");
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+        when(productMapper.selectByName("新产品")).thenReturn(null);
+
+        productService.updateProduct(reqVO);
+
+        ProductDO updated = captureUpdatedProduct();
+        assertProductBaseInfoUpdated(updated, "CNPD2026003", 2004L, "active",
+                "direction_value_updated", "新产品", "新描述");
+
+        BizAuditLogDO auditLog = captureAuditLog();
+        assertAuditFieldChanges(auditLog, productId, "direction_value", "direction_value_updated",
+                "旧产品", "新产品", "旧描述", "新描述");
+    }
+
+    @Test
+    void updateProduct_whenManagerUserIdChanged_shouldThrowException() {
+        Long productId = 1002L;
+        ProductDO product = createProduct(productId, "direction_value", "旧产品", 2005L, "旧描述", "active");
+        ProductSaveReqVO reqVO = new ProductSaveReqVO();
+        reqVO.setId(productId);
+        reqVO.setCode("CNPD2026002");
+        reqVO.setDirectionCode("direction_value_updated");
+        reqVO.setName("新产品");
+        reqVO.setManagerUserId(2006L);
+        reqVO.setDescription("新描述");
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+
+        ServiceException ex = assertThrows(ServiceException.class,
+                () -> productService.updateProduct(reqVO));
+        assertEquals(ErrorCodeConstants.PRODUCT_MANAGER_NOT_MODIFIABLE.getCode(), ex.getCode());
+        verify(productMapper, never()).updateById(any(ProductDO.class));
+        verify(bizAuditLogMapper, never()).insert(any(BizAuditLogDO.class));
+    }
+
+    @Test
+    void updateProductBaseInfo_whenPausedAndDirectionOrNameChanged_shouldThrowException() {
+        Long productId = 1004L;
+        ProductDO product = createProduct(productId, "direction_value", "暂停产品", 2007L, "旧描述", "paused");
+        ProductSettingBaseInfoUpdateReqVO reqVO = new ProductSettingBaseInfoUpdateReqVO();
+        reqVO.setDirectionCode("direction_value_updated");
+        reqVO.setName("暂停产品");
+        reqVO.setDescription("新描述");
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+
+        ServiceException ex = assertThrows(ServiceException.class,
+                () -> productService.updateProductBaseInfo(productId, reqVO));
+        assertEquals(ErrorCodeConstants.PRODUCT_PAUSED_ONLY_ALLOW_LIMITED_UPDATE.getCode(), ex.getCode());
+        verify(productMapper, never()).updateById(any(ProductDO.class));
+    }
+
+    @Test
+    void changeProductStatus_shouldUpdateStatusByConditionAndWriteLogs() {
+        Long productId = 1006L;
+        Long loginUserId = 3002L;
+        ProductDO product = createProduct(productId, "direction_value", "产品B", 2009L, "旧描述", "active");
+        ProductStatusActionReqVO reqVO = new ProductStatusActionReqVO();
+        reqVO.setId(productId);
+        reqVO.setActionCode("pause");
+        reqVO.setReason("环境受限");
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+        when(objectStatusTransitionMapper.selectByObjectTypeAndFromStatusAndAction("product", "active", "pause"))
+                .thenReturn(createTransition("pause", "paused", true));
+        when(productMapper.updateStatusByIdAndStatus(productId, "active", "paused", "环境受限")).thenReturn(1);
+
+        try (MockedStatic<SecurityFrameworkUtils> mockedStatic = mockLoginUser(loginUserId, "测试人")) {
+            productService.changeProductStatus(reqVO);
+        }
+
+        verify(productMapper, times(1)).updateStatusByIdAndStatus(productId, "active", "paused", "环境受限");
+
+        ArgumentCaptor<ProductStatusLogDO> statusLogCaptor = ArgumentCaptor.forClass(ProductStatusLogDO.class);
+        verify(productStatusLogMapper, times(1)).insert(statusLogCaptor.capture());
+        assertEquals("pause", statusLogCaptor.getValue().getActionType());
+        assertEquals("active", statusLogCaptor.getValue().getFromStatus());
+        assertEquals("paused", statusLogCaptor.getValue().getToStatus());
+        assertEquals("环境受限", statusLogCaptor.getValue().getReason());
+
+        BizAuditLogDO auditLog = captureAuditLog();
+        assertEquals("pause", auditLog.getActionType());
+        assertEquals("active", auditLog.getFromStatus());
+        assertEquals("paused", auditLog.getToStatus());
+        assertEquals("环境受限", auditLog.getReason());
+    }
+
+    @Test
+    void changeProductStatus_whenConditionalUpdateReturnsZero_shouldThrowException() {
+        Long productId = 1007L;
+        Long loginUserId = 3003L;
+        ProductDO product = createProduct(productId, "direction_value", "产品C", 2010L, "旧描述", "active");
+        ProductStatusActionReqVO reqVO = new ProductStatusActionReqVO();
+        reqVO.setId(productId);
+        reqVO.setActionCode("pause");
+        reqVO.setReason("环境受限");
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+        when(objectStatusTransitionMapper.selectByObjectTypeAndFromStatusAndAction("product", "active", "pause"))
+                .thenReturn(createTransition("pause", "paused", true));
+        when(productMapper.updateStatusByIdAndStatus(productId, "active", "paused", "环境受限")).thenReturn(0);
+
+        try (MockedStatic<SecurityFrameworkUtils> mockedStatic = mockLoginUser(loginUserId, "测试人")) {
+            ServiceException ex = assertThrows(ServiceException.class,
+                    () -> productService.changeProductStatus(reqVO));
+            assertEquals(ErrorCodeConstants.PRODUCT_STATUS_CONCURRENT_MODIFIED.getCode(), ex.getCode());
+            verify(productStatusLogMapper, never()).insert(any(ProductStatusLogDO.class));
+            verify(bizAuditLogMapper, never()).insert(any(BizAuditLogDO.class));
+        }
+    }
+
+    @Test
+    void changeProductStatus_whenActionNotAllowed_shouldThrowException() {
+        Long productId = 1010L;
+        ProductDO product = createProduct(productId, "direction_value", "产品F", 2013L, "旧描述", "archived");
+        ProductStatusActionReqVO reqVO = new ProductStatusActionReqVO();
+        reqVO.setId(productId);
+        reqVO.setActionCode("pause");
+        reqVO.setReason("再次暂停");
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+        when(objectStatusTransitionMapper.selectByObjectTypeAndFromStatusAndAction("product", "archived", "pause"))
+                .thenReturn(null);
+
+        ServiceException ex = assertThrows(ServiceException.class,
+                () -> productService.changeProductStatus(reqVO));
+        assertEquals(ErrorCodeConstants.PRODUCT_STATUS_ACTION_NOT_ALLOWED.getCode(), ex.getCode());
+    }
+
+    @Test
+    void changeProductStatus_whenReasonRequiredButMissing_shouldThrowException() {
+        Long productId = 1011L;
+        ProductDO product = createProduct(productId, "direction_value", "产品G", 2014L, "旧描述", "active");
+        ProductStatusActionReqVO reqVO = new ProductStatusActionReqVO();
+        reqVO.setId(productId);
+        reqVO.setActionCode("pause");
+        reqVO.setReason("   ");
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+        when(objectStatusTransitionMapper.selectByObjectTypeAndFromStatusAndAction("product", "active", "pause"))
+                .thenReturn(createTransition("pause", "paused", true));
+
+        ServiceException ex = assertThrows(ServiceException.class,
+                () -> productService.changeProductStatus(reqVO));
+        assertEquals(ErrorCodeConstants.PRODUCT_STATUS_ACTION_REASON_REQUIRED.getCode(), ex.getCode());
+    }
+
+    @Test
+    void deleteProduct_whenConfirmTextInvalid_shouldThrowException() {
+        Long productId = 1008L;
+        Long loginUserId = 3004L;
+        ProductDO product = createProduct(productId, "direction_value", "产品D", 2011L, "旧描述", "active");
+        ProductDeleteReqVO reqVO = new ProductDeleteReqVO();
+        reqVO.setId(productId);
+        reqVO.setProductName("产品D");
+        reqVO.setReason("录入错误");
+        reqVO.setConfirmText("WRONG");
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+
+        try (MockedStatic<SecurityFrameworkUtils> mockedStatic = mockLoginUser(loginUserId, "测试人")) {
+            ServiceException ex = assertThrows(ServiceException.class,
+                    () -> productService.deleteProduct(reqVO));
+            assertEquals(ErrorCodeConstants.PRODUCT_DELETE_CONFIRM_TEXT_INVALID.getCode(), ex.getCode());
+            verify(productMapper, never()).deleteByIdAndStatus(any(Long.class), any(String.class));
+            verify(productStatusLogMapper, never()).insert(any(ProductStatusLogDO.class));
+            verify(bizAuditLogMapper, never()).insert(any(BizAuditLogDO.class));
+        }
+    }
+
+    @Test
+    void deleteProduct_whenProductNameMismatch_shouldThrowException() {
+        Long productId = 1012L;
+        ProductDO product = createProduct(productId, "direction_value", "产品H", 2015L, "旧描述", "active");
+        ProductDeleteReqVO reqVO = new ProductDeleteReqVO();
+        reqVO.setId(productId);
+        reqVO.setProductName("错误名称");
+        reqVO.setReason("录入错误");
+        reqVO.setConfirmText("DELETE");
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+
+        ServiceException ex = assertThrows(ServiceException.class,
+                () -> productService.deleteProduct(reqVO));
+        assertEquals(ErrorCodeConstants.PRODUCT_DELETE_NAME_MISMATCH.getCode(), ex.getCode());
+    }
+
+    @Test
+    void deleteProduct_shouldDeleteByConditionAndWriteLogs() {
+        Long productId = 1009L;
+        Long loginUserId = 3005L;
+        ProductDO product = createProduct(productId, "direction_value", "产品E", 2012L, "旧描述", "active");
+        ProductDeleteReqVO reqVO = new ProductDeleteReqVO();
+        reqVO.setId(productId);
+        reqVO.setProductName("产品E");
+        reqVO.setReason("录入错误");
+        reqVO.setConfirmText("DELETE");
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+        when(productMapper.deleteByIdAndStatus(productId, "active")).thenReturn(1);
+
+        try (MockedStatic<SecurityFrameworkUtils> mockedStatic = mockLoginUser(loginUserId, "测试人")) {
+            productService.deleteProduct(reqVO);
+        }
+
+        verify(productMapper, times(1)).deleteByIdAndStatus(productId, "active");
+
+        ArgumentCaptor<ProductStatusLogDO> statusLogCaptor = ArgumentCaptor.forClass(ProductStatusLogDO.class);
+        verify(productStatusLogMapper, times(1)).insert(statusLogCaptor.capture());
+        assertEquals("delete", statusLogCaptor.getValue().getActionType());
+        assertEquals("active", statusLogCaptor.getValue().getFromStatus());
+        assertNull(statusLogCaptor.getValue().getToStatus());
+        assertEquals("录入错误", statusLogCaptor.getValue().getReason());
+
+        BizAuditLogDO auditLog = captureAuditLog();
+        assertEquals("delete", auditLog.getActionType());
+        assertEquals("active", auditLog.getFromStatus());
+        assertNull(auditLog.getToStatus());
+        assertEquals("录入错误", auditLog.getReason());
+    }
+
+    @Test
+    void updateProductBaseInfo_whenArchived_shouldThrowException() {
+        Long productId = 1013L;
+        ProductDO product = createProduct(productId, "direction_value", "归档产品", 2016L, "旧描述", "archived");
+        ProductSettingBaseInfoUpdateReqVO reqVO = new ProductSettingBaseInfoUpdateReqVO();
+        reqVO.setDirectionCode("direction_value");
+        reqVO.setName("归档产品");
+        reqVO.setDescription("新描述");
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+
+        ServiceException ex = assertThrows(ServiceException.class,
+                () -> productService.updateProductBaseInfo(productId, reqVO));
+        assertEquals(ErrorCodeConstants.PRODUCT_STATUS_NOT_ALLOW_EDIT.getCode(), ex.getCode());
+    }
+
+    @Test
+    void getProductContext_shouldAssembleCurrentRoleNavsAndButtonsFromObjectPermissionApi() {
+        Long productId = 1014L;
+        Long loginUserId = 3014L;
+        Long roleId = 9101L;
+        ProductDO product = createProduct(productId, "direction_value", "产品上下文", 2017L, "旧描述", "active");
+        UserObjectRoleDO currentMember = createMember(productId, loginUserId, roleId);
+        ObjectRolePermissionRespDTO detail = new ObjectRolePermissionRespDTO();
+        detail.setCurrentRole(createRole(roleId, "product_manager", "产品经理"));
+        detail.setMenus(List.of(
+                createMenu(9303L, "保存", "project:product:update", 3, 30, null, null, true),
+                createMenu(9302L, "隐藏导航", null, 2, 20, "/product/hidden", "mdi:hidden", false),
+                createMenu(9301L, "概览", null, 2, 10, "/product/overview", "mdi:view-dashboard-outline", true)
+        ));
+        detail.setPermissions(Set.of("project:product:update"));
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+        when(userObjectRoleMapper.selectActiveByObjectAndUserId("product", productId, loginUserId))
+                .thenReturn(currentMember);
+        when(objectPermissionApi.getObjectRolePermissionDetail(roleId, "object", "product"))
+                .thenReturn(success(detail));
+
+        ProductContextRespVO respVO;
+        try (MockedStatic<SecurityFrameworkUtils> mockedStatic = mockLoginUser(loginUserId, "测试人")) {
+            respVO = productService.getProductContext(productId);
+        }
+
+        assertNotNull(respVO.getCurrentProduct());
+        assertEquals(roleId, respVO.getCurrentRole().getRoleId());
+        assertEquals("product_manager", respVO.getCurrentRole().getRoleCode());
+        assertEquals("产品经理", respVO.getCurrentRole().getRoleName());
+        assertEquals(1, respVO.getNavs().size());
+        assertEquals(9301L, respVO.getNavs().get(0).getId());
+        assertEquals(List.of("project:product:update"), respVO.getButtons());
+    }
+
+    private ProductDO createProduct(Long id, String directionCode, String name, Long managerUserId,
+                                    String description, String statusCode) {
+        ProductDO product = new ProductDO();
+        product.setId(id);
+        product.setCode("CNPD202600" + (id % 10));
+        product.setDirectionCode(directionCode);
+        product.setStatusCode(statusCode);
+        product.setName(name);
+        product.setManagerUserId(managerUserId);
+        product.setDescription(description);
+        return product;
+    }
+
+    private UserObjectRoleDO createMember(Long productId, Long userId, Long roleId) {
+        UserObjectRoleDO currentMember = new UserObjectRoleDO();
+        currentMember.setId(9001L);
+        currentMember.setUserId(userId);
+        currentMember.setObjectType("product");
+        currentMember.setObjectId(productId);
+        currentMember.setRoleId(roleId);
+        currentMember.setStatus(0);
+        return currentMember;
+    }
+
+    private ObjectRoleRespDTO createRole(Long roleId, String roleCode, String roleName) {
+        ObjectRoleRespDTO role = new ObjectRoleRespDTO();
+        role.setId(roleId);
+        role.setCode(roleCode);
+        role.setName(roleName);
+        role.setScopeType("object");
+        role.setObjectType("product");
+        return role;
+    }
+
+    private ObjectMenuRespDTO createMenu(Long menuId, String name, String permission, Integer type, Integer sort,
+                                         String path, String icon, Boolean visible) {
+        ObjectMenuRespDTO menu = new ObjectMenuRespDTO();
+        menu.setId(menuId);
+        menu.setName(name);
+        menu.setPermission(permission);
+        menu.setType(type);
+        menu.setSort(sort);
+        menu.setPath(path);
+        menu.setIcon(icon);
+        menu.setVisible(visible);
+        return menu;
+    }
+
+    private ObjectStatusTransitionDO createTransition(String actionCode, String toStatus, boolean needReason) {
+        ObjectStatusTransitionDO transition = new ObjectStatusTransitionDO();
+        transition.setActionCode(actionCode);
+        transition.setToStatusCode(toStatus);
+        transition.setNeedReason(needReason);
+        return transition;
+    }
+
+    private MockedStatic<SecurityFrameworkUtils> mockLoginUser(Long loginUserId, String nickname) {
+        MockedStatic<SecurityFrameworkUtils> mockedStatic = mockStatic(SecurityFrameworkUtils.class);
+        mockedStatic.when(SecurityFrameworkUtils::getLoginUserId).thenReturn(loginUserId);
+        mockedStatic.when(SecurityFrameworkUtils::getLoginUserNickname).thenReturn(nickname);
+        return mockedStatic;
+    }
+
+    private ProductDO captureUpdatedProduct() {
+        ArgumentCaptor<ProductDO> productCaptor = ArgumentCaptor.forClass(ProductDO.class);
+        verify(productMapper, times(1)).updateById(productCaptor.capture());
+        return productCaptor.getValue();
+    }
+
+    private BizAuditLogDO captureAuditLog() {
+        ArgumentCaptor<BizAuditLogDO> auditCaptor = ArgumentCaptor.forClass(BizAuditLogDO.class);
+        verify(bizAuditLogMapper, times(1)).insert(auditCaptor.capture());
+        return auditCaptor.getValue();
+    }
+
+    private void assertProductBaseInfoUpdated(ProductDO updated, String code, Long managerUserId,
+                                              String statusCode, String directionCode,
+                                              String name, String description) {
+        assertEquals(code, updated.getCode());
+        assertEquals(managerUserId, updated.getManagerUserId());
+        assertEquals(statusCode, updated.getStatusCode());
+        assertEquals(directionCode, updated.getDirectionCode());
+        assertEquals(name, updated.getName());
+        assertEquals(description, updated.getDescription());
+        assertNull(updated.getLastStatusReason());
+    }
+
+    private void assertAuditFieldChanges(BizAuditLogDO auditLog, Long productId, String beforeDirectionCode,
+                                         String afterDirectionCode, String beforeName, String afterName,
+                                         String beforeDescription, String afterDescription) {
+        assertEquals("product", auditLog.getBizType());
+        assertEquals(productId, auditLog.getBizId());
+        assertEquals("update", auditLog.getActionType());
+        assertEquals("active", auditLog.getFromStatus());
+        assertEquals("active", auditLog.getToStatus());
+
+        JsonNode fieldChanges = JsonUtils.parseTree(auditLog.getFieldChanges());
+        assertEquals(beforeDirectionCode, fieldChanges.path("directionCode").path("before").asText());
+        assertEquals(afterDirectionCode, fieldChanges.path("directionCode").path("after").asText());
+        assertEquals(beforeName, fieldChanges.path("name").path("before").asText());
+        assertEquals(afterName, fieldChanges.path("name").path("after").asText());
+        assertEquals(beforeDescription, fieldChanges.path("description").path("before").asText());
+        assertEquals(afterDescription, fieldChanges.path("description").path("after").asText());
+        assertFalse(fieldChanges.has("managerUserId"));
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/service/product/ProductSettingServiceImplTest.java
+++ b/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/service/product/ProductSettingServiceImplTest.java
@@ -0,0 +1,215 @@
+package com.njcn.rdms.module.project.service.product;
+
+import com.njcn.rdms.framework.common.exception.ServiceException;
+import com.njcn.rdms.framework.common.pojo.CommonResult;
+import com.njcn.rdms.framework.common.pojo.PageResult;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityPageReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityTimelinePageReqVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.activity.ProductActivityTimelineRespVO;
+import com.njcn.rdms.framework.test.core.ut.BaseMockitoUnitTest;
+import com.njcn.rdms.module.project.controller.admin.product.vo.setting.ProductSettingLifecycleRespVO;
+import com.njcn.rdms.module.project.controller.admin.product.vo.setting.ProductSettingRespVO;
+import com.njcn.rdms.module.project.dal.dataobject.product.ProductDO;
+import com.njcn.rdms.module.project.dal.mysql.product.ProductMapper;
+import com.njcn.rdms.module.project.enums.ErrorCodeConstants;
+import com.njcn.rdms.module.system.api.user.AdminUserApi;
+import com.njcn.rdms.module.system.api.user.dto.AdminUserRespDTO;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+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.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+
+class ProductSettingServiceImplTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private ProductSettingServiceImpl productSettingService;
+    @Mock
+    private AdminUserApi adminUserApi;
+    @Mock
+    private ProductMapper productMapper;
+    @Mock
+    private ProductStatusViewService productStatusViewService;
+    @Mock
+    private ProductActivityQueryService productActivityQueryService;
+    @Mock
+    private ProductActivityTimelineQueryService productActivityTimelineQueryService;
+
+    @Test
+    void getProductSettings_shouldAssembleBaseInfoAndLifecycleActions() {
+        Long productId = 1001L;
+        Long managerUserId = 2002L;
+        ProductDO product = new ProductDO();
+        product.setId(productId);
+        product.setCode("CNPD2026001");
+        product.setDirectionCode("direction_value");
+        product.setName("统一交付平台");
+        product.setManagerUserId(managerUserId);
+        product.setDescription("产品描述");
+        product.setStatusCode("active");
+        product.setLastStatusReason("恢复正常推进");
+
+        AdminUserRespDTO manager = new AdminUserRespDTO();
+        manager.setId(managerUserId);
+        manager.setNickname("张三");
+
+        ProductSettingLifecycleRespVO lifecycle = new ProductSettingLifecycleRespVO();
+        lifecycle.setStatusCode("active");
+        lifecycle.setStatusName("启用");
+        lifecycle.setTerminal(false);
+        lifecycle.setAllowEdit(true);
+        lifecycle.setLastStatusReason("恢复正常推进");
+        lifecycle.setAvailableActions(Collections.emptyList());
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+        when(adminUserApi.getUser(managerUserId)).thenReturn(CommonResult.success(manager));
+        when(productStatusViewService.getLifecycle("active", "恢复正常推进")).thenReturn(lifecycle);
+
+        ProductSettingRespVO result = productSettingService.getProductSettings(productId);
+
+        assertEquals("统一交付平台", result.getBaseInfo().getName());
+        assertEquals("张三", result.getBaseInfo().getManagerUserNickname());
+        assertEquals("启用", result.getLifecycle().getStatusName());
+        assertEquals(false, result.getLifecycle().getTerminal());
+        assertEquals(true, result.getLifecycle().getAllowEdit());
+    }
+
+    @Test
+    void getProductSettings_shouldReturnNullManagerNicknameWhenManagerUserIdIsNull() {
+        Long productId = 1002L;
+        ProductDO product = new ProductDO();
+        product.setId(productId);
+        product.setCode("CNPD2026002");
+        product.setDirectionCode("direction_value");
+        product.setName("产品A");
+        product.setManagerUserId(null);
+        product.setStatusCode("active");
+        ProductSettingLifecycleRespVO lifecycle = new ProductSettingLifecycleRespVO();
+        lifecycle.setStatusCode("active");
+        lifecycle.setAvailableActions(Collections.emptyList());
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+        when(productStatusViewService.getLifecycle("active", null)).thenReturn(lifecycle);
+
+        ProductSettingRespVO result = productSettingService.getProductSettings(productId);
+
+        assertNull(result.getBaseInfo().getManagerUserNickname());
+        verifyNoInteractions(adminUserApi);
+    }
+
+    @Test
+    void getProductSettings_shouldReturnEmptyActionsWhenNoStatusTransitions() {
+        Long productId = 1003L;
+        Long managerUserId = 2003L;
+        ProductDO product = new ProductDO();
+        product.setId(productId);
+        product.setCode("CNPD2026003");
+        product.setDirectionCode("direction_value");
+        product.setName("产品B");
+        product.setManagerUserId(managerUserId);
+        product.setStatusCode("paused");
+
+        AdminUserRespDTO manager = new AdminUserRespDTO();
+        manager.setId(managerUserId);
+        manager.setNickname("李四");
+        ProductSettingLifecycleRespVO lifecycle = new ProductSettingLifecycleRespVO();
+        lifecycle.setStatusCode("paused");
+        lifecycle.setAvailableActions(Collections.emptyList());
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+        when(adminUserApi.getUser(managerUserId)).thenReturn(CommonResult.success(manager));
+        when(productStatusViewService.getLifecycle("paused", null)).thenReturn(lifecycle);
+
+        ProductSettingRespVO result = productSettingService.getProductSettings(productId);
+
+        assertNotNull(result.getLifecycle().getAvailableActions());
+        assertTrue(result.getLifecycle().getAvailableActions().isEmpty());
+    }
+
+    @Test
+    void getProductActivities_shouldValidateProductAndDelegate() {
+        Long productId = 1004L;
+        ProductDO product = new ProductDO();
+        product.setId(productId);
+
+        ProductActivityPageReqVO reqVO = new ProductActivityPageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+
+        ProductActivityRespVO respVO = new ProductActivityRespVO();
+        respVO.setType("status");
+        PageResult<ProductActivityRespVO> pageResult = new PageResult<>(List.of(respVO), 1L);
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+        when(productActivityQueryService.getProductActivities(productId, reqVO)).thenReturn(pageResult);
+
+        PageResult<ProductActivityRespVO> result = productSettingService.getProductActivities(productId, reqVO);
+
+        assertEquals(1L, result.getTotal());
+        assertEquals("status", result.getList().get(0).getType());
+    }
+
+    @Test
+    void getProductActivities_whenProductMissing_shouldThrowException() {
+        Long productId = 1005L;
+        ProductActivityPageReqVO reqVO = new ProductActivityPageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+
+        when(productMapper.selectById(productId)).thenReturn(null);
+
+        ServiceException ex = assertThrows(ServiceException.class,
+                () -> productSettingService.getProductActivities(productId, reqVO));
+        assertEquals(ErrorCodeConstants.PRODUCT_NOT_EXISTS.getCode(), ex.getCode());
+    }
+
+    @Test
+    void getProductActivityTimelinePage_shouldValidateProductAndDelegate() {
+        Long productId = 1006L;
+        ProductDO product = new ProductDO();
+        product.setId(productId);
+
+        ProductActivityTimelinePageReqVO reqVO = new ProductActivityTimelinePageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+
+        ProductActivityTimelineRespVO respVO = new ProductActivityTimelineRespVO();
+        respVO.setId("status:11");
+        PageResult<ProductActivityTimelineRespVO> pageResult = new PageResult<>(List.of(respVO), 1L);
+
+        when(productMapper.selectById(productId)).thenReturn(product);
+        when(productActivityTimelineQueryService.getProductActivityTimelinePage(productId, reqVO))
+                .thenReturn(pageResult);
+
+        PageResult<ProductActivityTimelineRespVO> result =
+                productSettingService.getProductActivityTimelinePage(productId, reqVO);
+
+        assertEquals(1L, result.getTotal());
+        assertEquals("status:11", result.getList().get(0).getId());
+    }
+
+    @Test
+    void getProductActivityTimelinePage_whenProductMissing_shouldThrowException() {
+        Long productId = 1007L;
+        ProductActivityTimelinePageReqVO reqVO = new ProductActivityTimelinePageReqVO();
+        reqVO.setPageNo(1);
+        reqVO.setPageSize(10);
+
+        when(productMapper.selectById(productId)).thenReturn(null);
+
+        ServiceException ex = assertThrows(ServiceException.class,
+                () -> productSettingService.getProductActivityTimelinePage(productId, reqVO));
+        assertEquals(ErrorCodeConstants.PRODUCT_NOT_EXISTS.getCode(), ex.getCode());
+    }
+
+}
--- a/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/service/product/ProductStatusViewServiceTest.java
+++ b/rdms-project/rdms-project-boot/src/test/java/com/njcn/rdms/module/project/service/product/ProductStatusViewServiceTest.java
@@ -0,0 +1,74 @@
+package com.njcn.rdms.module.project.service.product;
+
+import com.njcn.rdms.framework.common.exception.ServiceException;
+import com.njcn.rdms.framework.test.core.ut.BaseMockitoUnitTest;
+import com.njcn.rdms.module.project.controller.admin.product.vo.setting.ProductSettingLifecycleRespVO;
+import com.njcn.rdms.module.project.dal.dataobject.status.ObjectStatusModelDO;
+import com.njcn.rdms.module.project.dal.dataobject.status.ObjectStatusTransitionDO;
+import com.njcn.rdms.module.project.dal.mysql.status.ObjectStatusModelMapper;
+import com.njcn.rdms.module.project.dal.mysql.status.ObjectStatusTransitionMapper;
+import com.njcn.rdms.module.project.enums.ErrorCodeConstants;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+
+import java.util.List;
+
+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.Mockito.when;
+
+class ProductStatusViewServiceTest extends BaseMockitoUnitTest {
+
+    @InjectMocks
+    private ProductStatusViewService productStatusViewService;
+    @Mock
+    private ObjectStatusModelMapper objectStatusModelMapper;
+    @Mock
+    private ObjectStatusTransitionMapper objectStatusTransitionMapper;
+
+    @Test
+    void getLifecycle_shouldReturnStatusMetadataAndActions() {
+        ObjectStatusModelDO statusModel = new ObjectStatusModelDO();
+        statusModel.setObjectType("product");
+        statusModel.setStatusCode("active");
+        statusModel.setStatusName("启用");
+        statusModel.setTerminalFlag(false);
+        statusModel.setAllowEdit(true);
+        statusModel.setStatus(0);
+
+        ObjectStatusTransitionDO transition = new ObjectStatusTransitionDO();
+        transition.setActionCode("pause");
+        transition.setActionName("暂停");
+        transition.setNeedReason(true);
+
+        when(objectStatusModelMapper.selectByObjectTypeAndStatusCodeEnabled("product", "active"))
+                .thenReturn(statusModel);
+        when(objectStatusTransitionMapper.selectListByObjectTypeAndFromStatus("product", "active"))
+                .thenReturn(List.of(transition));
+
+        ProductSettingLifecycleRespVO result =
+                productStatusViewService.getLifecycle("active", "恢复正常推进");
+
+        assertEquals("active", result.getStatusCode());
+        assertEquals("启用", result.getStatusName());
+        assertFalse(result.getTerminal());
+        assertTrue(result.getAllowEdit());
+        assertEquals("恢复正常推进", result.getLastStatusReason());
+        assertEquals(1, result.getAvailableActions().size());
+        assertEquals("pause", result.getAvailableActions().get(0).getActionCode());
+    }
+
+    @Test
+    void getLifecycle_whenStatusModelMissing_shouldThrowException() {
+        when(objectStatusModelMapper.selectByObjectTypeAndStatusCodeEnabled("product", "active"))
+                .thenReturn(null);
+
+        ServiceException ex = assertThrows(ServiceException.class,
+                () -> productStatusViewService.getLifecycle("active", null));
+        assertEquals(ErrorCodeConstants.PRODUCT_STATUS_MODEL_NOT_EXISTS_OR_DISABLED.getCode(), ex.getCode());
+    }
+
+}
--- a/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/api/permission/ObjectPermissionApi.java
+++ b/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/api/permission/ObjectPermissionApi.java
@@ -0,0 +1,89 @@
+package com.njcn.rdms.module.system.api.permission;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.map.MapUtil;
+import com.njcn.rdms.framework.common.pojo.CommonResult;
+import com.njcn.rdms.framework.common.util.collection.CollectionUtils;
+import com.njcn.rdms.module.system.api.permission.dto.ObjectRolePermissionRespDTO;
+import com.njcn.rdms.module.system.api.permission.dto.ObjectRoleRespDTO;
+import com.njcn.rdms.module.system.enums.ApiConstants;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@FeignClient(name = ApiConstants.NAME)
+@Tag(name = "RPC 服务 - 对象权限")
+public interface ObjectPermissionApi {
+
+    String PREFIX = ApiConstants.PREFIX + "/permission/object";
+
+    @GetMapping(PREFIX + "/role-by-id")
+    @Operation(summary = "按角色 ID 查询对象作用域角色摘要")
+    @Parameter(name = "roleId", description = "角色 ID", example = "1024", required = true)
+    @Parameter(name = "scopeType", description = "权限作用域类型", example = "object", required = true)
+    @Parameter(name = "objectType", description = "对象类型", example = "product", required = true)
+    CommonResult<ObjectRoleRespDTO> getObjectRoleById(@RequestParam("roleId") Long roleId,
+                                                      @RequestParam("scopeType") String scopeType,
+                                                      @RequestParam("objectType") String objectType);
+
+    @GetMapping(PREFIX + "/role-by-code")
+    @Operation(summary = "按角色编码查询对象作用域角色摘要")
+    @Parameter(name = "roleCode", description = "角色编码", example = "product_manager", required = true)
+    @Parameter(name = "scopeType", description = "权限作用域类型", example = "object", required = true)
+    @Parameter(name = "objectType", description = "对象类型", example = "product", required = true)
+    CommonResult<ObjectRoleRespDTO> getObjectRoleByCode(@RequestParam("roleCode") String roleCode,
+                                                        @RequestParam("scopeType") String scopeType,
+                                                        @RequestParam("objectType") String objectType);
+
+    @GetMapping(PREFIX + "/role-list")
+    @Operation(summary = "按角色 ID 批量查询对象作用域角色摘要")
+    @Parameter(name = "roleIds", description = "角色 ID 集合", example = "1,2", required = true)
+    @Parameter(name = "scopeType", description = "权限作用域类型", example = "object", required = true)
+    @Parameter(name = "objectType", description = "对象类型", example = "product", required = true)
+    CommonResult<List<ObjectRoleRespDTO>> getObjectRoleList(@RequestParam("roleIds") Collection<Long> roleIds,
+                                                            @RequestParam("scopeType") String scopeType,
+                                                            @RequestParam("objectType") String objectType);
+
+    @GetMapping(PREFIX + "/permissions")
+    @Operation(summary = "查询对象作用域角色权限集合")
+    @Parameter(name = "roleId", description = "角色 ID", example = "1024", required = true)
+    @Parameter(name = "scopeType", description = "权限作用域类型", example = "object", required = true)
+    @Parameter(name = "objectType", description = "对象类型", example = "product", required = true)
+    CommonResult<Set<String>> getObjectRolePermissions(@RequestParam("roleId") Long roleId,
+                                                       @RequestParam("scopeType") String scopeType,
+                                                       @RequestParam("objectType") String objectType);
+
+    @GetMapping(PREFIX + "/role-permission-detail")
+    @Operation(summary = "查询对象作用域角色菜单与权限聚合结果")
+    @Parameter(name = "roleId", description = "角色 ID", example = "1024", required = true)
+    @Parameter(name = "scopeType", description = "权限作用域类型", example = "object", required = true)
+    @Parameter(name = "objectType", description = "对象类型", example = "product", required = true)
+    CommonResult<ObjectRolePermissionRespDTO> getObjectRolePermissionDetail(@RequestParam("roleId") Long roleId,
+                                                                            @RequestParam("scopeType") String scopeType,
+                                                                            @RequestParam("objectType") String objectType);
+
+    /**
+     * 按角色 ID 返回对象作用域角色摘要映射，便于业务模块批量对齐本地成员数据。
+     *
+     * @param roleIds 角色 ID 集合
+     * @param scopeType 权限作用域类型
+     * @param objectType 对象类型
+     * @return 角色摘要映射
+     */
+    default Map<Long, ObjectRoleRespDTO> getObjectRoleMap(Collection<Long> roleIds, String scopeType, String objectType) {
+        if (CollUtil.isEmpty(roleIds)) {
+            return MapUtil.empty();
+        }
+        List<ObjectRoleRespDTO> roles = getObjectRoleList(roleIds, scopeType, objectType).getCheckedData();
+        return CollectionUtils.convertMap(roles, ObjectRoleRespDTO::getId);
+    }
+
+}
--- a/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/api/permission/dto/ObjectMenuRespDTO.java
+++ b/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/api/permission/dto/ObjectMenuRespDTO.java
@@ -0,0 +1,34 @@
+package com.njcn.rdms.module.system.api.permission.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Schema(description = "RPC 服务 - 对象作用域菜单 Response DTO")
+@Data
+public class ObjectMenuRespDTO {
+
+    @Schema(description = "菜单 ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "2001")
+    private Long id;
+
+    @Schema(description = "菜单名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "产品设置")
+    private String name;
+
+    @Schema(description = "权限标识", example = "project:product:update")
+    private String permission;
+
+    @Schema(description = "菜单类型；允许返回目录、菜单、按钮，业务侧可按 type 再拆分导航或按钮", requiredMode = Schema.RequiredMode.REQUIRED, example = "2")
+    private Integer type;
+
+    @Schema(description = "显示排序", requiredMode = Schema.RequiredMode.REQUIRED, example = "10")
+    private Integer sort;
+
+    @Schema(description = "路由路径", example = "/project/product/detail")
+    private String path;
+
+    @Schema(description = "菜单图标", example = "ep:box")
+    private String icon;
+
+    @Schema(description = "是否可见", requiredMode = Schema.RequiredMode.REQUIRED, example = "true")
+    private Boolean visible;
+
+}
--- a/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/api/permission/dto/ObjectRolePermissionRespDTO.java
+++ b/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/api/permission/dto/ObjectRolePermissionRespDTO.java
@@ -0,0 +1,23 @@
+package com.njcn.rdms.module.system.api.permission.dto;
+
+import io.swagger.v3.oas.annotations.media.ArraySchema;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.util.List;
+import java.util.Set;
+
+@Schema(description = "RPC 服务 - 对象作用域角色权限聚合 Response DTO")
+@Data
+public class ObjectRolePermissionRespDTO {
+
+    @Schema(description = "当前查询 roleId 对应的角色摘要，不表示登录态上下文里的当前用户角色")
+    private ObjectRoleRespDTO currentRole;
+
+    @ArraySchema(schema = @Schema(description = "当前查询角色在指定 scopeType/objectType 下可消费的已启用菜单资源明细；允许包含目录、菜单、按钮，业务侧可按 type 再拆分导航或按钮"))
+    private List<ObjectMenuRespDTO> menus;
+
+    @ArraySchema(schema = @Schema(description = "基于同一批有效菜单资源归一化提取出的权限标识集合，供对象权限校验直接消费", example = "project:product:query"))
+    private Set<String> permissions;
+
+}
--- a/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/api/permission/dto/ObjectRoleRespDTO.java
+++ b/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/api/permission/dto/ObjectRoleRespDTO.java
@@ -0,0 +1,25 @@
+package com.njcn.rdms.module.system.api.permission.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Schema(description = "RPC 服务 - 对象作用域角色摘要 Response DTO")
+@Data
+public class ObjectRoleRespDTO {
+
+    @Schema(description = "角色 ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024")
+    private Long id;
+
+    @Schema(description = "角色编码", requiredMode = Schema.RequiredMode.REQUIRED, example = "product_manager")
+    private String code;
+
+    @Schema(description = "角色名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "产品经理")
+    private String name;
+
+    @Schema(description = "权限作用域类型", requiredMode = Schema.RequiredMode.REQUIRED, example = "object")
+    private String scopeType;
+
+    @Schema(description = "对象类型", requiredMode = Schema.RequiredMode.REQUIRED, example = "product")
+    private String objectType;
+
+}
--- a/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/api/user/UserManagementRelationApi.java
+++ b/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/api/user/UserManagementRelationApi.java
@@ -0,0 +1,49 @@
+package com.njcn.rdms.module.system.api.user;
+
+import cn.hutool.core.collection.CollUtil;
+import cn.hutool.core.map.MapUtil;
+import com.njcn.rdms.framework.common.pojo.CommonResult;
+import com.njcn.rdms.framework.common.util.collection.CollectionUtils;
+import com.njcn.rdms.module.system.api.user.dto.UserManagementRelationRespDTO;
+import com.njcn.rdms.module.system.enums.ApiConstants;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+@FeignClient(name = ApiConstants.NAME)
+@Tag(name = "RPC 服务 - 用户管理链路")
+public interface UserManagementRelationApi {
+
+    String PREFIX = ApiConstants.PREFIX + "/user-management-relation";
+
+    @GetMapping(PREFIX + "/list-by-manager")
+    @Operation(summary = "根据管理者用户ID获得管理链路列表")
+    @Parameter(name = "managerUserId", description = "管理者用户ID", example = "1", required = true)
+    CommonResult<List<UserManagementRelationRespDTO>> getRelationListByManagerUserId(@RequestParam("managerUserId") Long managerUserId);
+
+    @GetMapping(PREFIX + "/list-by-subordinate")
+    @Operation(summary = "根据被管理者用户ID获得管理链路列表")
+    @Parameter(name = "subordinateUserId", description = "被管理者用户ID", example = "2", required = true)
+    CommonResult<List<UserManagementRelationRespDTO>> getRelationListBySubordinateUserId(@RequestParam("subordinateUserId") Long subordinateUserId);
+
+    @GetMapping(PREFIX + "/list")
+    @Operation(summary = "获得管理链路列表")
+    @Parameter(name = "ids", description = "关系编号数组", example = "1,2", required = true)
+    CommonResult<List<UserManagementRelationRespDTO>> getRelationList(@RequestParam("ids") Collection<Long> ids);
+
+    default Map<Long, UserManagementRelationRespDTO> getRelationMap(Collection<Long> ids) {
+        if (CollUtil.isEmpty(ids)) {
+            return MapUtil.empty();
+        }
+        List<UserManagementRelationRespDTO> list = getRelationList(ids).getData();
+        return CollectionUtils.convertMap(list, UserManagementRelationRespDTO::getId);
+    }
+
+}
--- a/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/api/user/dto/AdminUserRespDTO.java
+++ b/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/api/user/dto/AdminUserRespDTO.java
@@ -14,6 +14,9 @@ public class AdminUserRespDTO implements VO {
    @Schema(description = "用户昵称", requiredMode = Schema.RequiredMode.REQUIRED, example = "小王")
    private String nickname;

+    @Schema(description = "所属公司", example = "灿能")
+    private String company;
+
    @Schema(description = "帐号状态", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
    private Integer status; // 参见 CommonStatusEnum 枚举

--- a/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/api/user/dto/UserManagementRelationRespDTO.java
+++ b/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/api/user/dto/UserManagementRelationRespDTO.java
@@ -0,0 +1,35 @@
+package com.njcn.rdms.module.system.api.user.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/**
+ * 用户管理链路 Response DTO
+ *
+ * @author dklive
+ */
+@Schema(description = "RPC 服务 - 用户管理链路 Response DTO")
+@Data
+public class UserManagementRelationRespDTO {
+
+    @Schema(description = "主键ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
+    private Long id;
+
+    @Schema(description = "管理者用户ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
+    private Long managerUserId;
+
+    @Schema(description = "被管理用户ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "2")
+    private Long subordinateUserId;
+
+    @Schema(description = "生效开始时间")
+    private LocalDateTime effectiveFrom;
+
+    @Schema(description = "生效结束时间")
+    private LocalDateTime effectiveUntil;
+
+    @Schema(description = "备注")
+    private String remark;
+
+}
--- a/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/enums/DictTypeConstants.java
+++ b/rdms-system/rdms-system-api/src/main/java/com/njcn/rdms/module/system/enums/DictTypeConstants.java
@@ -12,6 +12,7 @@ public interface DictTypeConstants {
    String USER_SEX = "system_user_sex";
    String LOGIN_TYPE = "system_login_type";
    String LOGIN_RESULT = "system_login_result";
+    String OBJECT_DIRECTION = "rdms_object_direction";

    String JOB_STATUS = "infra_job_status";
    String JOB_LOG_STATUS = "infra_job_log_status";
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
hongawen	ae90dcec24	feat(project): 为项目活动时间线添加成员角色名称显示功能 - 在 ObjectActivityConstants 中添加 MEMBER_ACTION_UPDATE 类型支持 - 为 ProductActivityQueryService 和 ProductActivityTimelineQueryService 添加角色名称加载和缓存功能 - 实现角色名称解析和 JSON 数据结构扩展 - 添加相关单元测试验证角色名称显示逻辑 - 集成 ObjectPermissionApi 获取角色信息并实现缓存机制	2026-04-24 16:22:23 +08:00
hongawen	ee732b97bf	feat(project): 新增产品动态时间线接口并重构活动查询逻辑 - 新增 GET /project/product/{id}/activities/page 接口用于产品动态时间线分页查询 - 添加 ProductActivityTimelinePageReqVO 和 ProductActivityTimelineRespVO 数据传输对象 - 实现 ProductActivityTimelineQueryService 服务处理动态时间线查询逻辑 - 在 BizAuditLogMapper 中新增按业务类型和动作类型查询的方法 - 在 ProductStatusLogMapper 中新增按产品ID和动作类型查询的方法 - 将硬编码的活动类型常量抽取到 ObjectActivityConstants 统一管理 - 重构 ProductActivityQueryService 使用统一的常量和查询方法 - 更新 ProductMemberServiceImpl 和 ProductServiceImpl 使用新的活动常量 - 添加相应的单元测试验证新接口和查询逻辑的正确性 - 新增产品对象首页改版设计文档和产品动态时间线接口需求说明文档	2026-04-24 15:43:38 +08:00
hongawen	0a6d70f7cf	feat(permission): 新增对象权限API接口及实现 - 定义ObjectPermissionApi接口提供对象作用域权限查询功能 - 实现ObjectPermissionApiImpl提供角色权限查询和转换逻辑 - 添加ObjectMenuRespDTO、ObjectRoleRespDTO和ObjectRolePermissionRespDTO数据传输对象 - 实现按角色ID、角色编码查询对象作用域角色及权限的功能 - 提供获取对象作用域角色菜单与权限聚合结果的方法 - 添加完整单元测试覆盖对象权限API的主要业务场景	2026-04-23 09:23:33 +08:00
hongawen	156728b1b9	feat(permission): 重构权限系统实现对象级别权限控制 - 在PermissionService中新增getScopedMenusByRoleId和getScopedPermissionsByRoleId方法 - 实现getScopedMenusByRoleId方法用于获取角色的对象范围菜单列表 - 实现getScopedPermissionsByRoleId方法用于获取角色的对象范围权限集合 - 添加getEnabledScopedRole私有方法确保只处理启用状态的角色对象 - 在ProductMemberServiceImpl中替换SystemRoleMapper为ObjectPermissionApi调用 - 将验证产品角色的方法改为调用远程权限接口验证 - 更新ProductObjectPermissionService使用远程权限接口替代本地查询 - 修改ProductServiceImpl中权限获取逻辑使用新的对象权限API - 移除原有的系统菜单和角色相关的数据对象依赖 - 在测试类中更新模拟对象和断言逻辑适配新的权限接口调用	2026-04-23 09:22:43 +08:00
hongawen	2943a6255b	docs(product): 删除产品管理SQL口径和业务设计文档 - 移除02-产品管理SQL已确认口径文档 - 移除02-产品管理业务设计文档 - 清理产品管理模块的详细设计说明 - 删除产品需求状态字段口径定义 - 移除来源承接与需求拆分口径说明 - 清理需求终态原因承接口径内容 - 删除产品生命周期管理设计 - 移除产品团队权限管理规范 - 清理产品与项目关系约束说明 - 删除轻量需求管理业务规则 - 移除产品状态机与流程设计 - 清理权限与动作矩阵定义	2026-04-22 18:18:38 +08:00
dk	f8231c2d51	feat(user): 支持前端用用户昵称字段进行模糊搜索 fix(post): 使岗位排序能按照sort字段来排序。	2026-04-22 14:38:41 +08:00
hongawen	a1f5936d20	Merge remote-tracking branch 'origin/main'	2026-04-18 14:20:06 +08:00
hongawen	38c69c748c	feat(other): 产品基础功能提交	2026-04-18 14:19:45 +08:00
dk	5815f49a79	fix(system-boot_user): 增加用户昵称不能为空的后端校验。	2026-04-16 20:55:29 +08:00
dk	0c91f5deaa	fix(system-api、boot): 给用户管理功能相关的各种需要company字段的类，新增company字段。	2026-04-16 20:29:36 +08:00
dk	67040aaf5d	fix(UserManagementRelationxxx.java): 优化了一些细节，主要是汇报关系 -> 管理链路。	2026-04-15 20:56:58 +08:00
dk	8af6842809	fix(UserManagementRelationxxx.java): 优化了一些细节，主要是代码注释，带人关系 -> 汇报关系。	2026-04-15 20:48:17 +08:00
hongawen	9384b2f502	feat(system): 取消角色superadmin能看到所有菜单的约定，改为实际配置实际显示	2026-04-14 18:58:26 +08:00
dk	07d07c8f5f	feat(UserManagementRelationxxx.java): 改造带人关系树的构造代码。 feat(UserController.java): 新增/list-by-dept-id接口，根据部门ID获取该部门和下属部门的用户精简信息列表。 fix(AdminUserServiceImpl.java): 修复删除某用户（含批量删除）后，带人关系树构造错乱、加载不出来的问题。	2026-04-14 16:32:06 +08:00
dk	c3dd0c9802	fix(package-info.java): 增加包声明。	2026-04-13 13:44:02 +08:00
dk	21ca027f3b	feat(user-management-relation): 完成带人关系后端接口（即直接管理）	2026-04-10 16:26:59 +08:00
dk	017beb1d5f	1.提交到本地	2026-04-07 11:21:18 +08:00
dk	09cba49a7d	Merge remote-tracking branch 'origin/main'	2026-04-07 11:14:54 +08:00
dk	7e22f79b5f	1.修复当有用户使用某个角色时，该角色也可以被禁用的BUG 2.引入热部署依赖，配置开启热部署（热更新快捷键：Ctrl+F9）	2026-04-07 11:14:28 +08:00