diff --git a/code/fms/.tmp-probe/wb-switch-migrate.mjs b/code/fms/.tmp-probe/wb-switch-migrate.mjs
new file mode 100644
index 00000000..8f866039
--- /dev/null
+++ b/code/fms/.tmp-probe/wb-switch-migrate.mjs
@@ -0,0 +1,134 @@
+// 方案2：把 coderelay 的 auth 文件转换为 wb-switch 的 accounts.json 记录格式
+// 依据 wb-switch-rust.exe 中提取的结构字符串：
+//   Account 字段: id uid nickname email access_token refresh_token token_type
+//                 expiresAt refreshExpiresAt refreshedAt createdAt domain
+//                 enterpriseId enterpriseName variant needs_relogin needs_relogin_reason
+//                 auth_raw profile_raw
+//   credit_usage_snapshots: { accountId, accountName, variant, remaining, total, ts }
+import fs from 'node:fs';
+import path from 'node:path';
+
+const AUTH_DIR = 'C:/Users/admin/AppData/Roaming/com.coderelay.desktop/sidecar-runtime/auths';
+const WB_DIR = 'C:/Users/admin/.wb-switch';
+const ACCOUNTS = path.join(WB_DIR, 'accounts.json');
+const SNAPSHOTS = path.join(WB_DIR, 'credit_usage_snapshots.json');
+
+const DRY_RUN = !process.argv.includes('--apply');
+
+// ---- 1. 读取 coderelay 的 auth 文件 ----
+const authFiles = fs.readdirSync(AUTH_DIR).filter((f) => f.endsWith('.json'));
+const converted = [];
+const now = Date.now();
+
+for (const file of authFiles) {
+  const raw = fs.readFileSync(path.join(AUTH_DIR, file), 'utf8');
+  const a = JSON.parse(raw);
+
+  // uid 是唯一稳定的账号标识；id 与 uid 取同一个值（wb-switch 用它关联积分快照）
+  const id = a.uid;
+  if (!id) {
+    console.warn(`[skip] ${file}: 无 uid`);
+    continue;
+  }
+
+  // JWT exp 解出过期时间，用于 expiresAt（毫秒）
+  let expMs;
+  try {
+    const payload = JSON.parse(
+      Buffer.from(a.access_token.split('.')[1], 'base64url').toString('utf8'),
+    );
+    if (payload.exp) expMs = payload.exp * 1000;
+  } catch {
+    /* 保守处理：解不出就不写 expiresAt */
+  }
+
+  const nickname = a.email || id;
+  // profile_raw 承载 plan/quota 等展示字段，让界面能显示套餐与积分
+  const profileRaw = {
+    planType: a.payment_type ?? null,
+    planRank: a.plan_rank ?? null,
+    region: a.region ?? null,
+    enterpriseId: a.enterprise_id ?? '',
+    baseUrl: a.base_url ?? null,
+    type: a.type ?? null,
+  };
+
+  converted.push({
+    id,
+    uid: id,
+    nickname,
+    email: a.email ?? '',
+    access_token: a.access_token,
+    refresh_token: a.refresh_token,
+    token_type: 'Bearer',
+    domain: a.domain ?? 'www.codebuddy.cn',
+    enterpriseId: a.enterprise_id ?? '',
+    enterpriseName: '',
+    variant: a.region === 'cn' ? 'cn' : 'ai',
+    expiresAt: expMs ?? null,
+    createdAt: now,
+    refreshedAt: now,
+    // auth_raw 保存原始认证响应，是 wb-switch 认账的关键字段
+    auth_raw: raw,
+    profile_raw: JSON.stringify(profileRaw),
+    remaining: typeof a.quota_remain === 'number' ? a.quota_remain : undefined,
+  });
+}
+
+console.log(`coderelay auth 文件: ${authFiles.length} 个，成功转换 ${converted.length} 条`);
+
+// ---- 2. 读取现有 accounts.json，保留非本次导入的账号 ----
+const existing = JSON.parse(fs.readFileSync(ACCOUNTS, 'utf8'));
+const importedUids = new Set(converted.map((c) => c.uid));
+
+// 残缺记录：无 id 且 uid 属于本次导入范围。
+// 注意：这类记录是 wb-switch 刷新时 append 出来的孤儿（每条 token 都不同，
+// 并非同一 token 的复制），清除它们不会丢失任何独立账号。
+const isJunk = (r) => r.id === undefined && importedUids.has(r.uid);
+const kept = existing.filter((r) => !isJunk(r));
+const removed = existing.length - kept.length;
+
+console.log(`现有记录 ${existing.length} 条 → 清除残缺重复 ${removed} 条，保留 ${kept.length} 条`);
+
+// ---- 3. 组装新 accounts.json ----
+const cleaned = converted.map(({ remaining, ...rest }) => rest);
+const merged = [...kept, ...cleaned];
+
+console.log(`\n新 accounts.json 将包含 ${merged.length} 条:`);
+for (const r of merged) {
+  console.log(`  - ${r.nickname} | id=${r.id} | variant=${r.variant ?? '-'}`);
+}
+
+// ---- 4. 积分快照 ----
+const snapshots = JSON.parse(fs.readFileSync(SNAPSHOTS, 'utf8'));
+const newSnaps = converted
+  .filter((c) => c.remaining !== undefined)
+  .map((c) => ({
+    accountId: c.id,
+    accountName: c.nickname,
+    remaining: c.remaining,
+    total: 0,
+    ts: now,
+    variant: c.variant,
+  }));
+
+const snapMerged = [...snapshots, ...newSnaps];
+console.log(`\n积分快照 ${snapshots.length} → ${snapMerged.length} 条（新增 ${newSnaps.length}）`);
+for (const s of newSnaps) {
+  console.log(`  - ${s.accountName} | remaining=${s.remaining} | accountId=${s.accountId}`);
+}
+
+// ---- 5. 写入 ----
+const accountsJson = JSON.stringify(merged, null, 2);
+const snapJson = JSON.stringify(snapMerged, null, 2);
+
+if (DRY_RUN) {
+  fs.writeFileSync('D:/workspace/code/fms/.tmp-probe/accounts.new.json', accountsJson);
+  fs.writeFileSync('D:/workspace/code/fms/.tmp-probe/snapshots.new.json', snapJson);
+  console.log('\n[DRY-RUN] 未改动 wb-switch。预览已写入 .tmp-probe/');
+  console.log('确认无误后加 --apply 执行');
+} else {
+  fs.writeFileSync(ACCOUNTS, accountsJson);
+  fs.writeFileSync(SNAPSHOTS, snapJson);
+  console.log('\n[APPLIED] 已写入 accounts.json 和 credit_usage_snapshots.json');
+}
diff --git a/code/fms/FMS删除策略重构-待决策问题清单.md b/code/fms/FMS删除策略重构-待决策问题清单.md
new file mode 100644
index 00000000..9d5b4b02
--- /dev/null
+++ b/code/fms/FMS删除策略重构-待决策问题清单.md
@@ -0,0 +1,262 @@
+# FMS 删除策略重构 — 待决策问题清单（已全部关闭）
+
+> **状态：本文所列问题均已决策并实施完毕，保留作为决策过程的记录。**
+> 结论已回写进 `FMS删除策略重构设计.md`（v1.1 / v1.2），代码已按结论落地。
+> 阅读本文时请以设计文档为准；本文只说明"为什么设计长成现在这样"。
+>
+> 最终决策对照：
+>
+> | # | 问题 | 结论 |
+> | --- | --- | --- |
+> | 1 | `b_on_delete` 默认值 | 新建关系默认 `restrict`；**存量 `none` 不回填**，避免上线后突然改变存量删除行为（设计 §3.1） |
+> | 2 | SQL 只读校验 | 复用 `DbUtils.validateReadOnlySql` + `DbUtils.loadDataBySql(Connection, String)`，不新建第二套判定器（设计 §4.4） |
+> | 3 | `:ids` 参数形式 | 非 JDBC 命名参数；引擎按主键类型替换为**经过校验和转义**的字面量 `IN` 列表（设计 §4.2） |
+> | 4 | 两条路径清单合并 | 显式删除与 cascade 展开按「表 + 主键字段 + 主键值」**去重合并**；同一记录同时以两种目标提交直接报冲突（设计 §6.2） |
+> | 5 | `b_module_id` 类型 | `varchar(50)` 模块编码，与 `s_relation` 等配置表一致（设计 §4.1） |
+> | 6 | 前端多对一硬编码 | `ModuleRelationPanel.vue` 的 `isManyToOne` 禁用/重置/警告与 `_hasRefRule` 联动全部删除（设计 §3.2、§9 第三阶段） |
+> | 7 | 视图表回退 | 删除操作只允许 `b_save_table`；为空时前后端都拒绝，绝不回退 `b_view_table`（设计 §6.1） |
+>
+> 除此之外，设计文档还新增了两处本文未提出的必要补充：
+> `target=module/direct` 二分（§1.1，避免给 `bf_files` 等技术表虚构模块）和文件删除路径（§6.3）。
+
+---
+
+> 用途（原始）：本文把《FMS删除策略重构设计.md》落地前必须先拍板的问题集中列出，供多方（人工 + 其他 AI）评审。
+> 阅读者可能无法访问本代码库，因此每个问题都附带了**必要的事实依据**（文件路径 + 行号 + 现有代码片段）。
+>
+> 背景：`FMS删除策略重构设计.md` v1.0 是一份"架构定稿、由 AI 执行"的文档。本文**不否定其架构方向**，
+> 只列出执行前存在的现状误判、行为反转风险与设计空白。
+>
+> 已确认的前提：**当前数据库无配置数据，`s_rule` 可直接删表重建**（该前提消除了"数据迁移"类问题）。
+
+---
+
+## 一、先说结论
+
+文档的**架构判断是正确的**，值得保留：
+
+1. 两类配置不合并（关联处置 vs SQL 规则，依赖维度不同）；
+2. SQL 规则只保留"返回至少一行 → 拒绝"这一条契约，废弃 `b_scope_type` / `b_scope_id` / `b_hook` / `b_kind` / `b_predicate`；
+3. 删除引擎三职责（计划器 / 检查器 / 执行器），对前端只暴露一个动作；
+4. 列表删除与 `saveobjt` 删行共用同一套检查逻辑。
+
+但文档 §9「AI 实施顺序」建立在**对代码现状的错误假设**上，直接照做会出错。
+以下 4 个问题的性质不同，其中 **问题 1 和问题 3 必须人工拍板**，问题 2、4 属于文档补全。
+
+---
+
+## 二、问题 1（必须决策）：`b_on_delete` 默认值 `none → restrict` 是行为反转
+
+### 事实依据
+
+现状建表语句 `sql/fms_core.sql:208`：
+
+```sql
+b_on_delete varchar(20) not null default 'none', -- 删除连带：none不连带 / cascade连带删除 / archive连带归档
+```
+
+文档 §3.1 要求：**默认值使用 `restrict`**，且只允许 `restrict` / `cascade` / `none` 三值。
+
+### 为什么这是问题
+
+`none` 与 `restrict` 的语义是相反的：
+
+| 取值 | 语义 | 新增一条关系后的默认行为 |
+| --- | --- | --- |
+| `none`（现状默认） | 不展开、**不保护**，由配置者承担结果 | 删主单时明细不受任何检查 |
+| `restrict`（文档要求） | 被引用方仍有外部引用时**拒绝删除** | 删主单时会被明细挡住 |
+
+文档 §8 已明确"没有登记到 `s_relation` 的引用不在自动保护范围内"，这没问题；
+但**已登记关系且取值为 `none`** 的那些，默认值一改，行为立即翻转。
+
+### 与现有前端代码的直接冲突
+
+`fms-vue/src/views/module/module-management/ModuleRelationPanel.vue:317-318`：
+
+```js
+if (dataIndex === 'b_relation_type' && isManyToOne(row) && row.b_on_delete !== 'none') {
+  row.b_on_delete = 'none'
+}
+```
+
+前端现在把 `many_to_one` 关系的 `b_on_delete` **强制重置为 `none`**。
+而文档 §3.2 明确反对这一做法："`many_to_one` 不在前端被硬编码禁止 `cascade`……是否允许级联由配置和业务语义决定"。
+
+也就是说，**文档 §3.2 那一整节实际上是在推翻一段已存在的代码**，但文档没有点名，
+执行者可能只改后端、漏掉这段前端硬编码，导致新配置在界面上被静默改回 `none`。
+
+### 待决策
+
+`s_relation.b_on_delete` 的默认值如何处理？可选：
+
+- **方案 A（推荐）**：列默认值改为 `restrict`（新增关系默认受保护），同时写一条回填语句把**存量关系**置为 `none`，保证现有删除行为不变。
+- **方案 B**：存量关系也一并改为 `restrict`，一致性最好，但上线后可能突然挡住一批原本能删的操作。
+- **方案 C**：保持 `none` 为默认，仅补充 `cascade` / `restrict` 的显式配置能力（与文档 §3.1 不一致，需回改文档）。
+
+**并且需要明确**：文档 §3.1 说的"默认值"，指的是**数据库列默认值**，还是**配置界面新增行时的默认值**？两者可以不同。
+
+---
+
+## 三、问题 2（文档补全）：SQL 规则的"只读"边界存在现成手段，但文档未引用
+
+文档 §4.2 约定"SQL 必须是只读查询"，§4.3 重申"配置 SQL 不等于允许 SQL 修改数据"，
+但**没有指定用什么机制保证**，也没说复用现有能力。
+
+### 事实依据
+
+- 项目规范《开发规范.md》第 8 条已把"只执行查询语句"定为系统级边界：
+  > **原生 SQL 仅限查询** — `b_query_sql`、查询 SQL 扩展和调用方传入的 SQL 可以是任意合法的 `SELECT` 语句……
+  > 禁止执行 `INSERT`、`UPDATE`、`DELETE`、DDL、存储过程调用及其他非查询语句。
+- 现有实现样板：`fms-api/src/main/java/cn/g3soft/fmsapi/service/SqlPermissionService.java`
+  （模块级 SQL 条件拼装与服务端数据范围过滤，可直接参照其连接管理与查询执行方式）。
+
+### 建议
+
+在 §4.2 补一句：**复用现有 `SELECT` 校验入口与连接管理，不新写一套 SQL 判定器**
+（符合《开发规范.md》第 3、4 条"复用现有模式 / 修改范围最小化"）。
+
+---
+
+## 四、问题 3（必须决策）：`:ids` 的参数形式未定义，而它决定契约能否落地
+
+### 事实依据
+
+文档 §4.2 给出的 SQL 契约示例：
+
+```sql
+select b_id, b_no
+from cw_receipt
+where b_id in (:ids)
+  and b_status in ('审核中', '已生效')
+```
+
+文档只写"统一使用 `:ids` 作为批量参数"，**没有说明这个占位符在实现层是什么**。
+
+而现有数据访问层的能力是**字面量拼接**，不是命名参数：
+`DbUtils` 提供 `toSqlStringLiteral(...)`；`DataSaveService.executeRows(...)`
+（`fms-api/.../service/DataSaveService.java:460-479`）逐行调用 `dbUtils.delete/update/insert`，
+`SqlPermissionService` 拼数据范围条件时同样是 `dbUtils.toSqlStringLiteral(userId)` 直接拼进 SQL 文本。
+
+### 因此 `:ids` 只能有三种落地方式，必须选一个
+
+- **方案 A**：引擎把 `:ids` 替换为拼接好的 `IN (...)` 列表（雪花 bigint 或业务键 varchar，按类型加引号/校验）。与现有代码风格一致。
+- **方案 B**：改造 `DbUtils` 支持真正的参数化（`?` / 命名参数），改动面大，触及所有保存/查询路径。
+- **方案 C**：把待删 ID 集先写入临时表，SQL 用 `join` 临时表（避免超长 `IN` 列表，但引入临时表生命周期管理）。
+
+**相关约束**：《开发规范.md》第 5 条"当前系统按内部 ERP 处理……不额外引入复杂的安全防护层"，
+第 6 条"SQL 驱动优先"。按此基调，**方案 A 更契合**，但需要文档显式写明，
+并要求删除引擎统一对 `ids` 做**类型校验**（不能把用户输入直接拼进 SQL）。
+
+此外还需明确：`:ids` 是**当前模块本次待删 ID**，还是**整个删除清单所有模块的 ID**？
+文档 §4.2 写"SQL 接收当前模块本次待删除的 ID 集合"，暗示是前者，
+但多条规则跨模块级联时，配置者可能期望看到子表 ID —— 这一点容易产生歧义。
+
+---
+
+## 五、问题 4（必须是设计决策，不是实现细节）：两条路径的待删清单如何合并
+
+文档 §6 说列表删除和 `saveobjt` 删行"共用一套检查逻辑"，方向正确，但**合并规则是空白的**。
+
+### 事实依据
+
+`saveobjt` 的实际执行顺序（`fms-api/.../service/DataSaveService.java:417-437`）：
+
+```java
+executeRows(connection, table, keyColumns, "delete", rows(request, "deletes"));
+executeRows(connection, table, keyColumns, "update", rows(request, "updates"));
+executeRows(connection, table, keyColumns, "insert", rows(request, "inserts"));
+```
+
+即 **先 delete → 再 update → 最后 insert**，且逐行循环。
+
+前端列表删除现状（`fms-vue/src/components/fms-module-list/FmsModuleListPage.vue:877-933`）：
+`deleteSelected()` 取 `resolveSaveTable()`（`:754`，即 `b_save_table || b_view_table`），
+然后调用 `saveObjectApi([{ table, key_field, deletes }])` —— **传的是裸表名，不是模块编码**。
+
+### 由此产生的三个未答问题
+
+1. **`moduleCode + ids` 如何反查表和主键？**
+   文档 §6.1 要求列表删除改为传 `moduleCode + ids`，但现有链路是 `table + key_field`。
+   后端需要新增"模块 → 保存表 + 主键字段"的反查，且需考虑一个模块可能对应多张表的情况。
+   `saveobjt` 路径则保留 `table` 入参 —— **两条路径的入参格式不一致，如何落到同一个服务？**
+
+2. **cascade 展开的子记录与请求自带的 `deletes` 行如何合并去重？**
+   例如 `saveobjt` 请求本身带了明细行的 `deletes`（表单删行），而 cascade 又从主单展开出同一批明细。
+   文档 §5.2 只说"删除清单内的引用方视为本次一起删除，不触发外部引用保护"，
+   但**没说这份清单怎么构建、两处来源怎么去重**。若不去重，可能出现同一记录删两次（第二次影响 0 行，或触发异常）。
+
+3. **cascade 展开的记录插入 `delete → update → insert` 的哪个位置？**
+   若模块级删除规则或外键约束要求"子先父后"，展开出的多层级记录必须排在请求自带 `deletes` 的**合适位置**。
+   文档 §5.3 给的流程是"生成清单 → 检查 → 子记录到主记录物理删除"，但**没有说明它与 `saveobjt` 既有顺序约束的关系**。
+
+### 待决策
+
+- **方案 A（推荐）**：cascade 展开结果与 `saveobjt` 自带 `deletes` 按「模块 + 主键」**去重合并成一份清单**，再统一检查、按子先父后排序后删除。
+- **方案 B**：`saveobjt` 路径不做 cascade，只对请求自带的 `deletes` 跑规则检查（简单，但两条路径语义不再等价，与文档 §6 目标冲突）。
+
+---
+
+## 六、问题 5（文档补全）：`s_delete_rule.b_module_id` 的类型与取号方式
+
+文档 §4.1 概念字段表列出 `b_id`（雪花主键）与 `b_module_id`（规则所属数据模块），
+但**没有给出 `b_module_id` 的类型**，也没有说明新增规则时是否走前端取号。
+
+### 事实依据
+
+《开发规范.md》「面板式配置页（左树右面板）设计」第 6 条：
+
+> **模块配置不使用雪花临时 ID** — 模块管理中的 `s_module` 使用业务编码，
+> `s_field`、`s_module_schema`、`s_autocode`、`s_relation` 等配置表使用业务键或联合主键；
+> 新增配置行直接使用业务字段组成的临时唯一键，不调用 `nextIdApi`，保存时也不做"临时 ID → 雪花 ID"转换。
+
+即模块配置类的表普遍用**业务编码 varchar(50)** 作为模块引用（`s_relation.b_source_module_id` 即如此）。
+而 `s_delete_rule` 与 `s_rule` 同族，旧表用的是 `b_scope_id varchar(250)`。
+
+### 待决策
+
+- `b_module_id` 用 `varchar(50)` 业务编码（与 `s_relation` 一致，前端不做 ID 换号），还是 `bigint` 雪花 ID？
+- 若用 `varchar(50)`：`b_id` 是规则主键（雪花），新增规则仍需前端取号 —— 这与"配置表不做 ID 转换"是否冲突？
+  旧 `s_rule` 的做法是"前端经 `/data/nextid` 取号"（见 `sql/fms_delete_rule.sql:29` 注释），文档未表态。
+
+---
+
+## 七、问题 6（次要）：文档对"现状"的描述性错误
+
+这类问题不影响架构，但会让执行者误判起点，建议一并修正：
+
+| 文档位置 | 文档表述 | 实际情况 |
+| --- | --- | --- |
+| §1 | `s_relation.b_on_delete` | **已存在**（`sql/fms_core.sql:208`），无需"增加" |
+| §3.1 | "并增加或保留一个删除行为列" | 列已存在，只需改默认值语义 |
+| §9 第一阶段 2 | "删除旧 `s_rule` 结构，建立 `s_delete_rule`" | 旧设计**已完整落地**：`sql/fms_delete_rule.sql` 建了 `s_rule`，且前端整套已实现 |
+| §7 | 待删除的旧概念 `勾条件` / `引用规则` / `refRules` / `relationScopeId` / `b_scope_type` … | **全部真实存在**，不是待设计的抽象概念（见下方清单） |
+
+### 旧设计在前端的实际落点（§7 要求删除的对象）
+
+- `fms-vue/src/views/module/module-management/ruleUtils.js`（195 行，规则类型三态推断、关系业务键拼装）
+- `fms-vue/src/views/module/module-management/ModuleRulePanel.vue`
+- `fms-vue/src/views/module/module-management/ModuleRuleEditModal.vue`
+- `fms-vue/src/views/module/module-management/ModuleRelationPanel.vue`
+- `fms-vue/src/views/module/module-management/index.vue`（`rules` / `refRules` / `refRulesReverse` / `refRules_org` 等状态与读写逻辑）
+- `sql/fms_core.sql:237-256`（`s_rule` 建表 + 索引）
+- `sql/fms_delete_rule.sql`（旧迁移脚本）
+
+值得注意：`ruleUtils.js:62-74` 的 `parseRulePredicate()` 用
+"是不是 `{` 开头 / 能不能 `JSON.parse` / `kind === 'dsl'`"来**推断规则类型**（引用 / 勾条件 / SQL 三态）。
+这种靠内容猜测类型的做法脆弱且难维护，正是新版"只保留 SQL + 关系处置"的改进理由 ——
+**建议把这条写进文档 §4.3，作为废弃 `s_rule` 的具体论据**，比现在的抽象论证更有说服力。
+
+---
+
+## 八、汇总：需要人工拍板的决策点
+
+| # | 决策点 | 影响 |
+| --- | --- | --- |
+| 1 | `b_on_delete` 默认值：存量是否升级 `restrict`；"默认"指列还是界面 | 决定上线后现有删除行为是否变化 |
+| 2 | `:ids` 落地方式：拼接 IN / 参数化 / 临时表；以及 `ids` 范围 | 决定 SQL 契约能否实现及引擎改造量 |
+| 3 | 两条路径清单合并：是否去重合并；cascade 是否参与 `saveobjt` | 决定两条路径语义是否真正等价 |
+| 4 | `b_module_id` 类型与规则取号方式 | 决定建表脚本与前端取号逻辑 |
+| 5 | `ModuleRelationPanel.vue:317-318` 的 `many_to_one → none` 硬编码是否删除 | 不删则新配置在界面被静默改回 |
+
+其余（问题 2、6）为文档补全，不需决策，但**建议在开工前先改文档**，
+否则执行者会按错误的现状描述行动。
diff --git a/code/fms/FMS删除策略重构设计.md b/code/fms/FMS删除策略重构设计.md
new file mode 100644
index 00000000..85c152ad
--- /dev/null
+++ b/code/fms/FMS删除策略重构设计.md
@@ -0,0 +1,385 @@
+# FMS 删除策略重构设计
+
+> 版本：v1.2
+>
+> 本文取代此前的删除规则设计和改造清单。本文只确定架构、边界和实施思路，具体代码由 AI 按本文执行。
+>
+> 设计目标：操作简单、执行逻辑简单、业务控制以 SQL 为主；第一期只做物理删除，不做归档。
+
+## 1. 重构结论
+
+删除能力保留两个来源，但统一放到一个“删除策略”入口下：
+
+```text
+删除策略
+├── 关联删除处理
+│   └── s_relation.b_on_delete
+└── 删除 SQL 规则
+    └── s_delete_rule
+```
+
+两部分回答的问题不同：
+
+| 配置 | 要回答的问题 | 作用 |
+| --- | --- | --- |
+| 关联删除处理 | 删除一条记录时，关联记录怎么办 | 展开级联删除、保护外部引用 |
+| 删除 SQL 规则 | 什么情况下不允许删除 | 检查状态、业务单据、跨表条件 |
+
+不把两类配置合成一张表。关联处理依赖关系方向和基数，SQL 规则依赖模块和删除批次；合成后会重新引入范围类型、拼接关系键和大量无意义的空字段。
+
+### 1.1 删除对象不强制绑定模块
+
+删除对象分为两类，不能为了统一接口给没有业务模块的表虚构 `moduleCode`：
+
+| 删除对象 | 调用参数 | 处理方式 |
+| --- | --- | --- |
+| 业务模块数据 | `target=module` + `moduleCode + ids` | 读取模块的保存表和主键，展开 `cascade`，执行 `restrict` 和模块 SQL 规则，再物理删除 |
+| 技术表或专用资源 | `target=direct` + `table + key_field + ids` | 直接进入物理删除执行器，不读取模块关系，不执行模块 SQL 规则 |
+
+两类请求共用连接、事务、主键类型校验、批量上限、日志和底层物理删除执行器；只有第一类进入删除计划器和删除检查器。后端不根据表名反查模块，也不要求 `bf_files`、配置表、日志表等技术表登记一个无意义的模块。
+
+“直接删除”表示删除策略层不再展开业务关系。它不表示可以绕过文件服务自身的清理步骤：文件删除仍由文件服务先删除本地文件或 OSS 对象，再删除 `bf_files` 行。
+
+直接表目标只由文件服务或其他受控的后端服务调用，普通模块列表不允许让用户任意传入表名和主键字段。
+
+## 2. 第一阶段范围
+
+### 2.1 第一阶段包含
+
+- 模块关系上的物理删除策略：`restrict`、`cascade`、`none`；
+- 模块级 SQL 删除规则；
+- 无模块技术表的直接物理删除；
+- 模块列表删除和 `saveobjt` 中的模块删除共用一套检查逻辑；无模块删除共用同一个物理删除执行器；
+- 批量删除、事务回滚、子记录先删；
+- 删除失败时返回可读的规则或关系错误；
+- 技术日志记录规则执行和删除结果。
+
+### 2.2 第一阶段不包含
+
+- `archive` 归档行为；
+- `b_archived`、`b_archive_datetime` 等归档字段；
+- JSON 条件 AST 和“勾条件”编辑器；
+- 保存前规则、修改限制、Java 钩子和自动业务动作；
+- 让配置 SQL 直接修改或删除业务数据；
+- 为删除策略另建角色、模板或继承体系。
+
+后续增加归档时，只扩展关联删除策略和执行器，不改变 SQL 删除规则的语义。
+
+## 3. 关联删除处理
+
+### 3.1 `s_relation.b_on_delete`
+
+`s_relation` 继续负责模块字段之间的关系映射，并增加或保留一个删除行为列。第一阶段只允许三个值：
+
+| 值 | 语义 |
+| --- | --- |
+| `restrict` | 被引用方仍有外部引用时拒绝删除 |
+| `cascade` | 引用方记录加入本次物理删除清单 |
+| `none` | 不自动处理关联记录 |
+
+新建关系的默认值使用 `restrict`。已存在的 `none` 不批量回填为 `restrict`，以免上线后突然改变存量删除行为；存量关系是否升级由单独迁移决定。只有登记在 `s_relation` 中的关系才进入自动保护范围；没有登记的表不视为系统已知引用。
+
+### 3.2 关系方向
+
+关系类型表达结构，删除行为表达处置方式，两者不互相推断：
+
+| 关系类型 | 外键所在侧 | 被引用方 |
+| --- | --- | --- |
+| `many_to_one` | 源字段 | 目标模块 |
+| `one_to_many` | 目标字段 | 源模块 |
+| `one_to_one` | 按系统约定 | 源模块 |
+
+`many_to_one` 不在前端被硬编码禁止 `cascade`。例如“明细 → 主单”的多对一关系，删除主单时级联删除明细是合理场景。是否允许级联由配置和业务语义决定，后端负责检查环路、重复记录和删除层级。
+
+这是对现有前端行为的明确改造要求，不能只改后端：
+
+- 删除 `fms-vue/src/views/module/module-management/ModuleRelationPanel.vue` 中 `b_on_delete` 编辑器的 `disabled: (row) => isManyToOne(row)`；
+- 删除同文件 `onCellChange` 中“关系类型切为多对一就把 `b_on_delete` 重置为 `none` 并弹出‘多对一关系不支持连带删除/连带归档’”的代码块；
+- 删除 `_hasRefRule`、`setRefRule` 及其关系键变化联动，引用保护统一由 `b_on_delete = restrict` 表达；
+- `b_on_delete` 的唯一配置来源是删除策略中的关联删除处理，不能再由关系类型或另一套勾选规则覆盖。
+
+### 3.3 关联策略的边界
+
+- `cascade` 只负责沿已登记关系展开删除清单，不负责判断业务状态；
+- `restrict` 只检查删除清单之外的外部引用；同一批次内也被删除的引用不算外部引用；
+- `none` 不展开、不保护，由配置者明确承担结果；
+- 复杂引用判断使用删除 SQL 规则，不在关系表中增加第二套规则字段。
+
+## 4. 删除 SQL 规则
+
+### 4.1 表职责
+
+第一阶段建议使用专用表 `s_delete_rule`，不再使用泛化的 `s_rule`。这样表名直接说明用途，也避免为未来不存在的规则类型预留抽象。
+
+概念字段如下：
+
+| 字段 | 含义 |
+| --- | --- |
+| `b_id` | 规则主键，应用层生成的雪花 ID |
+| `b_module_id` | 规则所属数据模块编码，`varchar(50)`；只允许模块删除使用 |
+| `b_sql` | 只读查询 SQL |
+| `b_message` | 删除失败时的提示文案 |
+| `b_canuse` | 是否启用 |
+| `b_xh` | 执行顺序 |
+| `b_created_*` / `b_updated_*` | 审计字段 |
+
+不保留以下字段：
+
+```text
+b_scope_type
+b_scope_id
+b_hook
+b_kind
+b_predicate
+```
+
+`s_delete_rule` 不覆盖无模块的直接表删除。技术表如果需要业务保护，由拥有该表的专用服务在调用删除前执行自己的检查；第一阶段不把表名、服务名和模块编码再抽象成一套通用作用域。
+
+### 4.2 SQL 契约
+
+模块删除规则 SQL 只表达“哪些记录不允许删除”：
+
+```text
+返回至少一行 → 规则不通过
+返回零行     → 规则通过
+```
+
+SQL 接收当前模块本次待删除的 ID 集合，统一使用 `:ids` 作为模板标记。它不是 JDBC 命名参数，执行前由删除引擎根据模块主键类型替换为经过校验和转义的字面量 `IN` 列表；第一阶段不引入表值参数或 `OPENJSON`。配置者可以自由使用本模块字段、其他表、聚合、子查询和连接条件。
+
+示例语义：
+
+```sql
+select b_id, b_no
+from cw_receipt
+where b_id in (:ids)
+  and b_status in ('审核中', '已生效')
+```
+
+约定：
+
+- SQL 必须是只读查询；
+- SQL 必须限制在本次 `:ids` 对应的数据范围内；
+- 单次删除 ID 数量设置明确上限，超限直接拒绝，避免生成过大的 SQL；
+- 查询返回的行用于错误样例和日志，不直接执行 SQL 返回的修改意图；
+- `b_message` 第一阶段使用固定文案，不做复杂占位符替换；
+- 多条规则全部属于“禁止条件”，任意一条命中即拒绝整批删除；
+- `b_xh` 只影响执行顺序和错误展示，不改变规则的并集语义。
+
+### 4.3 为什么只保留 SQL
+
+- 不需要维护字段、操作符、常量、分组和 AST 转换；
+- 跨表、聚合和历史业务条件可以直接表达；
+- 后端只需要实现一个 SQL 执行契约；
+- 前端只需要一个 SQL 编辑器和提示文案输入；
+- 未来需要更强的条件能力时，仍可在 SQL 层扩展，不影响表结构。
+
+配置 SQL 不等于允许 SQL 修改数据。删除动作仍由删除引擎统一完成，避免规则之间互相修改数据或破坏事务顺序。
+
+### 4.4 只读校验和执行入口
+
+删除规则不新建一套 SQL 安全判定器，直接复用现有 `DbUtils`：
+
+- `DbUtils.validateReadOnlySql(String)`：校验 SQL 以 `SELECT` / `WITH` 开头，并拒绝分号、注释和写入关键字；
+- `DbUtils.loadDataBySql(Connection, String)`：复用 `saveobjt` 当前事务连接执行查询，并再次走同一只读校验；
+- 删除引擎在替换 `:ids` 后调用上述入口，返回行即视为规则命中。
+
+`SqlPermissionService` 负责动作权限、字段权限和数据范围条件，不作为删除规则 SQL 的只读校验器。若将来需要增强 SQL 解析能力，先扩展 `DbUtils` 的公共入口，不在删除引擎中复制一套正则或解析逻辑。
+
+## 5. 删除引擎
+
+删除引擎分为三个职责，但对前端暴露一个删除动作：
+
+```text
+删除服务
+├── 删除计划器：仅对模块目标展开 cascade，形成模块和记录清单
+├── 删除检查器：仅对模块目标执行 s_delete_rule 和 restrict 检查
+└── 删除执行器：子记录优先，物理删除，提交审计日志
+```
+
+直接表目标不经过前两个组件，经过同一个删除执行器。这样既不漏掉文件、配置表等非模块删除，也不会让直接删除意外触发某个表名猜出来的模块规则。
+
+### 5.1 删除计划
+
+从用户指定的模块和 ID 开始，沿启用的 `cascade` 关系递归展开：
+
+- 同一模块、同一主键只进入清单一次；
+- 关系图出现环路时返回配置错误；
+- 设置最大展开深度，防止错误配置造成无限递归；
+- 记录每个模块将删除的数量，供日志和后续预览使用。
+
+### 5.2 删除检查
+
+对完整删除清单执行：
+
+1. 对每个模块运行启用的 `s_delete_rule`；
+2. 对每条 `restrict` 入边检查外部引用；
+3. 任何规则或关系失败，整批拒绝；
+4. 错误按“模块 SQL 规则 / 外部引用关系”分类返回。
+
+删除清单内的引用方视为本次一起删除，不触发外部引用保护。这是主单、明细和中间表一起删除时的必要语义。
+
+直接表目标没有模块删除清单，因此不执行上述两类检查；它只返回数据库删除错误或专用服务的清理错误。
+
+### 5.3 删除执行
+
+第一阶段不做独立的“预览后确认”两阶段操作。前端可以先弹一次普通确认框，后端在同一个事务中完成计划、检查和删除：
+
+```text
+开启事务
+  → 生成删除清单
+  → 执行 SQL 规则
+  → 执行 restrict 检查
+  → 子记录到主记录物理删除
+  → 写审计日志
+提交事务
+```
+
+任一步骤失败都回滚整批。以后需要删除预览时增加 `dryRun` 调用即可，不能改变正式删除流程。
+
+直接表删除省略“生成删除清单 / SQL 规则 / restrict”三步，但仍在同一事务中执行数据库删除和审计。文件服务的外部对象操作不属于数据库事务：对象删除失败时不删数据库行；数据库删除失败时保留可重试或补偿的清理记录。
+
+## 6. 调用路径
+
+### 6.1 模块列表删除
+
+列表删除通过统一删除服务处理：
+
+```text
+前端传 target=module、moduleCode + ids
+→ 删除计划器
+→ 删除检查器
+→ 删除执行器
+```
+
+前端不再直接为删除拼装 `saveobjt` 的 `deletes` 行。
+
+列表页解析写入目标时只读取 `b_save_table`。现有 `resolveSaveTable()` 中的 `b_save_table || b_view_table` 回退必须删除；`b_save_table` 为空时，所有保存、排序和删除写操作都提示“该模块未配置保存表，无法写入”，后端也必须再次拒绝，不能尝试对视图表执行写入。
+
+### 6.2 `saveobjt` 中删除明细
+
+`saveobjt` 的 `deletes` 分支仍保留原入参格式，但增加一个明确的删除目标类型：
+
+- `target=module`：必须提供 `moduleCode`；后端读取 `s_module.b_save_table` 和单一 `b_key_field`，调用同一删除计划器；`b_save_table` 为空时直接拒绝并返回“模块未配置保存表，无法删除”，不得使用 `b_view_table`；请求携带的 `table` / `key_field` 只能用于兼容和一致性校验；
+- `target=direct`：必须提供 `table` / `key_field`，直接进入物理删除执行器，不做表名到模块的反查；
+- 不允许以“有没有传 `moduleCode`”作为隐式分支。新接口必须明确目标类型，避免调用方漏传模块编码时静默绕过模块规则。
+
+两种目标都：
+
+- 使用 `saveobjt` 当前事务连接；
+- 收集本次请求中所有待删除记录；模块目标再展开 `cascade`，直接表目标不展开关系；
+- 模块目标的同批次内引用不算外部引用；
+- 显式删除和 `cascade` 展开的同一记录按解析后的“表 + 主键字段 + 主键值”去重；同一物理记录同时以模块目标和直接目标提交时直接报冲突，不执行两次；
+- 任一检查失败，主表更新、明细删除和其他变更整体回滚。
+
+这样列表删除和表单删行不会形成两套规则。
+
+### 6.3 文件和其他无模块删除
+
+文件删除继续由 `/file/delete` 负责：按文件主键定位记录，先删除本地文件或 OSS 对象，再以 `target=direct`、`table=bf_files`、`key_field=subid` 删除数据库行。即使 `bf_files.mx_moduleid` 保存了业务模块编码，它也只是文件元数据，不是本次删除策略的模块目标；文件删除不需要 `moduleCode`，也不触发 `s_relation` 或 `s_delete_rule`。
+
+如果某个业务明确要求“宿主单据处于某状态时不能删附件”，由文件服务显式调用宿主模块的 SQL 检查；直接表目标本身不自动反查 `father + mx_moduleid`。
+
+其他没有业务模块的表沿用同样的直接表目标。若一张技术表存在自己的依赖清理，清理由该表所属服务显式完成；删除策略引擎不根据表名猜测级联关系。
+
+## 7. 前端配置入口
+
+模块管理的业务能力建议调整为：
+
+```text
+数据行为
+├── 删除策略
+│   ├── 关联删除处理
+│   └── 删除 SQL 规则
+└── 自动编码
+```
+
+“模块关联”可以继续作为关系字段映射的维护面板，但删除行为只能有一个编辑来源。若删除策略页面展示关联行，则模块关联页面中的删除行为列改为只读或跳转。
+
+删除 SQL 规则面板只需要：
+
+- 新增、编辑、删除、启用/停用；
+- SQL 文本编辑器；
+- 固定提示文案；
+- 执行顺序；
+- 最近修改信息。
+
+删除以下旧概念和前端联动：
+
+```text
+勾条件
+引用规则
+refRules
+relationScopeId
+b_scope_type
+b_scope_id
+b_hook
+```
+
+同时必须删除现有实现中的以下联动，否则后端允许配置 `cascade` 也不会生效：
+
+```text
+ModuleRelationPanel.vue：b_on_delete 编辑器的 isManyToOne disabled
+ModuleRelationPanel.vue：onCellChange 中多对一重置 none 的分支和 Message.warning
+ModuleRelationPanel.vue：_hasRefRule、setRefRule 及关系键变更时清理引用规则的逻辑
+FmsModuleListPage.vue：resolveSaveTable() 对 b_view_table 的删除回退
+```
+
+`b_on_delete` 列可以继续显示在模块关联维护面板，但只能作为删除策略的同一份数据来源；不能同时保留一套只读/勾选/自动重置逻辑。
+
+## 8. 错误、日志和权限
+
+- SQL 规则命中时返回规则文案、所属模块、命中数量和少量样例 ID；
+- `restrict` 命中时返回引用模块、引用字段和样例引用记录；
+- 批量删除只返回聚合后的错误，避免逐行刷屏；
+- 规则的新增、修改、删除沿用模块配置权限；
+- SQL 文本、参数、命中行数和请求标识写入技术日志；
+- 直接表删除记录表名、主键字段、数量和请求来源；按明确的目标类型标记为 `direct`，便于审计和排查；
+- 规则停用使用 `b_canuse = 0`，删除规则本身才做物理删除并记录审计；
+- 没有登记到 `s_relation` 的引用不在自动保护范围内，这属于元数据配置边界。
+
+## 9. AI 实施顺序
+
+### 第一阶段：元数据和脚本
+
+1. `s_relation` 确认 `b_on_delete` 三值和默认 `restrict`；
+2. 删除旧 `s_rule` 结构，建立 `s_delete_rule`；
+3. 同步核心建表脚本和增量脚本；
+4. 不加入任何归档字段。
+
+### 第二阶段：后端
+
+1. 实现删除计划器；
+2. 实现 SQL 规则检查器，复用 `DbUtils.validateReadOnlySql` 和 `DbUtils.loadDataBySql(Connection, String)`，不新建第二套只读判定器；
+3. 实现 `restrict` 外部引用检查；
+4. 实现子记录优先的物理删除执行器；
+5. 定义 `target=module/direct` 两种删除目标，接入列表删除入口和 `saveobjt` 删除分支；
+6. 加入事务回滚、环路检测、日志和错误聚合。
+
+### 第三阶段：前端
+
+1. 删除条件 AST、引用规则和旧作用域逻辑；
+2. 将规则编辑器改为 SQL 编辑器；
+3. 删除规则面板与模块关联面板收敛为“删除策略”入口；
+4. 删除 `ModuleRelationPanel.vue` 的多对一 `b_on_delete` 禁用、重置、警告和 `_hasRefRule` 联动；
+5. 删除 `FmsModuleListPage.vue` 的 `b_view_table` 删除回退，空 `b_save_table` 时拒绝删除；
+6. 列表删除改为调用统一删除接口；
+7. 更新相关测试。
+
+### 第四阶段：验收
+
+- 单条删除成功；
+- 批量删除成功；
+- SQL 命中时整批拒绝；
+- `restrict` 外部引用生效；
+- `cascade` 子记录全部删除；
+- 多层级联按子到父顺序删除；
+- 关系环路被拦截；
+- `saveobjt` 中模块目标与列表删除使用相同规则，直接目标不触发模块检查；
+- 文件和其他无模块表可以走直接删除路径；
+- 任一失败都能完整回滚。
+
+## 10. 后续扩展边界
+
+后续增加归档时，只增加新的关联处置值和对应执行器；不改变 SQL 规则的“返回行即拦截”语义。
+
+后续增加“审核后不能修改”“保存前校验”“自动冲销”等能力时，重新评估是否需要新的策略表或服务，不在本次设计中预留 `b_hook` 或通用规则字段。
diff --git a/code/fms/FMS删除规则引擎设计.md b/code/fms/FMS删除规则引擎设计.md
deleted file mode 100644
index c2527f66..00000000
--- a/code/fms/FMS删除规则引擎设计.md
+++ /dev/null
@@ -1,335 +0,0 @@
-# FMS 删除规则设计
-
-> 版本：v2.0（取代 v1）。关联：`FMS新系统核心表结构设计.md`（§9 模块关系）、`FMS模块设计评审.md`。
-> 一句话：**删之前先查一查，查不过就拒绝；查什么、怎么查，由 IT 配置，不写代码。**
->
-> v2 相对 v1 的变化（动因见 `FMS模块设计评审.md` 问题一/问题三）：
-> - **引用规则退出 `s_rule`**：原「勾引用」由 `s_relation.b_on_delete = 'restrict'` 表达，关系面板只配一列；
-> - **`s_rule` 收敛为模块级**：去掉 `b_scope_type`、`b_scope_id`（拼接串）、`b_hook`，加 `b_kind` 显式区分勾条件与写 SQL；
-> - **方向语义统一**：四个取值都描述「删除**被引用方**时，**引用方**怎么办」，被引用方由基数判定，不再有删源/删目标两套口径；
-> - **默认值 `restrict`**：被引用即不可删成为默认，多数关系零配置。
-> - 库中无存量数据，全部按新结构直接建，不做迁移。
-
-## 这个设计解决什么问题
-
-业务上「能不能删」的规矩五花八门：
-
-- 单据还在审核中，不许删
-- 已经销账了，不许删
-- 核销过钱的，不许删
-- 费用已经做到账单里了，不许删
-- 删报销单时，下面的费用明细要跟着一起删
-
-以前这些规矩要么写死在代码里（改一条要发版），要么干脆没有（误删了才发现）。现在的做法：**IT 在界面上配置，配完立即生效**。
-
-规矩分两类，配在两个地方：
-
-- **记录自身什么状态不许删** → 模块上配「删除规则」（勾条件 / 写 SQL）；
-- **被别人引用着不许删、删主单连带删明细** → 关系上选一个「删除行为」（一列四值，默认即防护）。
-
-## 1. 整体图景
-
-一个用户点「删除」，系统背后做四件事：
-
-```
-1. 找出连带要删的记录(删报销单 → 连费用明细一起)
-2. 把配置的所有删除规则挨条查一遍
-3. 任何一条不过 → 整批拒绝,告诉用户为什么
-4. 全过 → 先弹预览给用户确认,再一个事务里一起删
-```
-
-IT 要做的事只有两件：模块上**配条件规则**，关系上**选删除行为**。配的地方都在模块管理。
-
-## 2. 模块规则：一条就是一句「什么情况不许删」
-
-每条规则就是一句话：
-
-> **当【什么条件】时，不许删，提示【什么话】**
-
-规则有两种写法，按配的难度从易到难：
-
-### 2.1 勾条件（日常用这个，占绝大多数）
-
-在模块管理 → 「删除规则」tab 点「新增规则」，弹出来的界面和**查询配置长得一样**：
-
-```
-满足以下条件时,不许删除:
-┌──────────┬────────┬─────────────────┐
-│ 字段      │ 操作符  │ 值              │
-│ 单据状态   │ 属于    │ [审核中, 已生效] │
-│ 已销账    │ 等于    │ 1               │
-└──────────┴────────┴─────────────────┘
-```
-
-- 字段下拉就是该模块字段定义里的字段
-- 值可以直接填，也可以选另一个字段比（比如「已核销金额 大于 0」）
-- 提示文案**不用写**——系统自动生成「单据 SKD-2026-001 状态为审核中，不能删除」
-
-会配查询条件的人，零学习成本。
-
-### 2.2 写 SQL（兜底，藏在角落）
-
-界面勾不出来的判断——比如「核销金额加起来大于 0」这种要查别的表的——在规则类型的「高级」选项里直接写一句 SQL：
-
-```sql
-select b.b_id, b.b_no from bill b
-join bill_detail d on d.bill_id = b.b_id
-where b.b_id in (:ids) and d.writeoff > 0
-```
-
-约定就两条：`:ids` 会自动换成当前删的这批单据的 id；**查出来有结果就拦**。提示文案自己填，可以 `{b_no}` 这样引用查询结果的列。
-
-平时用不到，会写的人自己找得到，不会打扰别人。谁改过这条 SQL、每次执行了什么，系统日志里全程有记录（内部系统，不做限制，只做留痕）。
-
-（v1 的「勾引用」一节取消——引用保护挪到关系上，见 §3。）
-
-## 3. 关系上的删除行为：`s_relation.b_on_delete`（一列四值）
-
-统一语义：**删除「被引用方」记录时，「引用方」记录怎么办。**
-
-谁是"被引用方"由基数决定，不需要额外配置：
-
-| 基数 | 外键在 | 被引用方 |
-| --- | --- | --- |
-| `many_to_one` | 源字段 | 目标 |
-| `one_to_many` | 目标字段 | 源 |
-| `one_to_one` | 目标字段（约定） | 源 |
-
-四个取值：
-
-| 值 | 含义 | 典型场景 |
-| --- | --- | --- |
-| `restrict`（**默认**） | 仍有引用方记录时，拒绝删除被引用方 | 费用→客户：客户被费用引用，删不掉 |
-| `cascade` | 引用方记录一起物理删除 | 报销单→费用明细：删单连带删明细 |
-| `archive` | 引用方记录打归档标记，不物理删 | 删报销单，明细归档供账单追溯 |
-| `none` | 不处理 | 日志→用户等确实无关的关联 |
-
-几个例子（源→目标按基数标注被引用方）：
-
-| 关系 | 基数 | 被引用方 | b_on_delete | 效果 |
-| --- | --- | --- | --- | --- |
-| 费用 → 客户 | many_to_one | 客户 | restrict（默认） | 客户被费用引用时删不掉 |
-| 费用类型 → 费用 | one_to_many | 费用类型 | restrict（默认） | 类型下有费用时删不掉 |
-| 报销单 → 费用明细 | one_to_many | 报销单 | cascade | 删报销单连带删明细 |
-| 报销单 → 费用明细（归档版） | one_to_many | 报销单 | archive | 删报销单，明细归档可追溯 |
-
-设计要点：
-
-- **默认即防护**：新关系默认 `restrict`，「主数据被引用不许删」这类最通用的规矩零配置；确实要放开才显式改 `none`。安全方向从「记得配防护」反转为「记得放开」
-- **一列取代原来的三个栏位**：v1 的 `b_on_delete`（三值）+「有引用时拒绝删除」勾选（假列，实际生成 `s_rule` 行）+ 方向口径混用，合并为**一个真列**
-- **取值即语义，无非法组合**：v1 可同时配出「cascade + 引用规则」（连带删但又不许删，自相矛盾）；单列四值后该组合在类型层面不存在
-- **基数不禁取值**：是否 `cascade` 是「被引用方是否独占拥有引用方」的业务判断，只有配置者知道；把 `cascade` 配在共享主数据的关系上属于配置错误，系统不做基数层面的硬拦（内部系统，配置留痕即可），界面在选 `cascade` / `archive` 时给出确认提示
-- **`archive` 前提**：引用方表需有 `b_archived` + `b_archive_datetime` 通用列，保存时服务层校验列存在
-
-连带展开的关键行为：
-
-- **查连带时也过规则**：删报销单连带要删费用明细，但费用明细被账单明细引用（restrict 入边）→ 整个删除（包括报销单）被拒绝，提示定位到那笔明细和那个账单
-- **一荣俱荣一损俱损**：任何一条卡住，整批都删不了，不存在删一半的中间状态
-- 关系套关系（单→明细→附件）会自动一层层找下去；层数太多（比如配置成了环）会直接报配置错误，不会死循环
-
-## 4. 删除的操作流程（业务用户视角）
-
-列表页勾几行点删除，系统**先预览后真删**：
-
-```
-第一步:系统先算一遍
-   ↓ 有问题?  → 弹错误列表:「这 3 条审核中删不了」「这笔费用被账单引用」
-   ↓ 没问题?  → 弹确认框:「将删除 1 张报销单 + 3 条费用明细,确认?」
-
-第二步:用户确认后才真删(删之前系统再快速查一遍,防止确认的几秒里有变化)
-```
-
-错误提示都是人话，不用猜。批量删 500 行时提示按规则归类显示，不会刷屏。
-
-## 5. 配置入口在哪
-
-**配规则**（IT 日常）：
-
-- 模块管理 → 「删除规则」tab → 新增：模块级条件规则，每条 3 个格子一分钟；改完立即生效，**不用发版**
-- 模块管理 → 「模块关联」tab → 每条关系一列「删除行为」，默认"被引用时禁止删除"；主子表关系显式选「连带删除」或「连带归档」
-- 常见条件规则可以**复制到其他模块**（多选目标模块批量克隆）——v2 起全部规则都是模块级、结构同构，无例外；复制时校验目标模块存在条件里用到的字段，缺字段的目标模块在确认框里点名
-
-**看全貌**（排查、盘点）：
-
-- 系统管理 → 「业务规则」：全系统所有模块级规则的列表——哪个模块的、什么类型、谁最后改的、什么时候。点行跳到对应模块
-- 排查「这单为什么删不掉」：错误提示里带规则内容 → 全局列表找到它 → 看条件/SQL → 完事；被引用拦下的，提示里直接带引用方单号和关系来源
-
-**谁可以配**：规则的增删改走权限控制（和菜单权限同体系）。看规则不受限。
-
-## 6. 数据落库（给开发看的部分）
-
-### 6.1 s_relation：删除行为列
-
-权威表结构见 `FMS新系统核心表结构设计.md` §9，本节只列差异：
-
-```sql
-alter table dbo.s_relation add
-    b_on_delete varchar(20) not null default 'restrict';
-    -- restrict(默认) 被引用时禁止删除 / cascade 连带删除 / archive 连带归档 / none 不处理
-```
-
-- 语义、取值、被引用方判定见本文 §3
-- `archive` 由服务层校验引用方表存在 `b_archived` / `b_archive_datetime` 列
-- 引擎读取时只认 `b_canuse = 1` 的关系行
-- 库中无存量数据，不需要从 v1 的 `none` 默认值做迁移；`fms_core.sql`、`fms_delete_rule.sql` 脚本需按本结构同步（现脚本默认值仍是 `none`）
-
-### 6.2 s_rule：模块级规则表（v2 结构）
-
-```sql
-create table dbo.s_rule (
-    b_id           bigint       not null,          -- 雪花主键（新增时前端经 /data/nextid 取号）
-    b_module_id    varchar(50)  not null,          -- 所属模块编码
-    b_kind         varchar(20)  not null,          -- condition 勾条件 / sql 写 SQL
-    b_predicate    nvarchar(max) not null,         -- condition=JSON AST（§6.3）；sql=SQL 文本
-    b_message      nvarchar(500) null,             -- condition 可留空（引擎按条件自动生成）；sql 必填
-    b_canuse       tinyint       not null default 1,
-    b_xh           int          not null default 0,-- 执行顺序（并列按 b_xh、b_id）
-    b_created_by   varchar(50)  null,              -- 审计列由服务端维护，配置界面不提交
-    b_created_at   datetime2    null,
-    b_updated_by   varchar(50)  null,
-    b_updated_at   datetime2    null,
-    primary key (b_id)
-);
-
-create index ix_s_rule_module on dbo.s_rule (b_module_id, b_canuse, b_xh);
-```
-
-相对 v1 的变化与理由：
-
-- **去掉 `b_scope_type` / `b_scope_id`**：规则只挂模块，`b_module_id` 直存模块编码。v1 的拼接串键（`源模块|源字段|目标模块|目标字段`）随之消失——它无法有效索引、无法校验、编码含 `|` 时错位，是明确的反模式
-- **去掉 `b_hook`**：一期只有 `delete.pre` 一种挂点，单值枚举列属过早抽象（`开发规范.md`「为真实出现的第二个使用方而抽象」）；将来做 save.pre 时再按当时的真实需求定表形态
-- **加 `b_kind`**：v1 靠 `b_predicate` 三态推断（空=引用 / `{` 开头=JSON / 其余=SQL），判别依据靠猜且依赖「SQL 不以 `{` 开头」这个未声明约定；显式一列后判别依据存在数据里
-- `b_xh` 保留：多条规则任一不过即拒绝，顺序不影响结论，但决定错误提示的展示顺序，也支持「便宜的勾条件规则排前、贵的 SQL 规则排后」的执行优化
-
-其他要点：
-
-- **模块上没有任何规则 = 该模块不受条件约束**（引用保护仍由关系默认值兜着）
-- 错误类型不用存——勾条件报「状态不符」、写 SQL 报自定义文案，写法本身决定了报什么
-- **删模块时，服务层把挂着的规则一起删掉**（`where b_module_id = …`，单条件直查，与字段、权限点同一套清理逻辑，全系统本来就不建物理外键）
-- 删规则 = 物理删 + 日志记全文；临时不想用某条规则 → 停用（`b_canuse=0`），不删
-
-### 6.3 勾条件那部分的格式（JSON，界面生成，人不手写）
-
-```json
-{ "kind": "dsl", "expr":
-    { "and": [
-        { "in": [ { "field": "b_status" }, { "const": ["draft", "rejected"] } ] },
-        { "eq":  [ { "field": "b_settled" }, { "const": 0 } ] }
-    ] }
-}
-```
-
-开发注意三条：
-
-- 只能引用本模块的字段（想跨表？去写 SQL 规则），后端翻译成**参数化 SQL**，没有注入风险
-- 常量按字段类型校验（数字/日期/文本），和查询配置的校验规则共用一套
-- 防手滑：条件嵌套最多 8 层、最多 100 个节点（界面上分组最多 3 层，比后端还紧）
-
-### 6.4 后端删除流程
-
-**引擎拆成两个部件：检查器 和 执行器**。执行器管连带和真删；检查器只查规则（一个方法：`check(连接, 模块, ids, 小闭包)`）。两个入口共用同一个检查器：
-
-```
-删除(模块, ids, 是否预览):
-
-  ① 执行器找连带:从这批 ids 出发,沿 b_on_delete ∈ {cascade, archive}
-     且 b_canuse=1 的关系,把引用方记录一层层装进删除清单
-     (被删的是被引用方;已装过的跳过——防关系成环;超过10层报配置错误)
-
-  ② 检查器查规则:
-     模块条件:清单内每个模块的 s_rule(b_canuse=1) 逐条执行
-        勾条件 → 按条件查清单内记录,不符的记一条错误(带实际值)
-        写SQL  → 拿清单内该模块的 id 跑那条 SQL,查出结果每行记一条错误(全程写日志)
-     引用保护:对清单内每条记录,查它作为「被引用方」的 restrict 入边
-        (b_on_delete='restrict' 且 b_canuse=1 的关系)
-        引用方存在、且引用方不在清单内 → 记错误(带引用方单号)
-
-  ③ 有错误 → 整批拒绝,返回错误列表(按规则归类,每类带数量和前几条示例)
-  ④ 全过 → 只是预览?返回"将删除 X 张单 + Y 条明细"摘要
-            真删?→ 开事务:再快速过一遍规则(防确认间隙有变化)
-                    → 归档的打标记 → 按先子后父的顺序物理删
-                    → 记审计日志(按删的这一批记一条 + 明细)
-```
-
-开发注意：
-
-- 查库全部按批 IN，不逐行循环
-- ids 数量不设上限——引擎内部把整批 id 装成一个数组参数（`OPENJSON`），不受绑定变量 2100 个的限制
-- 真删前在事务里重查一遍规则（预览的通过**不算数**），防确认的几秒里有人改了规则或新增了引用
-- 写 SQL 规则的每次执行：实际 SQL + 参数 + 结果行数都写进技术日志，关联本次请求——排查「为什么删不掉」从错误提示一路能追到原始 SQL
-
-### 6.5 saveobjt 保存时删行，规则同样生效（重要）
-
-**问题**：海运编辑这类主子表表单，保存走通用接口 `saveobjt`——前端把主表 + 子表（费用）的增删改 diff 成一个请求数组，一个事务提交。用户在表单里删掉一行费用，就是请求数组里子表的 `deletes` 段。**这条删除路径如果不过规则，配置就白配了**——列表页删除被拦，表单里删行却畅通无阻。
-
-**接法**（对前端完全透明，入参不变）：
-
-```
-DataSaveService.saveTable() 的 delete 分支,执行真删之前:
-
-  ① 按表名反查模块(b_savetable = 这张表的 data 模块);查不到模块(如日志表)→跳过
-  ② 该模块挂有规则、或它的记录存在 restrict 入边关系 → 调检查器,
-     传当前 connection(同一个事务!) + 待删的这批行
-  ③ 任一规则不过 → 抛 BusinessException(文案就是规则生成的提示)
-      → 整个 saveobjt 回滚——主表的修改和子表的删除一起回滚,
-        用户的前端草稿还在,知道哪行费用删不掉、为什么
-  ④ 无规则或全过 → 照常执行 deletes
-```
-
-三个关键点：
-
-- **同事务检查**：检查器用的就是 saveobjt 自己的 connection——表单里先改了主表状态、再删子表行，规则查到的是**改过之后**的值，不会出现「检查用旧数据、删的是新数据」的错位
-- **小闭包语义**：检查 restrict 时，要把「本次 saveobjt 所有 deletes 覆盖的记录」当作一个小闭包——引用方也在被删之列就不算外部引用。场景：删主单连带删子表行（前端编排的），子表对主单的引用指向一个同批正在删除的记录，不该拦。实现：把请求数组里所有 deletes 的 id 收集起来传给检查器
-- **不需要预览**：表单保存是「保存」动作，用户预期就是要么全成功要么报错，不做两阶段确认
-
-### 6.6 接口
-
-```
-POST /data/deleteobj
-{
-    "moduleCode": "receipt",
-    "ids": [1, 2, 3],
-    "dryRun": true          // true=只预览(前端删除按钮的第一步)
-}
-
-POST /data/saveobjt         // 不变,deletes 分支内部自动走规则检查
-```
-
-## 7. 其他约定
-
-- **字段联动**：条件规则里用了的字段，删除该字段时会被拦住并提示规则内容——不让规则悄悄失效
-- **配置权限**：改规则要权限点（如 `rule.edit`），和菜单权限同一套体系；SQL 不限制内容，但改它的人必须有配置权限
-- **归档标记**：`archive` 要求引用方表有通用列 `b_archived` + `b_archive_datetime`（配归档时服务层校验列存在）；通用查询默认不显示已归档行
-- **将来扩展**（二期再议，**不留列**，届时按真实需求定表形态）：
-  - 「已审核的单不能**改**」——形态未必与删除规则同构，到时候再决定复用还是另起
-  - 「删之前先自动红冲」这种要执行动作的——预留挂 Java 代码的口子
-  - 核销总额想在列表上显示成列——展示需求，单独做，跟删除无关
-- **已知边界**：restrict 只覆盖 `s_relation` 里**登记过的**引用；没登记关系的表（日志、迁移脚本写的表）不在保护范围内。这是配置边界，不是数据库级引用完整性，文档与培训材料里要写明
-
-## 8. 开工顺序
-
-1. 建表：`s_relation` 加 `b_on_delete`（四值、默认 `restrict`）；`s_rule` 按 §6.2 新结构建；同步重写 `fms_core.sql`、`fms_delete_rule.sql`（现脚本仍是 v1 结构）
-2. 后端：条件（JSON → 参数化 SQL）+ 检查器 + 执行器（连带展开 → 规则 → 事务删除）
-3. **saveobjt 接入检查器**：delete 分支反查模块 → 同事务规则检查 → 不过整体回滚（见 §6.5）
-4. 错误提示：条件自动生成人话 + 字段格式化（金额带 ¥、日期带格式）+ SQL 占位符填充
-5. 前端：关联面板一列化（去掉「有引用时拒绝删除」假列及其全部联动补丁）、规则面板收敛（去掉引用规则只读区与跳转）、列表删除先预览后确认、错误列表展示
-6. 二期：save.pre、Java 钩子、聚合展示
-
-## 9. 定案记录
-
-| # | 事项 | 结论 | 版本 |
-| --- | --- | --- | --- |
-| 1 | 节奏 | 一期只做删除规则；保存校验二期再议，不留 `b_hook` 列 | v2 修订 |
-| 2 | 跨表判断 | 不做计算字段，直接写 SQL 兜底 | v1 |
-| 3 | SQL | 兜底逃生舱：不限制内容、不做体验优化、入口藏角落；**每次执行全程写日志** | v1 |
-| 4 | 引用保护 | **`s_relation.b_on_delete='restrict'`（默认）表达，不进 `s_rule`**；删关系时规则随之消失，无孤儿清理 | v2 修订 |
-| 5 | 归档 | 通用列 `b_archived` + `b_archive_datetime` | v1 |
-| 6 | 条件规模 | 嵌套 ≤ 8 层、节点 ≤ 100；界面分组 ≤ 3 层 | v1 |
-| 7 | 规则类型 | **显式 `b_kind` 列（condition / sql）**，不靠 `b_predicate` 首字符推断 | v2 修订 |
-| 8 | 级联清理 | 删模块时服务层连带删 `s_rule`（`b_module_id` 单条件直查）；关系级规则不复存在 | v2 修订 |
-| 9 | 批量 | ids 不设上限；整批一个数组参数（OPENJSON） | v1 |
-| 10 | 复制 | **全部规则可多选模块批量克隆**（v2 起无引用规则例外）；复制时校验目标模块存在条件所用字段 | v2 修订 |
-| 11 | saveobjt 集成 | 引擎拆检查器/执行器；saveobjt 的 deletes 分支同事务调检查器，不过则整批回滚（§6.5）；前端入参不变 | v1 |
-| 12 | 方向语义 | 四值统一描述「删除被引用方时引用方怎么办」；被引用方由基数判定（§3） | v2 新增 |
-| 13 | 默认值 | `restrict`：被引用即不可删为默认，放开需显式改 `none` | v2 新增 |
-| 14 | 存量迁移 | 库中无数据，直接按新结构建表，不做转换 | v2 新增 |
diff --git a/code/fms/FMS删除规则改造待做.md b/code/fms/FMS删除规则改造待做.md
deleted file mode 100644
index 2474a5a6..00000000
--- a/code/fms/FMS删除规则改造待做.md
+++ /dev/null
@@ -1,73 +0,0 @@
-# FMS 删除规则改造待做
-
-> 创建：设计阶段已闭合、实施未开始。明日开工照此清单执行。
-> 设计依据：`FMS删除规则引擎设计.md` **v2.0**（权威实现规格）、`FMS模块设计评审.md` v1.2（决策记录）。
-> 前提确认：库中无存量规则/关系数据（`sql/` 种子脚本中 `s_relation` 零 insert），**全部按新结构直接建，不做迁移**。
-
-## 已定案的设计决策（不需要再讨论）
-
-| # | 决策 | 出处 |
-| --- | --- | --- |
-| 1 | `s_relation.b_on_delete` 单列四值：`restrict`（默认）/ `cascade` / `archive` / `none`；语义统一为「删除**被引用方**时，**引用方**怎么办」；被引用方由基数判定（many_to_one=目标 / one_to_many=源 / one_to_one=源） | 删除规则 v2.0 §3 |
-| 2 | 引用保护退出 `s_rule`，由 `b_on_delete='restrict'`（默认）表达；「有引用时拒绝删除」假列及全部联动补丁删除 | 删除规则 v2.0 §3 |
-| 3 | `s_rule` 新结构：`b_module_id` 直存、显式 `b_kind`（condition/sql）、去掉 `b_scope_type`/`b_scope_id`/`b_hook` | 删除规则 v2.0 §6.2 |
-| 4 | 中间表模块挂业务域 `module` 节点下、与主表模块平级（规范已写入核心表结构设计 §4.3） | 评审 v1.2 问题四 |
-| 5 | 模块管理分节改为「数据行为 / 访问控制」，只改 `configGroups` 分组，面板/路由/数据不动；与删除规则前端改造同批实施 | 评审 v1.2 问题二 |
-
-## 待做清单（按执行顺序）
-
-### ① 重写 SQL 脚本 —— 对应设计 v2.0 §6.1 / §6.2
-
-现状：两个脚本还是 v1 结构（`b_on_delete` 默认 `none` 三值、`s_rule` 带 `b_scope_type`/`b_scope_id`/`b_hook`）。
-
-- [ ] `sql/fms_delete_rule.sql` 重写：
-  - `s_relation.b_on_delete`：四值，**默认 `'restrict'`**（现脚本 L18 默认是 `'none'`）
-  - `s_rule` 按新结构重建：`b_module_id varchar(50) not null`、`b_kind varchar(20) not null`（condition / sql）、`b_predicate not null`、`b_message`、`b_canuse`、`b_xh`、审计四列；去掉 `b_scope_type`/`b_scope_id`/`b_hook`
-  - 索引：`ix_s_rule_module on s_rule (b_module_id, b_canuse, b_xh)`
-  - 保留脚本头「可重复执行」说明与执行方式注释
-- [ ] `sql/fms_core.sql` 同步：L208 的 `b_on_delete` 注释与默认值、L228-256 的 `s_rule` 段整体替换（与 `fms_delete_rule.sql` 保持一致，注意两脚本职责分工——core 建全表、delete_rule 只做本特性增量，按现有模式来）
-- [ ] 建表 SQL 的 `b_archived` / `b_archive_datetime` 通用列暂不加——它是 `archive` 行为的**运行时前提**（引用方表需有此列），到后端实现时再决定加在哪些业务表
-
-### ② 后端引擎 —— 对应设计 v2.0 §6.4 / §6.5 / §6.6
-
-- [ ] 新建 `DeleteRuleChecker`（检查器）：`check(connection, 模块, ids, 小闭包)`
-  - 模块条件：清单内每个模块的 `s_rule`（`b_canuse=1`）逐条执行；condition → JSON AST 翻译参数化 SQL（AST 格式见 §6.3，嵌套 ≤8 层、节点 ≤100）；sql → `:ids` 替换（OPENJSON 数组参数，绕开 2100 绑定变量上限），查出有结果即记错误，**全程写技术日志**（实际 SQL+参数+行数）
-  - 引用保护：清单内每条记录查它作为被引用方的 `restrict` 入边（`b_on_delete='restrict'` 且 `b_canuse=1`），引用方存在且不在清单内 → 记错误（带引用方单号）
-- [ ] 新建 `DeleteRuleExecutor`（执行器）：从 ids 出发沿 `b_on_delete ∈ {cascade, archive}` 的关系逐层展开删除清单（被删的是被引用方；已装过跳过防环；超 10 层报配置错误）
-- [ ] `DataController` 加 `POST /data/deleteobj`：`{ moduleCode, ids, dryRun }`；dryRun 返回「将删除 X + Y」摘要；真删开事务**重跑检查**（预览通过不算数）→ archive 打标记 → 先子后父物理删 → 审计日志
-- [ ] `DataSaveService.saveTable()` delete 分支接入（§6.5，**重要**）：
-  - 真删前按表名反查模块（`b_savetable`），查不到跳过（日志表等）
-  - 同事务调检查器；**小闭包语义**：本次 saveobjt 所有 deletes 覆盖的 id 传给检查器，引用方也在被删之列不算外部引用
-  - 不过 → 抛 BusinessException → 整个 saveobjt 回滚
-- [ ] 错误消息生成：condition 自动生成人话（带实际值 + 字段格式化：金额 ¥、日期格式）；sql 规则用 `b_message` 的 `{列名}` 占位符填充；错误按规则归类、每类带数量和前几条示例
-
-### ③ 前端改造 —— 对应设计 v2.0 §8 步骤 5 + 评审问题二
-
-- [ ] `ModuleRelationPanel.vue`：删除相关从三栏位（`b_relation_type` / `b_on_delete` / `_hasRefRule`）收敛为 `b_relation_type` + `b_on_delete`（四值下拉，默认 restrict）
-  - 删掉：`_hasRefRule` 假列、`setRefRule`、改关系主键时作废旧键规则及提示（L326-334）、填不全四列禁用 checkbox
-  - `many_to_one` + `cascade` 不再界面禁用，改保存校验拦截（对齐「校验落后端」原则——若后端引擎做此校验，前端可只做提示）
-- [ ] `ModuleRulePanel.vue`：去掉引用规则只读区 + `navigate` 跳转；列表只剩模块级规则（condition / sql）
-- [ ] `ModuleRuleEditModal.vue` + `ruleUtils.js`：
-  - `parseRulePredicate` 三态推断改两态（读 `b_kind`，不再看首字符 `{`）
-  - 删掉 `relationScopeId` / `parseRelationScopeId` / `isCompleteRelationKey` / `REF_RULE_HINT` / `createRefRuleRow` / `RULE_SCOPE_RELATION`
-  - `createRuleRow` 带 `b_kind`；新增默认 `condition`
-- [ ] `module-management/index.vue`：
-  - 删 `refRules` / `refRules_org` / `refRulesReverse` 三组数据及加载、diff、清理逻辑（L875-898 关系级规则清理段改为只清模块级）
-  - `configGroups` 分节调整：「数据行为 → 模块关联(含删除行为) / 删除规则 / 自动编码」「访问控制 → 权限」；section key 不动
-- [ ] `FmsModuleListPage.vue` `deleteSelected`（L877）：直删改两步——先 `deleteobj dryRun=true`，有错误弹错误列表，无错误弹确认框（含连带摘要），确认后真删
-
-### ④ 验收检查
-
-- [ ] 全局搜索无旧导出残留：`relationScopeId`、`createRefRuleRow`、`REF_RULE_HINT`、`b_scope_type`、`b_scope_id`、`_hasRefRule`、`setRefRule`
-- [ ] `pnpm check`（lint + fmt + build）通过
-- [ ] 跑受影响模块的前端测试；`ruleUtils` / 面板相关 spec 按新契约更新（测试约定见 `fms-vue/tests/README.md`：文件同名、中文用例名）
-- [ ] 后端：`mvnw test`；引擎核心逻辑（检查器翻译、闭包语义、环检测）补测试
-- [ ] 手工链路验证：配一条「审核中不可删」→ 列表删被拦（人话提示）→ 表单里删行同样被拦（saveobjt 回滚）→ cascade 关系连带展开预览 → restrict 默认生效
-
-## 注意事项（动工前再读一遍）
-
-1. **`sql/fms_delete_rule.sql` 现有 L22 是 `drop table if exists s_rule`**——虽然确认无数据，重写后仍保留 drop+create 模式，但执行前先 `select count(*)` 确认一次
-2. 规则引擎是**当前最大缺口**：现在界面上配的删除规则完全不生效（后端 `s_rule` 相关零实现）。②完成后配置才有意义，①③可以和②并行
-3. 执行 SQL 用 `RunSqlFile`：`java -cp "tools/migration/mssql-jdbc-13.4.0.jre11.jar" tools/migration/RunSqlFile.java ../sql/fms_delete_rule.sql --dry-run` 先 dry-run
-4. 改前端遵守 `开发规范.md`：改前先读、最小修改、不为兼容旧名留转发别名（调用方可控，直接迁移删旧代码）
-5. `s_rule` 主键仍是雪花 `b_id`（前端 `nextIdApi` 取号，与业务表一致）；**配置表不用 nextIdApi 的规则是「模块配置表用业务键」**——`s_rule` 无天然业务键，属例外（v2.0 §6.2 已注明）
diff --git a/code/fms/FMS模块关系与权限边界重构计划.md b/code/fms/FMS模块关系与权限边界重构计划.md
new file mode 100644
index 00000000..d416e8b0
--- /dev/null
+++ b/code/fms/FMS模块关系与权限边界重构计划.md
@@ -0,0 +1,547 @@
+# FMS 模块关系与权限边界重构计划
+
+> 状态：草案，供评审
+>
+> 目标：明确模块树、菜单绑定、数据关系、权限和删除策略的边界，降低“模块关联”配置的理解成本，避免一个关系表同时承担多种语义。
+
+## 一、结论先行
+
+“模块关联”不应该同时承担菜单授权、模块父子关系、业务数据关系和删除规则。
+
+本次计划采用以下分工：
+
+| 问题 | 权威数据 | 说明 |
+| --- | --- | --- |
+| 模块业务组织层级 | `s_module.b_parent_id` | 表达业务域、模块分组和权限上下文边界 |
+| 菜单导航层级 | `s_menu.b_parent_id` | 表达目录、页面和外链的导航树 |
+| 菜单使用哪些模块 | `s_menu_module` | 菜单与模块的多对多绑定，保存明确的模块清单 |
+| 用户拥有哪些权限 | `s_power`、`s_user_power` | 模块访问、业务动作和菜单入口权限 |
+| 数据字段之间的引用关系 | `s_relation` | 只表达模块字段之间的结构关系 |
+| 删除前的业务限制 | `s_delete_rule` | 用只读 SQL 检查状态、单据和跨表条件 |
+| 关联记录如何处置 | 删除策略 | `restrict`、`cascade`、`none`，不参与菜单权限计算 |
+
+因此：
+
+1. **菜单权限不需要依赖 `s_relation`。**
+2. **模块父子关系使用 `s_module.b_parent_id`，不从字段关系推导。**
+3. **`s_relation` 建议保留为“数据关系”，但不再称为菜单权限意义上的模块关联。**
+4. **删除策略继续存在，但从数据关系的菜单中剥离，统一放到删除策略入口。**
+
+当前设计文档已经有这几张表的雏形：模块树使用 `s_module.b_parent_id`，菜单绑定使用 `s_menu_module`，数据关系使用 `s_relation`。[核心表设计](FMS新系统核心表结构设计.md) [模块设计评审](FMS模块设计评审.md)
+
+## 二、当前问题
+
+### 2.1 “模块关联”包含了三种不同关系
+
+目前容易把下面三件事都叫作模块关联：
+
+1. **组织关系**：海运模块下面有主单、箱、费用模块。
+2. **数据关系**：箱表的 `order_id` 引用主单表的 `id`。
+3. **授权关系**：某个菜单页面使用主单模块和箱模块，用户可以进入并操作这些模块。
+
+它们的数学结构和运行规则不同：
+
+| 关系 | 结构 | 典型约束 |
+| --- | --- | --- |
+| 模块组织 | 树 | 一个父节点、不能循环 |
+| 数据关系 | 图 | 可以多对多、可以有多个入边 |
+| 菜单绑定 | 多对多 | 一个页面可用多个模块，一个模块可被多个页面使用 |
+| 权限授权 | 用户到权限点 | 不能因为数据引用就自动获得权限 |
+
+如果用数据关系建立模块父子树，会遇到多个父节点、循环和跨业务域引用。例如“费用 → 客户”是数据引用，但费用模块并不是客户模块的子模块。把它用于权限继承会造成权限扩大。
+
+### 2.2 删除策略和菜单权限没有共同语义
+
+删除策略回答：
+
+> 删除一条业务记录时，关联记录如何处理？什么条件下不允许删除？
+
+权限回答：
+
+> 用户能否进入页面、使用模块、执行动作、查看字段和查看哪些数据？
+
+两者的计算入口、管理员和风险都不同。把删除配置放进菜单权限关联，会让配置人员误以为“菜单绑定”会影响删除，也会让关系面板出现过多不相关列。
+
+### 2.3 当前代码已经有两个真实消费者
+
+当前前端菜单管理使用 `s_menu_module` 保存菜单与模块的绑定；模块关系面板维护 `s_relation`。后端 `DataDeleteService` 会读取启用的 `s_relation`，展开 `cascade` 并检查 `restrict`。
+
+这说明 `s_relation` 不是完全没有价值，但它的价值来自**数据删除和数据影响分析**，不是菜单授权。若以后改成每个模块完全由专用 SQL 删除，才可以进一步评估是否移除它。
+
+## 三、目标模型
+
+### 3.1 三棵树、两类关系
+
+```text
+模块组织树
+s_module.b_parent_id
+海运
+├── 海运主单
+├── 箱信息
+└── 费用
+
+菜单导航树
+s_menu.b_parent_id
+业务管理
+└── 海运工作台
+
+菜单与模块绑定
+s_menu_module
+海运工作台 ── 海运主单
+海运工作台 ── 箱信息
+海运工作台 ── 费用
+
+数据字段关系
+s_relation
+箱信息.order_id ──> 海运主单.id
+费用.order_id   ──> 海运主单.id
+```
+
+模块树只表达业务组织。菜单树只表达导航。菜单页面使用哪些数据模块由 `s_menu_module` 明确保存。数据字段关系只用于数据层，不参与菜单树和权限树。
+
+### 3.2 权限归属：模块为主，菜单为入口
+
+权限应当**跟着模块**，菜单只负责提供入口。
+
+```text
+用户
+ └── 拥有权限点
+      ├── menu.*       → 能否进入菜单页面
+      ├── module.*     → 能否使用模块
+      └── action.*     → 能否执行模块动作
+
+菜单页面
+ └── s_menu_module    → 页面使用哪些模块
+
+模块
+ ├── s_user_field_power → 字段能力
+ └── s_user_data_power  → 数据范围
+```
+
+菜单绑定模块不等于授予模块权限。原因有三点：
+
+1. 一个模块可能被多个菜单复用，权限应该保持一致；
+2. 一个菜单可能使用主模块、明细模块和多个辅助模块，不适合把它们的权限合并成一个菜单权限；
+3. 后端接口、导出、保存和业务动作可能绕过菜单入口，必须仍按模块权限和动作权限校验。
+
+因此运行时按以下顺序判断：
+
+1. 用户是否拥有当前菜单的 `menu.*` 权限；
+2. 当前页面所需模块是否拥有 `module.*` 权限；
+3. 当前请求的操作是否拥有对应的 `action.*` 或标准操作权限；
+4. 查询和写入时继续追加字段权限和数据范围条件。
+
+如果一个页面绑定多个模块，菜单权限只决定能否进入页面，每个模块仍单独判断。主模块或必需模块无权限时，页面应隐藏或拒绝进入；可选模块无权限时，可以隐藏对应面板。是否为“必需模块”属于页面配置，不由 `s_relation` 推导。
+
+模块父子树可以作为管理员批量授权的操作范围，但第一期不建议运行时隐式继承：勾选父模块时可以在界面展开子模块，最终保存每个数据模块的明确授权行。这样新建子模块不会在用户不知情的情况下自动获得所有权限。
+
+### 3.3 权限计算边界
+
+权限计算分为五层：
+
+1. `menu.*`：能否看到和进入菜单页面。
+2. `module.*`：能否使用页面中的某个模块。
+3. `action.*`：能否执行审核、结算等业务动作。
+4. `s_user_field_power`：字段查看、编辑、查询和导出权限。
+5. `s_user_data_power`：数据行范围。
+
+菜单绑定多个模块时，不合并这些模块的权限；每个模块仍按自己的模块编码判断。数据关系也不自动传播权限。若管理员在界面上勾选一个模块分类节点，可以自动展开下级数据模块，但落库仍保存明确的模块权限或菜单绑定行。
+
+### 3.4 用户授权页面如何呈现
+
+管理员不需要直接理解 `s_relation`。授权页面以业务域和模块树呈现：
+
+```text
+海运（业务域，只做分组）
+├── 海运主单（data）
+├── 装箱信息（data）
+└── 费用（data）
+```
+
+建议将授权页面分成三个视图：
+
+#### 菜单入口
+
+左侧显示菜单树，管理员选择“海运工作台”等页面，保存 `menu.*` 权限。
+
+#### 模块能力
+
+显示当前页面绑定的模块，以及完整的业务模块树。每个 `data` / `virtual` 模块显示：
+
+- 是否可访问；
+- 标准操作：查看、新增、编辑、删除、导出；
+- 已配置的业务动作，例如审核、结算；
+- 当前模块是否被哪些菜单使用。
+
+选择“海运”父节点时，界面可以全选或取消全部子模块，并使用半选状态表示部分授权。这个操作只是批量生成明确的模块授权行，不保存“沿关系自动继承”的隐式规则。
+
+#### 字段和数据范围
+
+管理员先选择一个具体模块，再配置字段权限和数据范围。不要在“海运”父节点上混合展示主单、装箱和费用的字段，因为这些字段属于不同模块，数据范围也可能不同。
+
+页面绑定关系可以提供一个“按页面补齐模块权限”的快捷操作：管理员选择菜单后，系统列出该页面使用的主模块、明细模块和辅助模块，管理员确认后一次性生成模块权限。这个操作是显式的授权动作，菜单绑定本身不自动授权。
+
+页面确实依赖某个模块时，应在页面配置中标记该模块为必需模块；可选模块则在用户没有权限时隐藏对应面板。必需/可选属于页面使用配置，不从 `s_relation` 的数据关系推导。
+
+授权效果示例：
+
+| 用户 | 菜单入口 | 模块权限 | 页面效果 |
+| --- | --- | --- | --- |
+| 张三 | 海运工作台 | 主单、装箱 | 能进入页面，费用面板隐藏或不可用 |
+| 李四 | 海运工作台 | 主单、装箱、费用 | 能使用完整页面 |
+| 王五 | 无海运菜单 | 主单 | 不能从海运菜单进入，但模块接口仍按模块权限统一校验 |
+
+页面是否显示可以由“菜单权限 + 至少一个可访问的必需模块”共同决定；真正的查询、保存、删除和动作权限仍必须在后端按模块执行。
+
+### 3.5 默认使用“业务授权方案”，隐藏技术细节
+
+如果每个用户都要先分配菜单，再逐个分配主单、装箱、费用和动作，业务管理员会觉得权限系统过于复杂。因此默认授权入口不直接展示三套独立权限表，而是展示业务人员能理解的授权方案：
+
+```text
+海运
+├── 未授权
+├── 只读
+├── 经办
+└── 主管
+```
+
+方案的含义由系统管理员预先定义。例如：
+
+| 方案 | 菜单入口 | 海运主单 | 装箱信息 | 费用 |
+| --- | --- | --- | --- | --- |
+| 只读 | 海运工作台、海运单列表 | 查看、导出 | 查看 | 查看 |
+| 经办 | 海运工作台、海运单列表 | 查看、新增、编辑、导出 | 查看、编辑 | 查看 |
+| 主管 | 海运全部相关页面 | 全部标准操作和业务动作 | 全部标准操作 | 查看、编辑、导出、结算 |
+
+管理员选择“海运·经办”后，界面先展示授权预览：
+
+```text
+将授予：
+菜单：海运工作台、海运单列表
+模块：海运主单（查看/新增/编辑/导出）
+      装箱信息（查看/编辑）
+      费用（查看）
+```
+
+确认后，在同一事务中写入菜单权限和模块/动作权限。这里的“方案”只是管理员操作的简化入口，运行时的真实权限仍然按模块、动作、字段和数据范围校验；菜单绑定不会在运行时隐式授予模块权限。
+
+默认页面只展示业务名称和方案，不展示模块编码、字段编码和 `s_relation`。授权预览中的“主单、装箱、费用”依赖来自 `s_menu_module` 的页面模块清单，不从数据关系推导。
+
+高级管理员可以展开“详细调整”：单独修改某个模块、动作、字段或数据范围。详细调整生成同一套底层权限记录，不另建一套与方案互相覆盖的规则。方案变更后，应显示变更前后差异并要求确认。
+
+第一期不必新增复杂的角色继承体系。可以先把方案作为权限页面上的预置操作，直接物化为现有 `s_power` / `s_user_power` 等权限行。出现多个用户需要相同授权时，再把方案独立为可复用的权限模板。
+
+## 四、目标表设计
+
+### 4.1 `s_module`：模块组织树
+
+继续使用现有字段：
+
+- `b_id`：模块编码。
+- `b_parent_id`：直接父模块，树关系的唯一权威来源。
+- `b_depth`、`b_path`：由业务层维护的派生字段。
+- `b_module_type`：`module`、`data`、`virtual`。
+
+约束：
+
+- `module` 可以包含下级 `module`、`data` 和 `virtual`。
+- `data`、`virtual` 默认作为叶子节点。
+- 不允许自指和循环。
+- 移动模块时，在同一事务内更新当前节点及全部后代的 `b_depth`、`b_path`。
+- 不从 `s_relation` 推导 `b_parent_id`。
+
+### 4.2 `s_menu`、`s_menu_module`：菜单与模块绑定
+
+`s_menu` 继续使用 `b_parent_id` 建立菜单树。
+
+`s_menu_module` 继续使用联合主键：
+
+```text
+(b_menu_id, b_module_id)
+```
+
+绑定规则：
+
+- `directory`、`external` 不强制绑定模块。
+- `page` 可以绑定一个或多个 `data` / `virtual` 模块。
+- `module` 类型只作为分类和上下文，不直接进入菜单模块绑定。
+- UI 可以按模块树批量勾选，但保存时写入明确的 `s_menu_module` 行。
+- 删除模块前检查并清理其菜单绑定，不能通过数据关系级联推断菜单绑定。
+
+### 4.3 `s_relation`：数据关系
+
+建议将管理页面名称改为“数据关系”，表继续使用字段级复合键：
+
+```text
+b_source_module_id
+b_source_field
+b_target_module_id
+b_target_field
+b_relation_type       -- one_to_one / one_to_many / many_to_one
+b_canuse
+b_xh
+```
+
+它只回答：
+
+> 哪个模块的哪个字段与另一个模块的哪个字段存在结构关系？
+
+它不保存：
+
+- 菜单编码。
+- 用户编码。
+- 权限编码。
+- 模块树父节点。
+- 菜单显示顺序。
+
+#### 删除行为的处理
+
+当前通用删除服务已经依赖 `b_on_delete`，因此建议采用兼容方案：
+
+- 数据库中暂时保留 `s_relation.b_on_delete`。
+- 关系面板只显示该列或提供跳转，不作为菜单权限关系编辑。
+- 唯一可编辑入口放到“删除策略 → 关联删除处理”。
+- 只保留 `restrict`、`cascade`、`none` 三值。
+- 不根据 `b_relation_type` 自动推断删除行为。
+
+如果后续确认所有模块都由专用 SQL 或存储过程删除，则可以迁移掉 `b_on_delete`，让 `s_relation` 只保留结构关系。
+
+### 4.4 `s_delete_rule`：业务删除条件
+
+`s_delete_rule` 只处理“什么情况下不允许删除”，不再保存数据关系键：
+
+```text
+b_id
+b_module_id
+b_sql          -- 只读检查 SQL，命中行即拒绝删除
+b_message
+b_xh
+b_canuse
+```
+
+适合配置：
+
+- 已审核单据不能删除。
+- 已开票记录不能删除。
+- 已生成下游业务单据不能删除。
+- 状态或跨表条件不满足时不能删除。
+
+SQL 只做检查，不允许配置 SQL 直接修改或删除业务数据。实际物理删除继续由后端事务服务负责。
+
+## 五、前端改造方案
+
+### 5.1 模块管理页面
+
+建议将业务能力分节调整为：
+
+```text
+基础
+字段
+界面
+数据关系
+删除策略
+自动编码
+权限
+多语言
+```
+
+其中：
+
+- “数据关系”只维护字段关系。
+- “删除策略”包含“关联删除处理”和“删除 SQL 规则”。
+- “权限”只维护 `s_power`，不展示删除配置。
+- “数据关系”只对 `data` 模块开放。
+
+### 5.2 数据关系面板
+
+保留：
+
+- 新增关系。
+- 源字段选择。
+- 目标模块、目标字段选择。
+- 关系类型。
+- 启用/停用。
+- 排序号。
+- 当前模块作为源的关系编辑。
+- 其他模块指向当前模块的关系只读展示。
+
+调整：
+
+- 面板标题从“模块关联”改为“数据关系”。
+- 删除处理列改为只读并提供“前往删除策略”的入口，或者完全移入删除策略面板。
+- 不出现菜单、权限、用户等字段。
+- 保存前校验模块、字段存在，字段类型可匹配，关系不能重复。
+
+### 5.3 菜单管理页面
+
+- 左侧继续展示模块树。
+- 勾选 `module` 分类节点时，展开其下的 `data` / `virtual` 模块。
+- 保存时只提交 `s_menu_module` 的增删行。
+- 菜单页面绑定的模块不反向修改模块树。
+- 模块被多个菜单使用时，只维护多条菜单绑定，不复制模块。
+
+### 5.4 权限面板
+
+- 模块使用权限继续以 `module.{moduleCode}` 为主。
+- 业务动作使用 `action.{moduleCode}.{action}`。
+- 菜单权限只控制入口。
+- 不因 `s_relation` 存在而自动给用户增加目标模块权限。
+- 如果未来需要继承，只允许从 `s_module.b_parent_id` 的组织树计算，并明确配置继承边界；不使用字段关系推导。
+
+## 六、删除实现取舍
+
+### 6.1 当前阶段推荐方案
+
+保留通用删除服务：
+
+```text
+模块删除
+→ 根据 s_relation.b_on_delete 展开 cascade
+→ 检查 restrict 外部引用
+→ 执行 s_delete_rule SQL 检查
+→ 同一事务内物理删除
+```
+
+这样适合模块数量较多、希望新增模块主要靠配置的场景。`s_relation` 为删除服务提供结构信息，`s_delete_rule` 为业务条件提供 SQL 出口，两者职责明确。
+
+### 6.2 SQL 直接处理的适用边界
+
+SQL 适合：
+
+- 复杂查询和跨表判断。
+- 固定模块的特殊清理逻辑。
+- 数据库外键的 `CASCADE` / `NO ACTION`（物理结构稳定时）。
+
+不建议：
+
+- 让管理员配置任意 `DELETE SQL` 作为通用删除入口。
+- 用 SQL 文本判断用户菜单权限。
+- 用 SQL 关系自动推导模块父子和权限继承。
+
+如果未来选择“完全模块专用 SQL 删除”，迁移顺序应是：先为每个模块补齐删除服务和测试，再停止通用删除服务读取 `s_relation`，最后删除 `b_on_delete`，不能先删元数据再补删除逻辑。
+
+## 七、迁移步骤
+
+### 阶段 0：盘点和校验
+
+1. 统计现有 `s_relation` 行，确认每行的源模块、源字段、目标模块、目标字段真实存在。
+2. 检查重复关系、自引用、无效模块和无效字段。
+3. 盘点旧系统 `s_modulelink` 或其他模块链接数据，确认哪些是菜单绑定，哪些是数据关系，禁止直接整表迁移到 `s_relation`。
+4. 统计菜单、模块、权限之间的现有绑定，找出没有模块权限但已有菜单入口的情况。
+
+### 阶段 1：先改语义和界面
+
+1. 将模块管理中的“模块关联”改为“数据关系”。
+2. 移除它对菜单权限的描述。
+3. 在菜单管理中明确展示 `s_menu_module` 绑定。
+4. 增加“删除策略”分组，保证 `b_on_delete` 只有一个编辑入口。
+5. 不立即删除数据库列和旧数据，保持兼容。
+
+### 阶段 2：拆分权限计算
+
+1. 路由和侧栏只根据菜单权限及菜单绑定判断入口。
+2. 页面内模块操作根据 `s_power` / `s_user_power` 独立判断。
+3. 字段和数据范围继续走独立权限表。
+4. 全局搜索确认权限代码没有读取 `s_relation`。
+
+### 阶段 3：收敛删除策略
+
+1. 删除前条件统一读取 `s_delete_rule`。
+2. 关联删除统一读取 `s_relation.b_on_delete`。
+3. 删除列表入口和 `saveobjt` 使用同一删除服务。
+4. 对 `cascade` 做环路、深度、重复记录和事务回滚测试。
+5. 对 `restrict` 返回引用模块、字段和示例记录，便于用户处理。
+
+### 阶段 4：清理旧概念
+
+只有在兼容数据完成迁移后，才删除：
+
+- 旧的菜单关系字段。
+- 旧的引用规则或重复删除配置。
+- 模块关联面板中的权限文案。
+- 不再使用的关系推导逻辑。
+
+## 八、验收标准
+
+### 模块树
+
+- 模块只能有一个直接父节点。
+- 不能自引用或形成循环。
+- 移动节点后，所有后代的 `b_path`、`b_depth` 正确。
+- 数据字段关系不会改变模块树。
+
+### 菜单和权限
+
+- 一个菜单可以绑定多个模块。
+- 一个模块可以被多个菜单复用。
+- 勾选模块分类节点只是批量操作，保存后仍是明确绑定行。
+- 只有菜单权限不能直接操作模块数据。
+- 有数据关系的两个模块不会自动互相获得权限。
+
+### 数据关系
+
+- 关系字段存在且类型可匹配。
+- 关系重复时保存失败。
+- 反向关系可查看，但不会重复提交或误删。
+- `s_relation` 不包含菜单、用户和权限字段。
+
+### 删除
+
+- `cascade` 能正确删除拥有关系的子记录。
+- `restrict` 能阻止外部引用导致的父记录删除。
+- `none` 不自动处理关联记录，并在配置界面显示风险提示。
+- 删除 SQL 命中时整批回滚。
+- 技术表使用 `target=direct` 时不读取模块关系。
+- 任何检查失败时，不留下部分删除结果。
+
+## 九、文件影响范围
+
+### 数据库和脚本
+
+- `sql/fms_core.sql`：确认 `s_module`、`s_menu`、`s_menu_module`、`s_relation`、`s_power` 的职责注释和字段。
+- `sql/fms_delete_rule.sql`：只保留删除策略迁移和 `s_delete_rule` 初始化。
+- 新增一份关系数据校验/迁移脚本，先报告问题，不直接静默修复。
+
+### 前端
+
+- `fms-vue/src/views/module/module-management/index.vue`：调整分节名称和数据关系/删除策略的编排。
+- `ModuleRelationPanel.vue`：改名、缩减职责、移除权限语义。
+- `ModuleRulePanel.vue`：作为删除 SQL 规则面板保留。
+- `fms-vue/src/views/module/menu-management/index.vue`：继续以 `s_menu_module` 保存菜单绑定。
+- `stores/permissions.js`：确认权限计算不读取 `s_relation`。
+
+### 后端
+
+- `DataDeleteService.java`：继续只把 `s_relation` 当作数据关系来源。
+- `SqlPermissionService.java`：权限只读取权限表，不通过数据关系推导。
+- 菜单接口和模块接口分别校验自己的树结构，不能共用一套父子关系处理。
+
+## 十、需要确认的唯一决策
+
+本计划默认保留通用删除服务，因此保留 `s_relation.b_on_delete` 作为底层删除策略字段，但把编辑入口移到“删除策略”。
+
+如果决定所有业务模块都用专用 SQL 或存储过程处理删除，则可以选择另一条路线：
+
+```text
+s_relation 只保留数据结构关系
+s_delete_rule 保留删除前检查
+模块删除由各自服务/存储过程完成
+```
+
+这条路线的配置更少，但新增模块不能只靠元数据完成删除行为，需要额外编写和测试模块删除逻辑。
+
+在当前 FMS 已经存在通用 `DataDeleteService`、模块数量较多的前提下，建议先采用默认方案：**保留数据关系，拆出权限语义，删除策略单独管理，暂不改成纯 SQL 删除。**
+
+## 十一、原型演示
+
+对应的交互原型位于 [权限分配原型.html](权限分配原型.html)，直接用浏览器打开即可查看。
+
+原型按常见企业系统的授权路径组织：
+
+1. 左侧切换用户，顶部查看当前授权来源和保存状态。
+2. 先选择海运、空运或财务业务域。
+3. 默认选择“未授权、只读、经办、主管”等业务方案，右侧立即预览菜单入口、模块和动作。
+4. 需要精细控制时，在海运业务中打开“详细权限调整”，分别配置菜单、模块、字段和数据范围。
+5. 用“预览最终权限”查看后端实际会收到的授权结果，用“撤销修改”验证未保存变更不会直接生效。
+
+原型中的角色方案只是降低管理员理解成本的操作入口，底层仍然落成菜单、模块和动作权限；业务域和模块之间的字段关系没有被用来推导权限。
diff --git a/code/fms/FMS模块设计评审.md b/code/fms/FMS模块设计评审.md
index e3b3ee7e..405a4db2 100644
--- a/code/fms/FMS模块设计评审.md
+++ b/code/fms/FMS模块设计评审.md
@@ -1,13 +1,15 @@
 # FMS 模块设计评审
 
 > 版本：v1.2。评审对象：`FMS新系统核心表结构设计.md`（模块 / 字段 / 界面配置 / 模块关系 / 权限）。
-> 关联：`FMS删除规则引擎设计.md`（已按本评审定案修订为 v2.0）、`开发规范.md`、`CODEBUDDY.md`。
+> 关联：`FMS删除策略重构设计.md`（当前删除策略架构）、`开发规范.md`、`CODEBUDDY.md`。
 > 一句话：**骨架是对的，改三处即可——关系删除行为一列化、配置分节按业务问题分、规则表达对齐权限体系。**
 >
-> v1.1 修订：问题一原建议「加 `b_relation_kind` 语义列 + 按语义推导默认行为」，定案为**不加语义列、单列 `b_on_delete` 四值**——语义列与删除行为同轴，不提供额外信息；被引用方由基数判定。`FMS删除规则引擎设计.md` 已同步修订为 v2.0。
+> v1.1 修订：问题一原建议「加 `b_relation_kind` 语义列 + 按语义推导默认行为」，定案为不加语义列、单列 `b_on_delete` 表达删除行为。该部分已由当前删除策略重构重新收敛为三值方案。
 >
 > v1.2 修订：第八节第 3、4 项定案——中间表模块统一挂业务域节点下（规范已写入 `FMS新系统核心表结构设计.md` §4.3）；模块管理分节调整随删除规则前端改造同一批实施。
 
+> 当前实施以 `FMS删除策略重构设计.md` 为准。本评审中关于四值删除行为、归档、勾条件、引用规则和 `s_rule` 的章节保留为历史讨论，不再作为实施规格。
+
 ---
 
 ## 一、总评
@@ -58,7 +60,7 @@
 3. **唯一只有配置者知道的事**是四选一的行为本身（被引用方是否独占拥有引用方），单列直接表达它；
 4. 与 `开发规范.md`「为真实出现的第二个使用方而抽象」一致——不为「表单将来可能用语义做别的」预留列。
 
-最终结构（详规见 `FMS删除规则引擎设计.md` v2.0 §3）：
+最终结构（历史方案；当前方案详见 `FMS删除策略重构设计.md`）：
 
 ```sql
 alter table dbo.s_relation add
@@ -154,7 +156,7 @@ alter table dbo.s_relation add
 - 去掉 `b_hook`（一期只有 `delete.pre` 一种取值，属过早抽象）；
 - 去掉 `b_scope_type`（同上）。
 
-已按此修订 `FMS删除规则引擎设计.md`（v2.0）。
+该历史方案已由 `FMS删除策略重构设计.md` 取代。
 
 ---
 
@@ -189,21 +191,21 @@ alter table dbo.s_relation add
 
 | 设计/文档有 | 实际状态 |
 | --- | --- |
-| 删除规则引擎（`FMS删除规则引擎设计.md` §6.4/§6.5 整节） | **后端零实现**：`s_rule` / `deleteobj` / `b_on_delete` / `b_archived` 在 `fms-api` 中全部 grep 无匹配 |
+| 删除策略引擎（`FMS删除策略重构设计.md`） | **后端零实现**：删除计划、SQL 规则检查、`deleteobj` 和 `b_on_delete` 执行链路仍待实现 |
 | `DataSaveService` 的 delete 分支接入规则检查 | 未实现，`DataSaveService.java:470` 直接 `dbUtils.delete(...)` |
 | `s_rule.b_scope_id` 为 `bigint`（v1 设计） | 实现为拼接串 `varchar(250)`；v2.0 已整体重新定义表结构，该差异随重建消除 |
 | 删除「先预览后确认」（设计 §4） | 列表页 `deleteSelected` 直接调 `saveObjectApi`，无预览/确认两步 |
 | `save.pre` / `b_hook` 预留位 | 只有 `delete.pre` 一种取值，预留位无实际内容 |
 
-**风险提示**：规则引擎未实现时，界面上配的删除规则**不生效**。这比没有该功能更危险——它给配置者虚假的安全感。详见 `FMS删除规则引擎设计.md`。
+**风险提示**：删除策略未实现时，界面上配置的删除规则**不生效**。这比没有该功能更危险——它给配置者虚假的安全感。详见 `FMS删除策略重构设计.md`。
 
 ---
 
 ## 七、建议的落地顺序
 
-1. **`s_relation` 加 `b_on_delete`**（四值、默认 `restrict`），配合 `FMS删除规则引擎设计.md` v2.0 的表结构调整；
-2. **模块管理分节改为「数据行为 / 访问控制」**，按业务问题而非载体划分；与删除规则前端改造（`FMS删除规则引擎设计.md` §8 步骤 5）同一批实施——两者都要动 `module-management/index.vue`，不单独安排；
-3. **`s_rule` 结构化**：显式 `b_kind`、直白 `b_module_id`、去掉预留位；
+1. **`s_relation` 加 `b_on_delete`**（三值、默认 `restrict`），按 `FMS删除策略重构设计.md` 的架构调整；
+2. **模块管理分节改为「数据行为 / 访问控制」**，按业务问题而非载体划分；删除策略统一为关联删除处理 + 删除 SQL 规则；
+3. **删除规则专用化**：使用 `s_delete_rule`，只保留模块、SQL、提示、启用和顺序；
 4. ~~补规范：明确中间表模块在模块树中的挂载位置~~ **已完成**：规范已写入 `FMS新系统核心表结构设计.md` §4.3；
 5. **实现后端删除引擎**（`deleteobj` + 检查器 + 执行器 + `saveobjt` 接入）。
 
diff --git a/code/fms/fms-api/src/main/java/cn/g3soft/fmsapi/controller/DataController.java b/code/fms/fms-api/src/main/java/cn/g3soft/fmsapi/controller/DataController.java
index 54e95a01..932759dd 100644
--- a/code/fms/fms-api/src/main/java/cn/g3soft/fmsapi/controller/DataController.java
+++ b/code/fms/fms-api/src/main/java/cn/g3soft/fmsapi/controller/DataController.java
@@ -1,5 +1,6 @@
 package cn.g3soft.fmsapi.controller;
 
+import cn.g3soft.fmsapi.service.DataDeleteService;
 import cn.g3soft.fmsapi.service.DataSaveService;
 import cn.g3soft.fmsapi.service.DataService;
 import cn.g3soft.fmsapi.utils.ApiResponse;
@@ -26,6 +27,9 @@ public class DataController {
     @Resource
     private DataSaveService dataSaveService;
 
+    @Resource
+    private DataDeleteService dataDeleteService;
+
     @PostMapping("/loaddata")
     public ApiResponse<List<Map<String, Object>>> loadData(
             @RequestBody(required = false) Map<String, Object> params
@@ -55,6 +59,17 @@ public class DataController {
         return ApiResponse.success("保存成功", null);
     }
 
+    /**
+     * 统一删除接口：模块数据传 target=module + moduleCode + ids；
+     * 受控后端服务传 target=direct + table + key_field + ids（设计 §6.1、§1.1）。
+     */
+    @PostMapping("/delete")
+    public ApiResponse<Map<String, Integer>> delete(
+            @RequestBody(required = false) Map<String, Object> params
+    ) throws SQLException {
+        return ApiResponse.success(dataDeleteService.delete(params));
+    }
+
     @PostMapping("/nextid")
     public ApiResponse<?> nextId(@RequestBody(required = false) Map<String, Object> params) {
         int count = 1;
diff --git a/code/fms/fms-api/src/main/java/cn/g3soft/fmsapi/service/DataDeleteService.java b/code/fms/fms-api/src/main/java/cn/g3soft/fmsapi/service/DataDeleteService.java
new file mode 100644
index 00000000..50a9452e
--- /dev/null
+++ b/code/fms/fms-api/src/main/java/cn/g3soft/fmsapi/service/DataDeleteService.java
@@ -0,0 +1,782 @@
+package cn.g3soft.fmsapi.service;
+
+import cn.g3soft.fmsapi.exception.BusinessException;
+import cn.g3soft.fmsapi.utils.DbUtils;
+import cn.g3soft.fmsapi.utils.ParamUtils;
+import jakarta.annotation.Resource;
+import org.springframework.stereotype.Service;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * 删除服务：删除策略层对外的唯一入口。
+ *
+ * <p>按设计文档《FMS删除策略重构设计.md》实现，删除目标分两类：
+ * <ul>
+ *   <li>{@code target=module}：业务模块数据，读取模块保存表和主键，展开 cascade，
+ *       执行 restrict 与模块 SQL 规则，再物理删除；</li>
+ *   <li>{@code target=direct}：技术表或专用资源，直接进入物理删除执行器，
+ *       不读模块关系、不跑模块 SQL 规则。普通模块列表不允许传表名。</li>
+ * </ul>
+ *
+ * <p>计划、检查、删除在同一事务中完成（设计 §5.3）：任一步骤失败整批回滚。
+ */
+@Service
+public class DataDeleteService {
+
+    /** 删除目标类型：模块数据。 */
+    public static final String TARGET_MODULE = "module";
+    /** 删除目标类型：直接表。 */
+    public static final String TARGET_DIRECT = "direct";
+
+    /** 单次删除的 ID 上限，避免生成过大的 IN 列表（设计 §4.2）。 */
+    private static final int MAX_DELETE_IDS = 1000;
+    /** cascade 最大展开深度，防止错误配置导致无限递归（设计 §5.1）。 */
+    private static final int MAX_CASCADE_DEPTH = 8;
+
+    private static final String ON_DELETE_RESTRICT = "restrict";
+    private static final String ON_DELETE_CASCADE = "cascade";
+    private static final String ON_DELETE_NONE = "none";
+
+    @Resource
+    private DataSource dataSource;
+
+    @Resource
+    private DbUtils dbUtils;
+
+    /**
+     * 统一删除入口（设计 §6.1）。参数按 target 取值：
+     * <ul>
+     *   <li>{@code target=module}：{@code moduleCode} + {@code ids}；</li>
+     *   <li>{@code target=direct}：{@code table} + {@code key_field} + {@code ids}。</li>
+     * </ul>
+     * 不允许以“有没有传 moduleCode”作隐式分支，避免漏传时静默绕过模块规则。
+     */
+    public Map<String, Integer> delete(Map<String, Object> params) throws SQLException {
+        if (params == null) {
+            throw new BusinessException("删除参数不能为空");
+        }
+        String target = ParamUtils.getString(params, "target");
+        if (target == null || target.isBlank()) {
+            throw new BusinessException("删除目标类型不能为空");
+        }
+        List<Object> ids = ParamUtils.getList(params, "ids");
+        String userId = ParamUtils.getString(params, "userId");
+
+        if (TARGET_MODULE.equalsIgnoreCase(target)) {
+            String moduleCode = ParamUtils.getRequiredString(params, "moduleCode");
+            return deleteModule(moduleCode, ids, userId);
+        }
+        if (TARGET_DIRECT.equalsIgnoreCase(target)) {
+            String table = ParamUtils.getRequiredString(params, "table");
+            String keyField = ParamUtils.getRequiredString(params, "key_field");
+            if (ids == null || ids.isEmpty()) {
+                return Collections.emptyMap();
+            }
+            checkIdLimit(ids);
+            try (Connection connection = dataSource.getConnection()) {
+                boolean originalAutoCommit = connection.getAutoCommit();
+                connection.setAutoCommit(false);
+                try {
+                    int count = deleteDirect(connection, table, keyField, ids, userId);
+                    connection.commit();
+                    return Map.of(table, count);
+                } catch (SQLException | RuntimeException exception) {
+                    rollback(connection, exception);
+                    throw exception;
+                } finally {
+                    if (originalAutoCommit) {
+                        connection.setAutoCommit(true);
+                    }
+                }
+            }
+        }
+        throw new BusinessException("删除目标类型必须是 module 或 direct");
+    }
+
+    /**
+     * 模块删除：前端只传 moduleCode + ids（设计 §6.1）。
+     *
+     * @param moduleCode 模块编码（s_module.b_id）
+     * @param ids        待删除记录主键值
+     * @return 各模块实际删除行数
+     */
+    public Map<String, Integer> deleteModule(String moduleCode, List<Object> ids, String userId)
+            throws SQLException {
+        try (Connection connection = dataSource.getConnection()) {
+            boolean originalAutoCommit = connection.getAutoCommit();
+            connection.setAutoCommit(false);
+            try {
+                Map<String, Integer> result = executeModuleTarget(
+                        connection, moduleCode, ids, Collections.emptyList(), userId);
+                connection.commit();
+                return result;
+            } catch (SQLException | RuntimeException exception) {
+                rollback(connection, exception);
+                throw exception;
+            } finally {
+                if (originalAutoCommit) {
+                    connection.setAutoCommit(true);
+                }
+            }
+        }
+    }
+
+    /**
+     * saveobjt 的删除分支：复用调用方事务连接，不自行提交（设计 §6.2）。
+     *
+     * @param explicitDeletes 请求自带的删除行，元素为 {table, key_field, ids}
+     *                        （direct 目标）或 {module_code, ids}（module 目标）
+     */
+    public Map<String, Integer> deleteWithinTransaction(
+            Connection connection,
+            String target,
+            String moduleCode,
+            List<Object> ids,
+            List<Map<String, Object>> explicitDeletes,
+            String userId
+    ) throws SQLException {
+        if (TARGET_MODULE.equalsIgnoreCase(target)) {
+            return executeModuleTarget(connection, moduleCode, ids, explicitDeletes, userId);
+        }
+        if (TARGET_DIRECT.equalsIgnoreCase(target)) {
+            return executeDirectTarget(connection, explicitDeletes, userId);
+        }
+        // 不以“有没有传 moduleCode”作隐式分支，避免漏传时静默绕过模块规则（设计 §6.2）
+        throw new BusinessException("删除目标类型必须是 module 或 direct");
+    }
+
+    /**
+     * 直接表删除：文件服务等受控后端服务使用，不展开业务关系（设计 §6.3）。
+     */
+    public int deleteDirect(
+            Connection connection,
+            String table,
+            String keyField,
+            List<Object> ids,
+            String userId
+    ) throws SQLException {
+        if (ids == null || ids.isEmpty()) {
+            return 0;
+        }
+        checkIdLimit(ids);
+        DbUtils.TableMetadata metadata = dbUtils.loadTableMetadata(connection, table);
+        DbUtils.ColumnMetadata keyColumn = requireKeyColumn(metadata, keyField);
+        int deleted = deleteRecords(connection, metadata, keyColumn, ids);
+        writeDeleteLog(userId, "direct", table, keyColumn.name(), ids.size(), deleted);
+        return deleted;
+    }
+
+    // ── target=module：计划 → 检查 → 执行 ──────────────────────────────────
+
+    private Map<String, Integer> executeModuleTarget(
+            Connection connection,
+            String moduleCode,
+            List<Object> ids,
+            List<Map<String, Object>> explicitDeletes,
+            String userId
+    ) throws SQLException {
+        String requiredModule = requireText(moduleCode, "moduleCode");
+        if (ids == null || ids.isEmpty()) {
+            return Collections.emptyMap();
+        }
+        checkIdLimit(ids);
+
+        ModuleTarget root = loadModuleTarget(connection, requiredModule);
+
+        // 1. 生成删除清单：显式删除 + cascade 展开，按“表 + 主键字段 + 主键值”去重（设计 §6.2）
+        DeletePlan plan = new DeletePlan();
+        plan.add(root.metadata(), root.keyColumn(), requiredModule, ids, 0);
+        expandCascade(connection, root, requiredModule, ids, plan, 1);
+        mergeExplicitDeletes(connection, explicitDeletes, plan, requiredModule, false);
+
+        // 2. 检查：模块 SQL 规则 + restrict 外部引用（设计 §5.2）
+        checkDeleteRules(connection, plan, userId);
+        checkRestrictReferences(connection, plan);
+
+        // 3. 执行：子记录优先，物理删除（设计 §5.3）
+        Map<String, Integer> deleted = new LinkedHashMap<>();
+        for (PlannedTable planned : plan.orderedFromLeaf()) {
+            int count = deleteRecords(
+                    connection,
+                    planned.metadata(),
+                    planned.keyColumn(),
+                    new ArrayList<>(planned.values()));
+            deleted.merge(planned.key(), count, Integer::sum);
+            writeDeleteLog(userId, requiredModule, planned.key(),
+                    planned.keyColumn().name(), planned.values().size(), count);
+        }
+        return deleted;
+    }
+
+    private ModuleTarget loadModuleTarget(Connection connection, String moduleCode)
+            throws SQLException {
+        List<Map<String, Object>> rows = dbUtils.loadDataBySql(
+                connection,
+                "select [b_save_table], [b_key_field] from [s_module] where [b_id] = "
+                        + dbUtils.toSqlStringLiteral(moduleCode));
+        if (rows.isEmpty()) {
+            throw new BusinessException("模块不存在: " + moduleCode);
+        }
+        Map<String, Object> row = rows.get(0);
+        String saveTable = text(row.get("b_save_table"));
+        // 只允许保存表，绝不回退视图表（设计 §6.1）；视图表通常不可写。
+        if (saveTable == null || saveTable.isBlank()) {
+            throw new BusinessException("模块未配置保存表，无法删除");
+        }
+        String keyField = text(row.get("b_key_field"));
+        if (keyField == null || keyField.isBlank()) {
+            throw new BusinessException("模块未配置主键字段，无法删除");
+        }
+        DbUtils.TableMetadata metadata = dbUtils.loadTableMetadata(connection, saveTable);
+        return new ModuleTarget(metadata, requireKeyColumn(metadata, keyField));
+    }
+
+    /**
+     * 沿启用的 cascade 关系递归展开删除清单（设计 §5.1）。
+     *
+     * <p>关系是双向登记的：一条 {@code s_relation} 行描述“源模块.源字段 → 目标模块.目标字段”。
+     * 删除某模块记录时，引用它的可能是关系的哪一侧，取决于外键所在侧（设计 §3.2）：
+     * <ul>
+     *   <li>本模块是关系的<b>目标</b>侧：引用方是源侧，外键列 = 目标字段，用源表按该列匹配本模块主键值；</li>
+     *   <li>本模块是关系的<b>源</b>侧：被引用方是目标侧，外键列 = 源字段，用目标表按该列匹配本模块主键值。</li>
+     * </ul>
+     * 两种方向都要展开，否则“从明细删主单”这类反向级联会静默失效。
+     */
+    private void expandCascade(
+            Connection connection,
+            ModuleTarget current,
+            String moduleCode,
+            List<Object> ids,
+            DeletePlan plan,
+            int depth
+    ) throws SQLException {
+        if (depth > MAX_CASCADE_DEPTH) {
+            throw new BusinessException(
+                    "关联删除层级超过上限 " + MAX_CASCADE_DEPTH + "，请检查关系配置是否存在环路");
+        }
+
+        List<Map<String, Object>> relations = dbUtils.loadDataBySql(
+                connection,
+                "select [b_source_module_id], [b_source_field], [b_target_module_id], [b_target_field], [b_relation_type] "
+                        + "from [s_relation] where [b_canuse] = 1 and [b_on_delete] = 'cascade' "
+                        + "and ([b_source_module_id] = " + dbUtils.toSqlStringLiteral(moduleCode)
+                        + " or [b_target_module_id] = " + dbUtils.toSqlStringLiteral(moduleCode) + ")");
+
+        for (Map<String, Object> relation : relations) {
+            String sourceModule = text(relation.get("b_source_module_id"));
+            String targetModule = text(relation.get("b_target_module_id"));
+            String sourceField = text(relation.get("b_source_field"));
+            String targetField = text(relation.get("b_target_field"));
+            String relationType = text(relation.get("b_relation_type"));
+            if (sourceModule == null || targetModule == null
+                    || sourceField == null || targetField == null) {
+                continue;
+            }
+
+            // 外键所在侧由关系类型决定（设计 §3.2）：
+            //   many_to_one  → 外键在源字段，被引用方是目标模块；
+            //   one_to_many / one_to_one → 外键在目标字段，被引用方是源模块。
+            boolean fkOnSource = relationType == null
+                    || relationType.equalsIgnoreCase("many_to_one");
+            String fkModule = fkOnSource ? sourceModule : targetModule;
+            String fkField = fkOnSource ? sourceField : targetField;
+            String referencedModule = fkOnSource ? targetModule : sourceModule;
+
+            // 只有当前模块正是"被引用方"时才向下展开引用它的记录；
+            // 当前模块是持有外键的一方时，删除它不会牵连被引用方，不展开。
+            if (!moduleCode.equalsIgnoreCase(referencedModule)) {
+                continue;
+            }
+            String childModule = fkModule;
+            String childFkField = fkField;
+            if (childModule.equalsIgnoreCase(moduleCode)) {
+                // 自引用关系：不当作新增层级，避免自己级联自己
+                continue;
+            }
+
+            ModuleTarget child = loadModuleTarget(connection, childModule);
+            List<Object> childIds = queryChildIdsByFk(
+                    connection, child, childFkField, current.keyColumn(), ids);
+            if (childIds.isEmpty()) {
+                continue;
+            }
+            boolean added = plan.add(child.metadata(), child.keyColumn(), childModule, childIds, depth);
+            if (added) {
+                expandCascade(connection, child, childModule, childIds, plan, depth + 1);
+            }
+        }
+    }
+
+    /**
+     * 查询引用了给定父记录的子记录主键：子表中外键列 = 父主键值。
+     * 只用模块保存表元数据定位列名，不信任配置里的表名。
+     */
+    private List<Object> queryChildIdsByFk(
+            Connection connection,
+            ModuleTarget child,
+            String childFkField,
+            DbUtils.ColumnMetadata parentKey,
+            List<Object> parentIds
+    ) throws SQLException {
+        DbUtils.ColumnMetadata fkColumn = dbUtils.getColumn(child.metadata(), childFkField);
+        String fkName = fkColumn != null ? fkColumn.name() : childFkField;
+        dbUtils.validateIdentifier(fkName);
+        String childKey = child.keyColumn().name();
+
+        String sql = "select distinct [" + childKey + "] from " + child.metadata().quotedName()
+                + " where [" + fkName + "] in (" + literalList(parentIds, parentKey) + ")";
+        List<Map<String, Object>> rows = dbUtils.loadDataBySql(connection, sql);
+        List<Object> values = new ArrayList<>();
+        for (Map<String, Object> row : rows) {
+            Object value = row.get(childKey);
+            if (value != null) {
+                values.add(value);
+            }
+        }
+        return values;
+    }
+
+    /**
+     * 合并 saveobjt 请求自带的显式删除行（设计 §6.2）。
+     * 同一物理记录若同时以模块目标和直接目标提交，直接报冲突，不执行两次。
+     */
+    private void mergeExplicitDeletes(
+            Connection connection,
+            List<Map<String, Object>> explicitDeletes,
+            DeletePlan plan,
+            String moduleCode,
+            boolean asDirectTarget
+    ) throws SQLException {
+        for (Map<String, Object> row : explicitDeletes == null
+                ? List.<Map<String, Object>>of() : explicitDeletes) {
+            String table = text(row.get("table"));
+            String keyField = text(row.get("key_field"));
+            List<?> rawIds = row.get("ids") instanceof List<?> list ? list : List.of();
+            if (table == null || keyField == null || rawIds.isEmpty()) {
+                continue;
+            }
+            DbUtils.TableMetadata metadata = dbUtils.loadTableMetadata(connection, table);
+            DbUtils.ColumnMetadata keyColumn = requireKeyColumn(metadata, keyField);
+            String tableKey = metadata.requestedName().toLowerCase(Locale.ROOT)
+                    + "|" + keyColumn.normalizedName();
+            if (asDirectTarget) {
+                // 直接目标提交的记录若已作为模块目标进清单，说明同一物理记录被两种目标同时提交。
+                // 模块目标自己的显式删除行不属于此列（它们本就归属该模块）。
+                if (plan.containsTable(tableKey) && plan.moduleCodeOfTable(tableKey) != null
+                        && plan.valuesOf(table).stream().anyMatch(rawIds::contains)) {
+                    throw new BusinessException(
+                            "同一记录不能同时以模块目标和直接目标删除: " + table);
+                }
+            }
+            // 模块目标的显式删除行：记录模块归属，使其参与模块 SQL 规则检查
+            plan.add(metadata, keyColumn, asDirectTarget ? null : moduleCode, new ArrayList<>(rawIds), 0);
+        }
+    }
+
+    // ── 检查：SQL 规则 + restrict ─────────────────────────────────────────
+
+    private void checkDeleteRules(Connection connection, DeletePlan plan, String userId)
+            throws SQLException {
+        for (PlannedTable planned : plan.tables()) {
+            String moduleCode = planned.moduleCode();
+            if (moduleCode == null) {
+                continue;
+            }
+            List<Map<String, Object>> rules = dbUtils.loadDataBySql(
+                    connection,
+                    "select [b_message], [b_sql] from [s_delete_rule] "
+                            + "where [b_canuse] = 1 and [b_module_id] = "
+                            + dbUtils.toSqlStringLiteral(moduleCode)
+                            + " order by [b_xh], [b_id]");
+            for (Map<String, Object> rule : rules) {
+                String template = text(rule.get("b_sql"));
+                if (template == null || template.isBlank()) {
+                    continue;
+                }
+                String sql = template.replace(":ids",
+                        literalList(planned.values(), planned.keyColumn()));
+                // 复用统一只读入口：校验 + 使用当前事务连接执行（设计 §4.4）
+                List<Map<String, Object>> hit = dbUtils.loadDataBySql(connection, sql);
+                if (!hit.isEmpty()) {
+                    String message = text(rule.get("b_message"));
+                    throw new BusinessException(
+                            (message == null || message.isBlank() ? "记录不允许删除" : message)
+                                    + "（模块 " + moduleCode + " 命中 " + hit.size() + " 行）");
+                }
+            }
+        }
+    }
+
+    /**
+     * restrict 入边检查：删除清单之外的外部引用即拒绝（设计 §3.3、§5.2）。
+     *
+     * <p>与 cascade 同向：先列出所有 {@code restrict} 关系，再判断本模块处在哪一侧，
+     * 得到“引用方模块 + 外键列”。命中行数减去“本次清单内也要删掉的行数”，
+     * 剩下的就是真正的外部引用。
+     */
+    private void checkRestrictReferences(Connection connection, DeletePlan plan)
+            throws SQLException {
+        for (PlannedTable planned : plan.tables()) {
+            String moduleCode = planned.moduleCode();
+            if (moduleCode == null) {
+                continue;
+            }
+            List<Map<String, Object>> relations = dbUtils.loadDataBySql(
+                    connection,
+                    "select [b_source_module_id], [b_source_field], "
+                            + "[b_target_module_id], [b_target_field], [b_relation_type] "
+                            + "from [s_relation] where [b_canuse] = 1 and [b_on_delete] = 'restrict' "
+                            + "and ([b_source_module_id] = " + dbUtils.toSqlStringLiteral(moduleCode)
+                            + " or [b_target_module_id] = " + dbUtils.toSqlStringLiteral(moduleCode) + ")");
+            for (Map<String, Object> relation : relations) {
+                String sourceModule = text(relation.get("b_source_module_id"));
+                String targetModule = text(relation.get("b_target_module_id"));
+                String sourceField = text(relation.get("b_source_field"));
+                String targetField = text(relation.get("b_target_field"));
+                String relationType = text(relation.get("b_relation_type"));
+                if (sourceModule == null || targetModule == null
+                        || sourceField == null || targetField == null) {
+                    continue;
+                }
+
+                // 外键所在侧由关系类型决定（设计 §3.2），与 cascade 同一口径
+                boolean fkOnSource = relationType == null
+                        || relationType.equalsIgnoreCase("many_to_one");
+                String fkModule = fkOnSource ? sourceModule : targetModule;
+                String fkField = fkOnSource ? sourceField : targetField;
+                String referencedModule = fkOnSource ? targetModule : sourceModule;
+
+                // 只有当前模块是被引用方时，才需要检查"谁引用了我"
+                if (!moduleCode.equalsIgnoreCase(referencedModule)) {
+                    continue;
+                }
+                String childModule = fkModule;
+                String childFkField = fkField;
+                if (childModule.equalsIgnoreCase(moduleCode)) {
+                    continue;
+                }
+
+                ModuleTarget child = loadModuleTarget(connection, childModule);
+                DbUtils.ColumnMetadata fkColumn = dbUtils.getColumn(child.metadata(), childFkField);
+                String fkName = fkColumn != null ? fkColumn.name() : childFkField;
+                dbUtils.validateIdentifier(fkName);
+                String childKey = child.keyColumn().name();
+
+                String parentLiteral = literalList(planned.values(), planned.keyColumn());
+                String countSql = "select count(1) as [cnt] from " + child.metadata().quotedName()
+                        + " where [" + fkName + "] in (" + parentLiteral + ")";
+                List<Map<String, Object>> rows = dbUtils.loadDataBySql(connection, countSql);
+                long count = rows.isEmpty() ? 0 : toLong(rows.get(0).get("cnt"));
+                if (count <= 0) {
+                    continue;
+                }
+
+                // 清单内同一批一起删除的引用不算外部引用
+                long inPlan = 0;
+                Set<Object> plannedChildIds = plan.valuesOf(child.metadata().requestedName());
+                if (!plannedChildIds.isEmpty()) {
+                    long total = count;
+                    String overlapSql = "select count(1) as [cnt] from "
+                            + child.metadata().quotedName()
+                            + " where [" + fkName + "] in (" + parentLiteral + ")"
+                            + " and [" + childKey + "] in ("
+                            + literalList(plannedChildIds, child.keyColumn()) + ")";
+                    List<Map<String, Object>> overlapRows =
+                            dbUtils.loadDataBySql(connection, overlapSql);
+                    inPlan = overlapRows.isEmpty() ? 0 : toLong(overlapRows.get(0).get("cnt"));
+                    if (inPlan > total) {
+                        inPlan = total;
+                    }
+                }
+                if (count > inPlan) {
+                    throw new BusinessException(
+                            "存在外部引用，无法删除：" + childModule + "." + fkName
+                                    + " 引用 " + count + " 行，其中 " + (count - inPlan)
+                                    + " 行不在本次删除范围内");
+                }
+            }
+        }
+    }
+
+    // ── target=direct ────────────────────────────────────────────────────
+
+    private Map<String, Integer> executeDirectTarget(
+            Connection connection,
+            List<Map<String, Object>> explicitDeletes,
+            String userId
+    ) throws SQLException {
+        Map<String, Integer> deleted = new LinkedHashMap<>();
+        for (Map<String, Object> row : explicitDeletes == null
+                ? List.<Map<String, Object>>of() : explicitDeletes) {
+            String table = text(row.get("table"));
+            String keyField = text(row.get("key_field"));
+            List<?> rawIds = row.get("ids") instanceof List<?> list ? list : List.of();
+            if (table == null || keyField == null || rawIds.isEmpty()) {
+                continue;
+            }
+            checkIdLimit(rawIds);
+            DbUtils.TableMetadata metadata = dbUtils.loadTableMetadata(connection, table);
+            DbUtils.ColumnMetadata keyColumn = requireKeyColumn(metadata, keyField);
+            int count = deleteRecords(connection, metadata, keyColumn, new ArrayList<>(rawIds));
+            deleted.merge(table, count, Integer::sum);
+            writeDeleteLog(userId, TARGET_DIRECT, table, keyColumn.name(), rawIds.size(), count);
+        }
+        return deleted;
+    }
+
+    // ── 执行器：子记录优先的物理删除 ───────────────────────────────────────
+
+    private int deleteRecords(
+            Connection connection,
+            DbUtils.TableMetadata table,
+            DbUtils.ColumnMetadata keyColumn,
+            List<Object> ids
+    ) throws SQLException {
+        int total = 0;
+        for (Object id : ids) {
+            Map<String, Object> condition = new LinkedHashMap<>();
+            condition.put(keyColumn.name(), id);
+            total += dbUtils.delete(connection, table, condition);
+        }
+        return total;
+    }
+
+    // ── 辅助 ─────────────────────────────────────────────────────────────
+
+    private void checkIdLimit(List<?> ids) {
+        if (ids.size() > MAX_DELETE_IDS) {
+            throw new BusinessException(
+                    "单次删除记录数不能超过 " + MAX_DELETE_IDS + " 条，当前 " + ids.size() + " 条");
+        }
+    }
+
+    private DbUtils.ColumnMetadata requireKeyColumn(
+            DbUtils.TableMetadata table,
+            String keyField
+    ) {
+        DbUtils.ColumnMetadata column = dbUtils.getColumn(table, keyField);
+        if (column == null) {
+            throw new BusinessException("主键字段不存在: " + table.requestedName() + "." + keyField);
+        }
+        return column;
+    }
+
+    /**
+     * 按主键列类型生成 IN 列表。values 已经在 :ids 替换处经过类型校验，
+     * 这里统一走 toSqlStringLiteral 转义，数字类型不加引号（设计 §4.2）。
+     */
+    private String literalList(Collection<?> values, DbUtils.ColumnMetadata keyColumn) {
+        if (values.isEmpty()) {
+            // 空集合生成永假条件，避免 IN () 语法错误
+            return "null";
+        }
+        List<String> literals = new ArrayList<>();
+        for (Object value : values) {
+            literals.add(literal(value, keyColumn));
+        }
+        return String.join(", ", literals);
+    }
+
+    private String literal(Object value, DbUtils.ColumnMetadata keyColumn) {
+        if (value == null) {
+            return "null";
+        }
+        String typeName = keyColumn == null ? "" : keyColumn.typeName().toLowerCase(Locale.ROOT);
+        boolean numeric = typeName.contains("int") || typeName.contains("decimal")
+                || typeName.contains("numeric") || typeName.contains("money")
+                || typeName.contains("float") || typeName.contains("real");
+        if (value instanceof Number) {
+            return String.valueOf(value);
+        }
+        String text = String.valueOf(value);
+        if (numeric) {
+            // 类型已校验为数字时才内联，拒绝把非数字塞进数字列
+            if (!text.matches("-?\\d+(\\.\\d+)?")) {
+                throw new BusinessException("主键值类型不正确: " + text);
+            }
+            return text;
+        }
+        return dbUtils.toSqlStringLiteral(text);
+    }
+
+    private void writeDeleteLog(
+            String userId,
+            String moduleCode,
+            String table,
+            String keyField,
+            int requested,
+            int deleted
+    ) {
+        // 技术日志当前阶段只输出结构化摘要，不落库（设计 §8：日志表不在本阶段范围内）
+        System.out.println("[delete-strategy] user=" + userId
+                + " target=" + moduleCode
+                + " table=" + table
+                + " key=" + keyField
+                + " requested=" + requested
+                + " deleted=" + deleted);
+    }
+
+    private long toLong(Object value) {
+        if (value instanceof Number number) {
+            return number.longValue();
+        }
+        if (value == null) {
+            return 0;
+        }
+        try {
+            return Long.parseLong(String.valueOf(value));
+        } catch (NumberFormatException exception) {
+            return 0;
+        }
+    }
+
+    private String text(Object value) {
+        return value == null ? null : String.valueOf(value).trim();
+    }
+
+    private String requireText(String value, String field) {
+        if (value == null || value.isBlank()) {
+            throw new BusinessException(field + " 不能为空");
+        }
+        return value.trim();
+    }
+
+    private void rollback(Connection connection, Exception cause) {
+        try {
+            connection.rollback();
+        } catch (SQLException rollbackException) {
+            cause.addSuppressed(rollbackException);
+        }
+    }
+
+    /** 模块删除目标：保存表元数据 + 主键列。 */
+    private record ModuleTarget(
+            DbUtils.TableMetadata metadata,
+            DbUtils.ColumnMetadata keyColumn
+    ) {
+    }
+
+    /** 计划中的一张表：按“表 + 主键字段 + 主键值”去重（设计 §6.2）。 */
+    private static final class PlannedTable {
+        private final String key;
+        private final DbUtils.TableMetadata metadata;
+        private final DbUtils.ColumnMetadata keyColumn;
+        private final Set<Object> values = new LinkedHashSet<>();
+        private final int depth;
+        private String moduleCode;
+
+        PlannedTable(String key, DbUtils.TableMetadata metadata,
+                     DbUtils.ColumnMetadata keyColumn, int depth) {
+            this.key = key;
+            this.metadata = metadata;
+            this.keyColumn = keyColumn;
+            this.depth = depth;
+        }
+
+        String key() {
+            return key;
+        }
+
+        DbUtils.TableMetadata metadata() {
+            return metadata;
+        }
+
+        DbUtils.ColumnMetadata keyColumn() {
+            return keyColumn;
+        }
+
+        Set<Object> values() {
+            return values;
+        }
+
+        int depth() {
+            return depth;
+        }
+
+        String moduleCode() {
+            return moduleCode;
+        }
+
+        void moduleCode(String value) {
+            this.moduleCode = value;
+        }
+    }
+
+    /** 删除计划：按“表 + 主键字段”归并，值去重；按深度倒序（子记录优先）删除。 */
+    private static final class DeletePlan {
+        private final Map<String, PlannedTable> tables = new LinkedHashMap<>();
+
+        /**
+         * 并入一批待删记录。同一模块同一主键只进清单一次（设计 §5.1、§6.2）。
+         *
+         * @param moduleCode 模块归属；显式删除行传 null（不跑模块 SQL 规则）
+         * @return 该表是否首次进入清单（用于决定是否继续向下展开 cascade）
+         */
+        boolean add(DbUtils.TableMetadata metadata, DbUtils.ColumnMetadata keyColumn,
+                    String moduleCode, List<Object> ids, int depth) {
+            String tableKey = metadata.requestedName().toLowerCase(Locale.ROOT)
+                    + "|" + keyColumn.normalizedName();
+            PlannedTable planned = tables.get(tableKey);
+            boolean created = false;
+            if (planned == null) {
+                planned = new PlannedTable(tableKey, metadata, keyColumn, depth);
+                tables.put(tableKey, planned);
+                created = true;
+            }
+            // 同一物理表既有模块归属又有显式删除时，保留模块归属（模块目标优先）
+            if (moduleCode != null && planned.moduleCode() == null) {
+                planned.moduleCode(moduleCode);
+            }
+            if (ids != null) {
+                for (Object id : ids) {
+                    if (id != null) {
+                        planned.values().add(id);
+                    }
+                }
+            }
+            return created;
+        }
+
+        boolean containsTable(String tableKey) {
+            return tables.containsKey(tableKey);
+        }
+
+        String moduleCodeOfTable(String tableKey) {
+            PlannedTable planned = tables.get(tableKey);
+            return planned == null ? null : planned.moduleCode();
+        }
+
+        List<PlannedTable> tables() {
+            return new ArrayList<>(tables.values());
+        }
+
+        /** 深度大的先删（子记录优先），同深度按加入顺序。 */
+        List<PlannedTable> orderedFromLeaf() {
+            List<PlannedTable> ordered = new ArrayList<>(tables.values());
+            ordered.sort((left, right) -> Integer.compare(right.depth(), left.depth()));
+            return ordered;
+        }
+
+        Set<Object> valuesOf(String tableName) {
+            String normalized = tableName.toLowerCase(Locale.ROOT);
+            for (PlannedTable planned : tables.values()) {
+                if (planned.metadata().requestedName().toLowerCase(Locale.ROOT).equals(normalized)) {
+                    return planned.values();
+                }
+            }
+            return Collections.emptySet();
+        }
+    }
+}
diff --git a/code/fms/fms-api/src/main/java/cn/g3soft/fmsapi/service/DataSaveService.java b/code/fms/fms-api/src/main/java/cn/g3soft/fmsapi/service/DataSaveService.java
index 30527c9f..02da073d 100644
--- a/code/fms/fms-api/src/main/java/cn/g3soft/fmsapi/service/DataSaveService.java
+++ b/code/fms/fms-api/src/main/java/cn/g3soft/fmsapi/service/DataSaveService.java
@@ -31,6 +31,9 @@ public class DataSaveService {
     @Resource
     private DbUtils dbUtils;
 
+    @Resource
+    private DataDeleteService dataDeleteService;
+
     public void save(List<Map<String, Object>> requests) throws SQLException {
         if (requests == null || requests.isEmpty()) {
             throw new BusinessException("保存数据不能为空");
@@ -414,13 +417,12 @@ public class DataSaveService {
             throw new BusinessException("主键字段不能为空: " + tableName);
         }
 
-        executeRows(
-                connection,
-                table,
-                keyColumns,
-                "delete",
-                rows(request, "deletes")
-        );
+        // 分阶段执行（设计 §6.2）：updates → 删除检查 → 物理删除 → inserts，同一事务。
+        // 删除走统一删除服务，显式删除与 cascade 展开合并去重后统一检查。
+        // 普通表没有声明删除目标时沿用旧的逐行删除，保持既有行为。
+        String deleteTarget = ParamUtils.getString(request, "delete_target");
+        List<Map<String, Object>> deleteRows = rows(request, "deletes");
+
         executeRows(
                 connection,
                 table,
@@ -428,6 +430,17 @@ public class DataSaveService {
                 "update",
                 rows(request, "updates")
         );
+        if (deleteTarget != null && !deleteTarget.isBlank() && !deleteRows.isEmpty()) {
+            executeDeletes(connection, request, tableName, keyField, deleteTarget, deleteRows);
+        } else {
+            executeRows(
+                    connection,
+                    table,
+                    keyColumns,
+                    "delete",
+                    deleteRows
+            );
+        }
         executeRows(
                 connection,
                 table,
@@ -437,6 +450,60 @@ public class DataSaveService {
         );
     }
 
+    /**
+     * 通过删除服务执行 saveobjt 的删除行（设计 §6.2）。
+     *
+     * <p>删除目标必须显式声明，不允许以“有没有传 moduleCode”作隐式分支：
+     * {@code delete_target=module} 要求 {@code moduleCode}，{@code delete_target=direct}
+     * 要求 {@code table} / {@code key_field}。两种目标都复用当前事务连接，
+     * 任一检查失败由外层统一回滚。
+     */
+    private void executeDeletes(
+            Connection connection,
+            Map<String, Object> request,
+            String tableName,
+            String keyField,
+            String deleteTarget,
+            List<Map<String, Object>> deleteRows
+    ) {
+        String moduleCode = ParamUtils.getString(request, "moduleCode");
+        List<Object> ids = new ArrayList<>();
+        for (Map<String, Object> row : deleteRows) {
+            Object value = row.get(keyField);
+            if (value != null) {
+                ids.add(value);
+            }
+        }
+        if (ids.isEmpty()) {
+            return;
+        }
+        // 显式删除行统一表述为 {table, key_field, ids}，与 cascade 展开结果按表+主键去重
+        List<Map<String, Object>> explicitDeletes = new ArrayList<>();
+        explicitDeletes.add(Map.of(
+                "table", tableName,
+                "key_field", keyField,
+                "ids", new ArrayList<>(ids)
+        ));
+
+        String target = deleteTarget;
+        if (DataDeleteService.TARGET_MODULE.equalsIgnoreCase(target)) {
+            if (moduleCode == null || moduleCode.isBlank()) {
+                throw new BusinessException("模块删除必须提供 moduleCode");
+            }
+        } else if (DataDeleteService.TARGET_DIRECT.equalsIgnoreCase(target)) {
+            moduleCode = null;
+        } else {
+            throw new BusinessException("删除目标类型必须是 module 或 direct");
+        }
+
+        try {
+            dataDeleteService.deleteWithinTransaction(
+                    connection, target, moduleCode, ids, explicitDeletes, null);
+        } catch (SQLException exception) {
+            throw new SaveObjectException(tableName, "delete", -1, exception);
+        }
+    }
+
     private DbUtils.TableMetadata loadMetadata(
             Connection connection,
             String tableName,
diff --git a/code/fms/fms-api/src/main/java/cn/g3soft/fmsapi/service/FileService.java b/code/fms/fms-api/src/main/java/cn/g3soft/fmsapi/service/FileService.java
index 7c657118..cad9f41c 100644
--- a/code/fms/fms-api/src/main/java/cn/g3soft/fmsapi/service/FileService.java
+++ b/code/fms/fms-api/src/main/java/cn/g3soft/fmsapi/service/FileService.java
@@ -48,6 +48,9 @@ public class FileService {
     @Resource
     private DataSource dataSource;
 
+    @Resource
+    private DataDeleteService dataDeleteService;
+
     /**
      * 本地上传：逐个写磁盘 → 写 DB → 返回元数据列表
      */
@@ -182,7 +185,11 @@ public class FileService {
     }
 
     /**
-     * 删除文件：查 bf_files → 删存储 → 删 DB 行
+     * 删除文件：查 bf_files → 删存储 → 走统一删除执行器删 DB 行（设计 §6.3）。
+     *
+     * <p>bf_files 属于无业务模块的技术表，用 target=direct 只做物理删除，
+     * 不触发 s_relation 与 s_delete_rule。外部对象操作不属于数据库事务：
+     * 对象删除失败时不删数据库行；数据库删除失败时保留可重试的清理记录。
      */
     public void delete(String subid) throws SQLException, IOException, InterruptedException {
         List<Map<String, Object>> rows = dbUtils.loadData("bf_files", "subid = " + subid, null, null);
@@ -199,8 +206,14 @@ public class FileService {
             deleteLocalFile(mapfilename);
         }
 
-        // 删 DB 行
-        deleteDbRow(subid);
+        // 删 DB 行：复用统一直接表删除
+        Connection connection = DataSourceUtils.getConnection(dataSource);
+        try {
+            dataDeleteService.deleteDirect(
+                    connection, "bf_files", "subid", List.of(subid), null);
+        } finally {
+            DataSourceUtils.releaseConnection(connection, dataSource);
+        }
     }
 
     private void deleteLocalFile(String mapfilename) throws IOException {
@@ -248,19 +261,6 @@ public class FileService {
         }
     }
 
-    private void deleteDbRow(String subid) throws SQLException {
-        Connection connection = DataSourceUtils.getConnection(dataSource);
-        try {
-            String sql = "DELETE FROM [bf_files] WHERE [subid] = ?";
-            try (PreparedStatement statement = connection.prepareStatement(sql)) {
-                statement.setLong(1, Long.parseLong(subid));
-                statement.executeUpdate();
-            }
-        } finally {
-            DataSourceUtils.releaseConnection(connection, dataSource);
-        }
-    }
-
     private String extension(String name) {
         if (name == null || !name.contains(".")) {
             return "";
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/FmsApiApplication.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/FmsApiApplication.class
index 559592fc..9a055d80 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/FmsApiApplication.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/FmsApiApplication.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/AuthProperties.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/AuthProperties.class
index 22cfa4af..a5187a9b 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/AuthProperties.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/AuthProperties.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/FileStorageProperties$Local.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/FileStorageProperties$Local.class
index 5ac35469..822c502c 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/FileStorageProperties$Local.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/FileStorageProperties$Local.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/FileStorageProperties$Oss.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/FileStorageProperties$Oss.class
index aba3549e..feb115f3 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/FileStorageProperties$Oss.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/FileStorageProperties$Oss.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/FileStorageProperties.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/FileStorageProperties.class
index 7ca39c05..9098305c 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/FileStorageProperties.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/FileStorageProperties.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/JacksonConfig.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/JacksonConfig.class
index 37408c3f..e57213b4 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/JacksonConfig.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/config/JacksonConfig.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/controller/AuthController.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/controller/AuthController.class
index 6c7b72f2..4d749e7b 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/controller/AuthController.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/controller/AuthController.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/controller/DataController.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/controller/DataController.class
index 25c4e52f..f26a14f2 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/controller/DataController.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/controller/DataController.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/controller/FileController.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/controller/FileController.class
index cd9ccdb5..5bdd23f5 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/controller/FileController.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/controller/FileController.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgContext.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgContext.class
index b441b83e..05b8fe4f 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgContext.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgContext.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDataSourceFactory.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDataSourceFactory.class
index 73a3db58..01c250f1 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDataSourceFactory.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDataSourceFactory.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDataSourceManager$PoolEntry.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDataSourceManager$PoolEntry.class
index c5e35b10..a7514698 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDataSourceManager$PoolEntry.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDataSourceManager$PoolEntry.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDataSourceManager.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDataSourceManager.class
index 3c371400..c3c80f8d 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDataSourceManager.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDataSourceManager.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseConfig.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseConfig.class
index 62e91cad..4aefdc8f 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseConfig.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseConfig.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseConfigLoader.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseConfigLoader.class
index 126443e6..9120d513 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseConfigLoader.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseConfigLoader.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseConfigWatcher.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseConfigWatcher.class
index cfe4f00c..9c18dc14 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseConfigWatcher.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseConfigWatcher.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseProperties$Pool.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseProperties$Pool.class
index b5cb3e35..4caaae3e 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseProperties$Pool.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseProperties$Pool.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseProperties.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseProperties.class
index 6123a420..b88b12ec 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseProperties.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgDatabaseProperties.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgRoutingDataSource.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgRoutingDataSource.class
index 78d12c4f..31944e40 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgRoutingDataSource.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/database/OrgRoutingDataSource.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/AuthenticationException.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/AuthenticationException.class
index e1560d86..e6a0569d 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/AuthenticationException.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/AuthenticationException.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/BusinessException.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/BusinessException.class
index 94af84fa..13e0bdd3 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/BusinessException.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/BusinessException.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/GlobalExceptionHandler.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/GlobalExceptionHandler.class
index 0eea0492..6dc0382c 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/GlobalExceptionHandler.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/GlobalExceptionHandler.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/SaveObjectException.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/SaveObjectException.class
index e523a194..b1e39134 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/SaveObjectException.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/exception/SaveObjectException.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/AuthService.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/AuthService.class
index 46d3a22b..653f5ecd 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/AuthService.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/AuthService.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService$AutoCodeFormat.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService$AutoCodeFormat.class
index db35bf62..415adb7b 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService$AutoCodeFormat.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService$AutoCodeFormat.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService$AutoCodeRule.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService$AutoCodeRule.class
index 9b1b0238..170e3b14 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService$AutoCodeRule.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService$AutoCodeRule.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService$CodeCandidate.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService$CodeCandidate.class
index e8093600..b2d557df 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService$CodeCandidate.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService$CodeCandidate.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService.class
index 17968130..7344de39 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataSaveService.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataService.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataService.class
index 28c8b8c9..631a4e27 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataService.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/DataService.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/ExportHeadBuilder.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/ExportHeadBuilder.class
index a648b5bb..75cc612f 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/ExportHeadBuilder.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/ExportHeadBuilder.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/ExportStyleHandler.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/ExportStyleHandler.class
index d5977c54..d93ba655 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/ExportStyleHandler.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/ExportStyleHandler.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/FileService.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/FileService.class
index a72f53e7..c93d6300 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/FileService.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/FileService.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/LoginLogService.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/LoginLogService.class
index 24b1e7d2..1fb10021 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/LoginLogService.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/LoginLogService.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/SqlPermissionService.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/SqlPermissionService.class
index 695baab7..38d3fc21 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/SqlPermissionService.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/service/SqlPermissionService.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ApiResponse.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ApiResponse.class
index f0537e84..2a5766aa 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ApiResponse.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ApiResponse.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ClientInfo.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ClientInfo.class
index 0ad5d9dd..178049c4 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ClientInfo.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ClientInfo.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ClientInfoExtractor.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ClientInfoExtractor.class
index fc329abc..334490a1 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ClientInfoExtractor.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ClientInfoExtractor.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils$ColumnMetadata.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils$ColumnMetadata.class
index 319f068e..4d0c2298 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils$ColumnMetadata.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils$ColumnMetadata.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils$PageResult.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils$PageResult.class
index 4b450936..e47bf3ef 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils$PageResult.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils$PageResult.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils$TableMetadata.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils$TableMetadata.class
index 4ce69645..d64adc0c 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils$TableMetadata.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils$TableMetadata.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils.class
index 0e8c2ddb..669b7f6d 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/DbUtils.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/IpRegionSearcher.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/IpRegionSearcher.class
index 23cd6142..e1bc47f1 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/IpRegionSearcher.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/IpRegionSearcher.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/IpUtils.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/IpUtils.class
index f20a9e5e..8e837371 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/IpUtils.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/IpUtils.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/JwtUtils$TokenClaims.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/JwtUtils$TokenClaims.class
index e8ad6365..752775dc 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/JwtUtils$TokenClaims.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/JwtUtils$TokenClaims.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/JwtUtils.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/JwtUtils.class
index 6b2812aa..f2ae6fa9 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/JwtUtils.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/JwtUtils.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ParamUtils.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ParamUtils.class
index 12d7c118..779e1855 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ParamUtils.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/ParamUtils.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/StringUtils.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/StringUtils.class
index b485b135..4b26a3bd 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/StringUtils.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/StringUtils.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/UuidV7Generator.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/UuidV7Generator.class
index aeec4597..df2a56e9 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/UuidV7Generator.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/UuidV7Generator.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/contract/IdGeneratorException.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/contract/IdGeneratorException.class
index 39db6908..81bfb7ed 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/contract/IdGeneratorException.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/contract/IdGeneratorException.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/contract/IdGeneratorOptions.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/contract/IdGeneratorOptions.class
index f67aad8a..d7f0b038 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/contract/IdGeneratorOptions.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/contract/IdGeneratorOptions.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/contract/OverCostActionArg.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/contract/OverCostActionArg.class
index c6f83b73..b35764b1 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/contract/OverCostActionArg.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/contract/OverCostActionArg.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/core/SnowWorkerM1.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/core/SnowWorkerM1.class
index 06a6e877..aed62c84 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/core/SnowWorkerM1.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/core/SnowWorkerM1.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/core/SnowWorkerM2.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/core/SnowWorkerM2.class
index 0d4a11dc..40d4112c 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/core/SnowWorkerM2.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/core/SnowWorkerM2.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/idgen/DefaultIdGenerator.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/idgen/DefaultIdGenerator.class
index 3679d9f8..81ba7abd 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/idgen/DefaultIdGenerator.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/idgen/DefaultIdGenerator.class differ
diff --git a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/idgen/IdGenerator.class b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/idgen/IdGenerator.class
index a289499c..9ca7e76a 100644
Binary files a/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/idgen/IdGenerator.class and b/code/fms/fms-api/target/classes/cn/g3soft/fmsapi/utils/snowflake/idgen/IdGenerator.class differ
diff --git a/code/fms/fms-api/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst b/code/fms/fms-api/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst
index 45a05b89..81929d53 100644
--- a/code/fms/fms-api/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst
+++ b/code/fms/fms-api/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst
@@ -2,6 +2,7 @@ cn\g3soft\fmsapi\service\LoginLogService.class
 cn\g3soft\fmsapi\controller\FileController.class
 cn\g3soft\fmsapi\utils\ParamUtils.class
 cn\g3soft\fmsapi\service\ExportService$PreparedExport.class
+cn\g3soft\fmsapi\service\DataDeleteService.class
 cn\g3soft\fmsapi\utils\JwtUtils.class
 cn\g3soft\fmsapi\service\ExportService$1.class
 cn\g3soft\fmsapi\database\OrgDataSourceManager$PoolEntry.class
@@ -22,12 +23,15 @@ cn\g3soft\fmsapi\controller\DataController.class
 cn\g3soft\fmsapi\database\OrgDatabaseConfigLoader.class
 cn\g3soft\fmsapi\database\OrgDatabaseConfig.class
 cn\g3soft\fmsapi\exception\BusinessException.class
+cn\g3soft\fmsapi\service\DataDeleteService$DeletePlan.class
 cn\g3soft\fmsapi\config\FileStorageProperties.class
+cn\g3soft\fmsapi\service\DataDeleteService$PlannedTable.class
 cn\g3soft\fmsapi\config\JacksonConfig.class
 cn\g3soft\fmsapi\service\FileService.class
 cn\g3soft\fmsapi\database\OrgDataSourceFactory.class
 cn\g3soft\fmsapi\service\DataSaveService$CodeCandidate.class
 cn\g3soft\fmsapi\database\OrgContext.class
+cn\g3soft\fmsapi\service\DataDeleteService$ModuleTarget.class
 cn\g3soft\fmsapi\database\OrgDatabaseProperties$Pool.class
 cn\g3soft\fmsapi\utils\snowflake\idgen\IdGenerator.class
 cn\g3soft\fmsapi\service\DataSaveService$AutoCodeRule.class
diff --git a/code/fms/fms-api/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst b/code/fms/fms-api/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst
index aeb035af..dc1af92e 100644
--- a/code/fms/fms-api/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst
+++ b/code/fms/fms-api/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst
@@ -21,6 +21,7 @@ D:\workspace\code\fms\fms-api\src\main\java\cn\g3soft\fmsapi\exception\SaveObjec
 D:\workspace\code\fms\fms-api\src\main\java\cn\g3soft\fmsapi\FmsApiApplication.java
 D:\workspace\code\fms\fms-api\src\main\java\cn\g3soft\fmsapi\service\ActiveSessionRegistry.java
 D:\workspace\code\fms\fms-api\src\main\java\cn\g3soft\fmsapi\service\AuthService.java
+D:\workspace\code\fms\fms-api\src\main\java\cn\g3soft\fmsapi\service\DataDeleteService.java
 D:\workspace\code\fms\fms-api\src\main\java\cn\g3soft\fmsapi\service\DataSaveService.java
 D:\workspace\code\fms\fms-api\src\main\java\cn\g3soft\fmsapi\service\DataService.java
 D:\workspace\code\fms\fms-api\src\main\java\cn\g3soft\fmsapi\service\ExportHeadBuilder.java
diff --git a/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/config/JwtAuthFilterTests.class b/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/config/JwtAuthFilterTests.class
index 3818e35d..b68ad01c 100644
Binary files a/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/config/JwtAuthFilterTests.class and b/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/config/JwtAuthFilterTests.class differ
diff --git a/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/service/ActiveSessionRegistryTests.class b/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/service/ActiveSessionRegistryTests.class
index 6310143e..acc383b6 100644
Binary files a/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/service/ActiveSessionRegistryTests.class and b/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/service/ActiveSessionRegistryTests.class differ
diff --git a/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/service/ExportServiceIntegrationTests.class b/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/service/ExportServiceIntegrationTests.class
index b2ce9c11..42ba670b 100644
Binary files a/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/service/ExportServiceIntegrationTests.class and b/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/service/ExportServiceIntegrationTests.class differ
diff --git a/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/service/ExportServiceTests.class b/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/service/ExportServiceTests.class
index 47e20269..67525ed0 100644
Binary files a/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/service/ExportServiceTests.class and b/code/fms/fms-api/target/test-classes/cn/g3soft/fmsapi/service/ExportServiceTests.class differ
diff --git a/code/fms/fms-vue/src/components/fms-module-edit/FmsModuleEditModal.vue b/code/fms/fms-vue/src/components/fms-module-edit/FmsModuleEditModal.vue
index 3d8efc8f..ec3e0e93 100644
--- a/code/fms/fms-vue/src/components/fms-module-edit/FmsModuleEditModal.vue
+++ b/code/fms/fms-vue/src/components/fms-module-edit/FmsModuleEditModal.vue
@@ -295,9 +295,12 @@ const resolvedWidth = computed(() => {
 /** 保存过程上下文：beforeSave 阶段准备的数据，buildSaveData / afterSave 阶段消费 */
 let saveCtx = { isNew: false, row: null, extraUpdates: [] }
 
-/** 模块保存表（s_module.b_save_table 优先，其次 b_view_table） */
+/**
+ * 模块保存表：只使用 s_module.b_save_table（设计 §6.1）。
+ * 视图表通常不可写，回退到 b_view_table 会让写入在数据库层失败；为空时由 beforeSave 拒绝。
+ */
 function saveTableName() {
-  return String(moduleMeta.value?.b_save_table || moduleMeta.value?.b_view_table || '')
+  return String(moduleMeta.value?.b_save_table || '')
 }
 
 /** 构造完整合并行（含主键；checkbox→0/1、''→null 归一化），供保存前准备与 diff 使用 */
diff --git a/code/fms/fms-vue/src/components/fms-module-list/FmsModuleListPage.vue b/code/fms/fms-vue/src/components/fms-module-list/FmsModuleListPage.vue
index 7522264b..361bd3b4 100644
--- a/code/fms/fms-vue/src/components/fms-module-list/FmsModuleListPage.vue
+++ b/code/fms/fms-vue/src/components/fms-module-list/FmsModuleListPage.vue
@@ -1,9 +1,9 @@
 <script setup>
 import { computed, h, nextTick, onActivated, reactive, ref, shallowRef, useSlots, watch } from 'vue'
 import { useRoute } from 'vue-router'
-import { Columns3, Download, Ellipsis, FileSpreadsheet, RefreshCw, Save } from '@lucide/vue'
-import { Button, Dropdown, Message, Pagination, Spin } from '@/components/ui'
-import { loadDataApi, nextIdApi, pageDataApi, saveObjectApi } from '@/services/api'
+import { Download, Ellipsis, FileSpreadsheet, RefreshCw, RotateCcw, Save } from '@lucide/vue'
+import { Button, ButtonGroup, Dropdown, Message, Pagination, Spin, Tag } from '@/components/ui'
+import { deleteApi, loadDataApi, nextIdApi, pageDataApi, saveObjectApi } from '@/services/api'
 import { exportListApi, loadTotalsApi } from '@/services/exportService'
 import { useI18nStore } from '@/stores/i18n'
 import {
@@ -33,16 +33,22 @@ import FmsAdvancedQueryPanel from './FmsAdvancedQueryPanel.vue'
 import FmsQuerySettingsDrawer from './FmsQuerySettingsDrawer.vue'
 import FmsExportDialog from './FmsExportDialog.vue'
 import {
+  PREF_SCHEMA_TYPES,
   buildDefaultQueryLayout,
+  columnSettingsDelta,
   currentUserId,
+  isEmptyColumnDelta,
   isEmptyDelta,
   layoutDelta,
   loadFieldPower,
   loadModulePref,
+  mergeColumnPref,
   mergeQueryLayout,
   removeModulePref,
+  sameColumnSettings,
   saveModulePref,
 } from './useModulePref'
+import { usePermissionStore } from '@/stores/permissions'
 
 const props = defineProps({
   dataCode: { type: String, default: '' },
@@ -73,6 +79,7 @@ const emit = defineEmits([
 const slots = useSlots()
 const route = useRoute()
 const { t } = useI18nStore()
+const permissions = usePermissionStore()
 const tableRef = ref(null)
 // keep-alive 中的缓存实例必须保留各自的路由上下文，不能跟随全局 route 变化。
 const instanceRoutePath = route.path
@@ -112,6 +119,17 @@ const queryLayout = ref({ area: {}, order: {} })
 const defaultQueryLayout = ref({ area: {}, order: {} })
 // query 界面配置 JSON（s_module_schema.query），「保存为通用」时回写
 const querySchema = shallowRef(null)
+// ── 栏位设置（列宽/顺序）──
+// 基线：进入本页（或保存/重载）时的栏位快照，用于判断「列是否已被调整」。
+// 与 tableRef.getColumnSettings() 的当前值逐项比对，决定工具条上「已调整」操作条是否出现。
+const columnBaseline = shallowRef([])
+const columnDirty = ref(false)
+// 个人层栏位偏好（s_user_module_pref, b_schema_type='view'）是否已存在，决定 insert 还是 update
+const columnPrefRowExists = ref(false)
+// 通用栏位行（s_module_schema.view 展开结果）：个人增量与其比较，「保存为通用」也以它为底
+const columnGlobalRows = shallowRef([])
+// 「保存为通用」会改到所有人的默认视图，限系统管理员（与 /module/* 的 meta.adminOnly 同一判据）
+const canSaveColumnGlobal = computed(() => permissions.isG3soft)
 // 无查询权限的字段（s_user_field_power.b_query = 0），设置抽屉中灰显
 const disabledFields = shallowRef([])
 const keyField = ref('')
@@ -150,6 +168,7 @@ const effectiveRowDraggable = computed(
 )
 
 // ── 外部工具 ──
+// 栏位设置不在此菜单：列宽/顺序改动后由工具条按需浮出操作条承载（见 columnDirty）
 const moreMenuItems = computed(() => [
   {
     key: 'batch-export',
@@ -162,17 +181,6 @@ const moreMenuItems = computed(() => [
     label: t('common.refreshData', '刷新数据'),
     icon: h(RefreshCw, { size: 14 }),
   },
-  {
-    key: 'reset-columns',
-    label: t('common.resetColumnSettings', '恢复栏位设置'),
-    icon: h(Columns3, { size: 14 }),
-  },
-  {
-    key: 'save-column-settings',
-    label: t('common.saveColumnSettings', '保存栏位设置'),
-    icon: h(Save, { size: 14 }),
-    disabled: columnSaving.value,
-  },
 ])
 const cellSlotNames = computed(() => Object.keys(slots).filter((name) => name.startsWith('cell-')))
 // 高级面板可选字段：排除用户在设置中隐藏的字段
@@ -311,6 +319,9 @@ async function loadModuleConfig() {
       if (!fieldById.has(String(item.b_field))) continue
       lists.push(item)
     }
+    // 通用栏位（lists）即「保存为通用」的基线与个人增量的比较基准；
+    // 个人层只叠加宽度与顺序，不增删字段，因此先裁到同一字段集再合并。
+    columnGlobalRows.value = lists
 
     // 查询条件：query JSON（quick 顺序优先）
     const queryRender = buildQueryRender(schemas.query)
@@ -335,7 +346,11 @@ async function loadModuleConfig() {
 
     // 两层配置（系统默认 → 个人）+ 字段查询权限；权限在偏好合并之后裁剪，不得放宽权限
     const userId = currentUserId()
-    const savedPref = await loadModulePref(userId, dataId)
+    // 查询布局（query）与栏位布局（view）各有一份个人层增量，互不影响
+    const [savedPref, savedColumnPref] = await Promise.all([
+      loadModulePref(userId, dataId),
+      loadModulePref(userId, dataId, PREF_SCHEMA_TYPES.view),
+    ])
     const fieldPower = await loadFieldPower(userId, dataId)
     if (getDataCode() !== code) return false
 
@@ -358,6 +373,12 @@ async function loadModuleConfig() {
     defaultQueryLayout.value = buildDefaultQueryLayout(allowedQueries, queryRender.quick)
     queryLayout.value = mergeQueryLayout(defaultQueryLayout.value, savedPref, allowedFields)
 
+    // 栏位：通用（lists）→ 个人层叠加宽度与顺序；个人层不增删字段（通用没有的字段一律忽略）
+    const mergedLists = mergeColumnPref(lists, savedColumnPref)
+    columnPrefRowExists.value = Boolean(savedColumnPref)
+    columnBaseline.value = columnRowsOf(mergedLists)
+    columnDirty.value = false
+
     // 默认条件取全部启用字段：简单查询与高级查询共用同一批启用字段
     const defaultValues = {}
     for (const item of allowedQueries) defaultValues[item.field.b_field] = defaultQueryValue(item)
@@ -371,7 +392,7 @@ async function loadModuleConfig() {
     dataModule.value = runtimeData
     activeFields.value = fields
     activeFieldById.value = fieldById
-    listConfig.value = lists
+    listConfig.value = mergedLists
     queryItems.value = allowedQueries
     viewSchema.value = schemas.view
     editSchema.value = schemas.edit
@@ -667,11 +688,96 @@ function reload() {
   return fetchData()
 }
 
+/* ================= 栏位设置（列宽 / 顺序） =================
+ * 编辑方式：直接在表格上拖拽列宽、拖拽列头换序。
+ * 提交方式：工具条按需浮出「撤销 / 保存为个人 / 保存为通用」——
+ *   拖完才出现，因此平时不占内容区，也不改变表格高度。
+ * 默认落点是个人层（s_user_module_pref, b_schema_type='view'，只存增量），
+ * 「保存为通用」才写 s_module_schema（影响所有人，需要权限）。
+ */
+
+/** 按当前 listConfig 重建列（丢弃未保存的拖拽结果）；等 DOM 更新后再重置虚拟滚动 */
 async function resetColumns() {
   await nextTick()
   if (tableRef.value) tableRef.value.resetColumns()
 }
 
+/** 栏位行 → 用于比对的精简结构（只含字段与宽度，顺序即数组顺序） */
+function columnRowsOf(rows) {
+  return (rows || []).map((row) => ({ b_field: String(row.b_field), b_width: row.b_width }))
+}
+
+/** 表格当前栏位设置（列宽取真实渲染宽度）；表格未就绪时回退到已加载的 listConfig */
+function currentColumnSettings() {
+  const fromTable = tableRef.value?.getColumnSettings?.()
+  if (Array.isArray(fromTable) && fromTable.length) return columnRowsOf(fromTable)
+  return columnRowsOf(listConfig.value)
+}
+
+/** 重新比对当前栏位与基线，决定操作条是否出现 */
+function refreshColumnDirty() {
+  columnDirty.value = !sameColumnSettings(currentColumnSettings(), columnBaseline.value)
+}
+
+/** 表格列变化（拖宽 / 拖序）时由 FmsModuleTable 上抛 */
+function handleColumnsChange() {
+  refreshColumnDirty()
+}
+
+/** 撤销：丢弃未保存的列宽/顺序改动，回到基线 */
+async function undoColumnSettings() {
+  await resetColumns()
+  columnDirty.value = false
+}
+
+/** 保存为个人：只记「相对通用的差异」，通用后续调整仍能透传到这个人 */
+async function saveColumnAsPersonal() {
+  if (loading.value || columnSaving.value || !tableRef.value) return
+  const moduleId = String(dataModule.value?.b_id || '').trim()
+  const userId = currentUserId()
+  if (!moduleId || !userId) return
+
+  const current = currentColumnSettings()
+  const delta = columnSettingsDelta(current, columnGlobalRows.value)
+  // 与通用完全一致 → 没有个人覆盖可言，顺手清掉旧记录，避免留下空壳覆盖
+  if (isEmptyColumnDelta(delta)) {
+    if (columnPrefRowExists.value) {
+      columnSaving.value = true
+      try {
+        await removeModulePref(userId, moduleId, PREF_SCHEMA_TYPES.view)
+        columnPrefRowExists.value = false
+        columnBaseline.value = columnRowsOf(listConfig.value)
+        columnDirty.value = false
+        Message.success('已与通用栏位一致，个人设置已清除')
+      } catch (error) {
+        Message.error('清除个人栏位设置失败：' + (error?.message || error))
+      } finally {
+        columnSaving.value = false
+      }
+    } else {
+      columnBaseline.value = columnRowsOf(listConfig.value)
+      columnDirty.value = false
+    }
+    return
+  }
+
+  columnSaving.value = true
+  try {
+    await saveModulePref(userId, moduleId, delta, columnPrefRowExists.value, PREF_SCHEMA_TYPES.view)
+    columnPrefRowExists.value = true
+    // 保存成功即成为新基线：操作条立即消失，不必等整页重载
+    listConfig.value = mergeColumnPref(columnGlobalRows.value, delta)
+    await resetColumns()
+    columnBaseline.value = columnRowsOf(listConfig.value)
+    columnDirty.value = false
+    Message.success('已保存为个人栏位设置')
+  } catch (error) {
+    Message.error('个人栏位设置保存失败：' + (error?.message || error))
+  } finally {
+    columnSaving.value = false
+  }
+}
+
 async function saveColumnSettings() {
   if (loading.value || columnSaving.value || !tableRef.value) return
   if (typeof tableRef.value.getColumnSettings !== 'function') return
@@ -715,7 +821,11 @@ async function saveColumnSettings() {
       savedListConfig.push({ ...current, b_xh: saved.b_xh, b_width: saved.b_width })
     }
     listConfig.value = savedListConfig
-    Message.success('栏位设置已保存')
+    // 通用已是新值：它同时成为「个人增量」的比较基准与新基线
+    columnGlobalRows.value = savedListConfig
+    columnBaseline.value = columnRowsOf(savedListConfig)
+    columnDirty.value = false
+    Message.success('栏位设置已保存为通用')
   } catch (error) {
     let errorMessage = error
     if (error && error.message) errorMessage = error.message
@@ -751,9 +861,13 @@ function handleCellChange({ row, field }) {
   emit('dirty-change', { count: dirtyRows.value.size })
 }
 
+/**
+ * 写入目标表：只使用 b_save_table（设计 §6.1）。
+ * 视图表通常不可写，回退到 b_view_table 会让写入在数据库层失败，这里直接返回空串由调用方拒绝。
+ */
 function resolveSaveTable() {
   if (!dataModule.value) throw new Error('数据模块尚未加载')
-  return String(dataModule.value.b_save_table || dataModule.value.b_view_table || '')
+  return String(dataModule.value.b_save_table || '')
 }
 
 function dirtyUpdateRows() {
@@ -876,8 +990,12 @@ async function saveChanges() {
 
 async function deleteSelected(rowKeys) {
   if (saving.value || !rowKeys?.length) return
-  const table = resolveSaveTable()
-  if (!table) {
+  const moduleCode = String(dataModule.value?.b_id || '').trim()
+  if (!moduleCode) {
+    Message.error('该模块未配置模块编码，无法删除')
+    return
+  }
+  if (!resolveSaveTable()) {
     Message.error('该模块未配置保存表，无法删除')
     return
   }
@@ -907,13 +1025,14 @@ async function deleteSelected(rowKeys) {
   }
   saving.value = true
   try {
-    await saveObjectApi([
-      {
-        table,
-        key_field: keyField.value,
-        deletes: persistedKeys.map((key) => ({ [keyField.value]: key })),
-      },
-    ])
+    // 统一删除接口：传 moduleCode + ids，由后端读取保存表、展开 cascade、
+    // 执行 restrict 与模块 SQL 规则（设计 §6.1）。前端不再拼 saveobjt 的 deletes 行。
+    // 行键即主键值（resolveRowKey 取 keyField 列），直接作为 ids 提交。
+    await deleteApi({
+      target: 'module',
+      moduleCode,
+      ids: persistedKeys.map((key) => String(key)),
+    })
     // 清除被删行的脏记录
     const deletedSet = new Set(persistedKeys.map((key) => String(key)))
     const remaining = new Map()
@@ -1018,15 +1137,6 @@ async function handleMoreAction({ key }) {
   }
   if (key === 'refresh') {
     await reload()
-    return
-  }
-  if (key === 'reset-columns') {
-    await resetColumns()
-    Message.success(t('common.columnSettingsReset', '已恢复栏位设置'))
-    return
-  }
-  if (key === 'save-column-settings') {
-    await saveColumnSettings()
   }
 }
 
@@ -1244,6 +1354,27 @@ defineExpose({
               />
             </div>
             <div class="list-toolbar__status">{{ statusText }}</div>
+            <!-- 栏位已调整时才浮出的操作条：平时不渲染，因此不占内容区、不改变表格高度。
+                 状态用 Tag（胶囊提示）、动作簇用 ButtonGroup（项目统一的贴合按钮组）。 -->
+            <div v-if="columnDirty" class="list-toolbar__group list-column-bar">
+              <Tag variant="secondary">{{ t('common.columnAdjusted', '列宽或顺序已调整') }}</Tag>
+              <ButtonGroup>
+                <Button type="outline" :disabled="columnSaving" @click="undoColumnSettings">
+                  <RotateCcw :size="14" /> {{ t('common.undo', '撤销') }}
+                </Button>
+                <Button type="outline" :disabled="columnSaving" @click="saveColumnAsPersonal">
+                  {{ t('common.saveAsPersonal', '保存为个人') }}
+                </Button>
+                <Button
+                  v-if="canSaveColumnGlobal"
+                  type="primary"
+                  :disabled="columnSaving"
+                  @click="saveColumnSettings"
+                >
+                  {{ t('common.saveAsGlobal', '保存为通用') }}
+                </Button>
+              </ButtonGroup>
+            </div>
             <div class="list-toolbar__group list-toolbar__group--tools">
               <Button
                 type="outline"
@@ -1292,6 +1423,7 @@ defineExpose({
               @expand="$emit('expand', $event)"
               @cell-change="handleCellChange"
               @row-order-change="handleRowOrderChange"
+              @columns-change="handleColumnsChange"
             >
               <template v-for="slotName in cellSlotNames" :key="slotName" #[slotName]="slotProps">
                 <slot :name="slotName" v-bind="slotProps" />
@@ -1476,6 +1608,14 @@ defineExpose({
   font-size: 16px;
 }
 
+/* 栏位已调整操作条：仅在 columnDirty 时渲染，不占常驻空间。
+   容器不画框、不填色 —— 状态由 Tag 承担、动作由 ButtonGroup 承担，
+   样式（圆角 / 描边 / 间距 / 主题色）全部来自组件库，跟随主题且不会与项目风格脱节。 */
+.list-column-bar {
+  flex: none;
+  gap: 8px;
+}
+
 /* 底部分页条：左总数、右分页器 */
 .list-footer {
   display: flex;
diff --git a/code/fms/fms-vue/src/components/fms-module-list/FmsModuleTable.vue b/code/fms/fms-vue/src/components/fms-module-list/FmsModuleTable.vue
index bc474bdb..3caff8f2 100644
--- a/code/fms/fms-vue/src/components/fms-module-list/FmsModuleTable.vue
+++ b/code/fms/fms-vue/src/components/fms-module-list/FmsModuleTable.vue
@@ -1,4 +1,4 @@
-<script setup>
+<script setup>
 import { computed, h, ref, shallowRef, useSlots, watch } from 'vue'
 import { Checkbox } from '@/components/ui'
 import FmsTable from '@/components/fms-table/FmsTable.vue'
@@ -31,6 +31,8 @@ const emit = defineEmits([
   'expand',
   'cell-change',
   'row-order-change',
+  // 列宽/列顺序变化：栏位设置可能已偏离基线，父级据此刷新「已调整」状态
+  'columns-change',
 ])
 const i18nStore = useI18nStore()
 const { t } = i18nStore
@@ -443,6 +445,16 @@ watch(
   },
 )
 
+/**
+ * FmsTable 回传列宽/列序（v-model:columns 的写入口）。
+ * 显式接管而不直接用 v-model，是为了在写回的同时把「列已变化」上抛：
+ * 父级据此判断栏位设置是否已偏离基线（配置变化触发的 rebuild 不走这里，不会误报）。
+ */
+function onColumnsUpdate(nextColumns) {
+  columns.value = nextColumns
+  emit('columns-change', getColumnSettings())
+}
+
 defineExpose({
   resetColumns,
   refreshLayout,
@@ -457,7 +469,8 @@ defineExpose({
 <template>
   <FmsTable
     ref="tableRef"
-    v-model:columns="columns"
+    :columns="columns"
+    @update:columns="onColumnsUpdate"
     :data-source="dataSource"
     :footer-data="footerData"
     :row-key="rowKey"
diff --git a/code/fms/fms-vue/src/components/fms-module-list/useModulePref.js b/code/fms/fms-vue/src/components/fms-module-list/useModulePref.js
index 3be3469d..77456dfe 100644
--- a/code/fms/fms-vue/src/components/fms-module-list/useModulePref.js
+++ b/code/fms/fms-vue/src/components/fms-module-list/useModulePref.js
@@ -1,14 +1,19 @@
-// 查询布局读写与两层继承合并（系统默认 → 个人）。
+// 布局读写与两层继承合并（系统默认 → 个人）。
 //   s_module_schema    —— 系统默认。查询布局以 query JSON（quick 列表 + 条件）为来源；
-//                         由 schemaRender.applyQueryLayout 在「保存为通用」时回写。
+//                         列宽顺序以 view JSON（columns 节点）为来源。
+//                         分别由 schemaRender.applyQueryLayout / applyColumnSettings 在
+//                         「保存为通用」时回写。
 //   s_user_module_pref —— 个人覆盖（b_schema_type + b_schema_json），只存相对系统默认的增量。
-// 布局只能调整区域与顺序，不得放宽字段权限——合并后仍按字段权限裁剪（开发规范 通用原则 10）。
+// 两种布局（query 查询布局 / view 栏位布局）共用本文件的读写与增量计算，靠 schemaType 区分。
+// 布局只能调整区域、顺序与列宽，不得放宽字段权限——合并后仍按字段权限裁剪（开发规范 通用原则 10）。
 import { loadDataApi, saveObjectApi } from '@/services/api'
 import { escapeSqlText } from '@/components/fms-module-common/queryUtils'
 import { formatLocalDateTime } from '@/components/fms-module-common/fieldUtils'
 import { useAuthStore } from '@/stores/auth'
 
-const SCHEMA_TYPE = 'query'
+/** 个人偏好层可记录的布局类型：query=查询布局，view=列表栏位布局 */
+export const PREF_SCHEMA_TYPES = { query: 'query', view: 'view' }
+const DEFAULT_SCHEMA_TYPE = PREF_SCHEMA_TYPES.query
 const USER_PREF_TABLE = 's_user_module_pref'
 const USER_PREF_KEY = 'b_user_id,b_module_id,b_schema_type'
 
@@ -86,11 +91,126 @@ export function layoutDelta(current, base) {
 
 /** 增量是否为空（无实际覆盖则无需落库） */
 export function isEmptyDelta(delta) {
-  return !delta || (Object.keys(delta.area || {}).length === 0 && Object.keys(delta.order || {}).length === 0)
+  return (
+    !delta ||
+    (Object.keys(delta.area || {}).length === 0 && Object.keys(delta.order || {}).length === 0)
+  )
+}
+
+/* ================= 栏位布局（view）个人层 =================
+ * 与查询布局同构：系统默认（s_module_schema.view 的 columns 节点顺序与 width）
+ * → 个人层增量（s_user_module_pref, b_schema_type='view'）。
+ *
+ * 增量结构：{ schemaVersion: 1, columns: { [b_field]: { width } }, order: [b_field, ...] }
+ *   - columns：逐字段只记「与通用不同的宽度」，同宽不记，保证通用改宽仍能透传；
+ *   - order  ：顺序是全局排列，无法只记「谁和谁换了位」，因此整体记当前顺序。
+ * 个人层只调整顺序与列宽，不得增删字段（开发规范 通用原则 10）。
+ */
+
+/** 栏位行 → 规范化 { b_field, b_width }（忽略无字段的行） */
+function normalizeColumnRows(rows) {
+  return (rows || [])
+    .filter((row) => row && String(row.b_field ?? '') !== '')
+    .map((row) => ({ b_field: String(row.b_field), b_width: row.b_width }))
+}
+
+/** 宽度归一：null / undefined / '' / 非数字一律视为「未设置」，与数字 0 区分开 */
+function widthOf(raw) {
+  if (raw == null || raw === '') return null
+  const value = Number(raw)
+  return Number.isFinite(value) ? value : null
+}
+
+/** 空对象常量：避免逐处内联空字面量 */
+const emptyColumns = Object.freeze({})
+
+/**
+ * 个人层覆盖叠加到通用栏位之上，返回新的栏位行数组。
+ * 个人只改宽度与顺序，不新增字段：通用里没有的字段一律忽略。
+ * @param baseRows 通用栏位行（buildListConfig 结果，含 b_visible/options 等）
+ * @param pref     个人层增量（可能为 null）
+ */
+export function mergeColumnPref(baseRows, pref) {
+  const base = normalizeColumnRows(baseRows)
+  if (!pref) return baseRows || []
+  const widthById = pref.columns || {}
+  const orderList = Array.isArray(pref.order) ? pref.order.map(String) : []
+
+  const known = new Set(base.map((row) => row.b_field))
+  const rank = new Map()
+  orderList.forEach((field, index) => {
+    if (known.has(field)) rank.set(field, index)
+  })
+
+  // 有 order 名次的按名次排；没有的（含未列入 order 的新字段）保持原有相对顺序追加在后
+  const ordered = base
+    .map((row, index) => ({ row, index }))
+    .toSorted((a, b) => {
+      const ra = rank.has(a.row.b_field) ? rank.get(a.row.b_field) : Number.MAX_SAFE_INTEGER
+      const rb = rank.has(b.row.b_field) ? rank.get(b.row.b_field) : Number.MAX_SAFE_INTEGER
+      return ra === rb ? a.index - b.index : ra - rb
+    })
+    .map((item) => item.row)
+
+  // 回到 baseRows 的原始形态（保留 b_visible/options 等），只改顺序与宽度并重编 b_xh
+  const rowByField = new Map((baseRows || []).map((row) => [String(row?.b_field ?? ''), row]))
+  return ordered.map((item, index) => {
+    const original = rowByField.get(item.b_field) || item
+    const override = widthById[item.b_field]
+    const nextWidth = override?.width != null ? widthOf(override.width) : widthOf(original.b_width)
+    return { ...original, b_xh: (index + 1) * 10, b_width: nextWidth }
+  })
+}
+
+/**
+ * 当前栏位设置相对通用默认的增量（只保留差异）。
+ * @param current getColumnSettings() 结果（[{ b_field, b_xh, b_width }]）
+ * @param base    通用栏位行（含 b_field / b_width，数组顺序即通用顺序）
+ */
+export function columnSettingsDelta(current, base) {
+  const baseRows = normalizeColumnRows(base)
+  const curRows = normalizeColumnRows(current)
+  const baseWidth = new Map(baseRows.map((row) => [row.b_field, widthOf(row.b_width)]))
+
+  // 宽度：只记与通用不同、且通用里确实存在的字段
+  const columns = {}
+  for (const row of curRows) {
+    if (!baseWidth.has(row.b_field)) continue
+    const next = widthOf(row.b_width)
+    if (next == null || next === baseWidth.get(row.b_field)) continue
+    columns[row.b_field] = { width: next }
+  }
+
+  // 顺序：与通用一致时不记，避免把通用顺序固化、导致管理员后续调整无法透传
+  const baseOrder = baseRows.map((row) => row.b_field)
+  const curOrder = curRows.map((row) => row.b_field)
+  const sameOrder =
+    baseOrder.length === curOrder.length && baseOrder.every((field, i) => field === curOrder[i])
+
+  const delta = { schemaVersion: 1, columns }
+  if (!sameOrder) delta.order = curOrder
+  return delta
+}
+
+/** 栏位增量是否为空（宽度与顺序都与通用一致 → 无需落库，可清空个人层） */
+export function isEmptyColumnDelta(delta) {
+  if (!delta) return true
+  return Object.keys(delta.columns ?? emptyColumns).length === 0 && !delta.order
+}
+
+/** 当前栏位设置与基线是否一致（列宽或顺序任一不同即为「已调整」） */
+export function sameColumnSettings(current, baseline) {
+  const cur = normalizeColumnRows(current)
+  const base = normalizeColumnRows(baseline)
+  if (cur.length !== base.length) return false
+  return cur.every((row, index) => {
+    const other = base[index]
+    return row.b_field === other.b_field && widthOf(row.b_width) === widthOf(other.b_width)
+  })
 }
 
 /** 读取个人层（s_user_module_pref）某一 schema 类型的覆盖 JSON；无记录或解析失败返回 null */
-export async function loadModulePref(userId, moduleId, schemaType = SCHEMA_TYPE) {
+export async function loadModulePref(userId, moduleId, schemaType = DEFAULT_SCHEMA_TYPE) {
   if (!userId || !moduleId) return null
   const condition =
     `b_user_id = N'${escapeSqlText(userId)}' AND b_module_id = N'${escapeSqlText(moduleId)}' ` +
@@ -116,7 +236,13 @@ function parseRow(row) {
 /**
  * 写个人层覆盖（s_user_module_pref）。后端 saveobject 无 upsert：insert 冲突重试 updates。
  */
-export async function saveModulePref(userId, moduleId, pref, rowExists, schemaType = SCHEMA_TYPE) {
+export async function saveModulePref(
+  userId,
+  moduleId,
+  pref,
+  rowExists,
+  schemaType = DEFAULT_SCHEMA_TYPE,
+) {
   if (!userId || !moduleId) return false
   const row = {
     b_user_id: userId,
@@ -143,7 +269,7 @@ export async function saveModulePref(userId, moduleId, pref, rowExists, schemaTy
  * 删除某层覆盖（「恢复默认」即删除个人层，回落到系统/企业层或系统默认）。
  * schemaType 为空数组则删除该模块全部类型（供「恢复出厂」等管理操作使用）。
  */
-export async function removeModulePref(userId, moduleId, schemaType = SCHEMA_TYPE) {
+export async function removeModulePref(userId, moduleId, schemaType = DEFAULT_SCHEMA_TYPE) {
   if (!userId || !moduleId) return false
   const keys = Array.isArray(schemaType) ? schemaType : [schemaType]
   const deletes = keys.map((type) => ({
@@ -171,4 +297,4 @@ export async function loadFieldPower(userId, moduleId) {
     power.set(String(row.b_field_id), Number(row.b_query) === 0 ? 0 : 1)
   }
   return power
-}
\ No newline at end of file
+}
diff --git a/code/fms/fms-vue/src/services/api.js b/code/fms/fms-vue/src/services/api.js
index 3f7d12e9..feec4ee7 100644
--- a/code/fms/fms-vue/src/services/api.js
+++ b/code/fms/fms-vue/src/services/api.js
@@ -58,6 +58,15 @@ export function saveObjectApi(requests) {
   return post('/data/saveobjt', requests)
 }
 
+/**
+ * 统一删除接口。
+ * 模块数据传 { target: 'module', moduleCode, ids }；
+ * 受控后端服务传 { target: 'direct', table, key_field, ids }。
+ */
+export function deleteApi(params) {
+  return post('/data/delete', params)
+}
+
 /**
  * 获取下一个雪花 ID；传入 count 可批量获取指定数量的 ID（返回数组）。
  */
diff --git a/code/fms/fms-vue/src/views/login/index.vue b/code/fms/fms-vue/src/views/login/index.vue
index 49b2c9a3..e26d6e74 100644
--- a/code/fms/fms-vue/src/views/login/index.vue
+++ b/code/fms/fms-vue/src/views/login/index.vue
@@ -146,11 +146,13 @@ function onFailed() {
             {{ loginHint }}
           </div>
 
-          <!-- 表单 -->
+          <!-- 表单：登录页固定上下结构（label 在上、控件在下），
+               不跟随 App.vue 的「中文横向 / 其他语言纵向」全局切换 -->
           <Form
             class="login-form"
             :model="formModel"
             :rules="formRules"
+            layout="vertical"
             :gap="20"
             @submit="onSubmit"
             @submit-failed="onFailed"
diff --git a/code/fms/fms-vue/src/views/module/module-management/ModuleRelationPanel.vue b/code/fms/fms-vue/src/views/module/module-management/ModuleRelationPanel.vue
index 6dff8272..0e744c16 100644
--- a/code/fms/fms-vue/src/views/module/module-management/ModuleRelationPanel.vue
+++ b/code/fms/fms-vue/src/views/module/module-management/ModuleRelationPanel.vue
@@ -6,11 +6,12 @@
  *   b_source_module_id + b_source_field → b_target_module_id + b_target_field，
  *   另有 b_relation_type（one_to_one / one_to_many / many_to_one）、b_on_delete、b_canuse、b_xh。
  *
- * 删除行为（两列）：
- *   - 「删除连带」写 s_relation.b_on_delete：删源记录时对目标行不连带 / 连带删除 / 连带归档；
- *     多对一是「多条指向同一条」，只允许不连带（连带会波及其他引用方）。
- *   - 「有引用时拒绝删除」不写 s_relation：勾选时在 refRules 草稿（s_rule，scope_type='relation'）
- *     里增/删一条引用规则，由父级随保存一并提交。
+ * 删除行为：由 s_relation.b_on_delete 表达，三值 restrict / cascade / none：
+ *   - restrict：被引用方仍有外部引用时拒绝删除（新建关系的默认值）；
+ *   - cascade：引用方记录加入本次物理删除清单；
+ *   - none：不自动处理关联记录。
+ *   多对一不再被硬编码禁止 cascade（设计 §3.2）：是否允许级联由配置和业务语义决定，
+ *   后端负责检查环路、重复记录和删除层级。删除行为的编辑来源收敛到「删除策略」面板。
  *
  * 方向性：上区只编辑「本模块作为源」的关系（父级已按 b_source_module_id 拆好）；
  * 下区只读展示「其他模块指向本模块」的引用，避免对方配置的关系完全不可见。
@@ -22,10 +23,9 @@ import { computed, nextTick, reactive, ref, shallowRef, watch } from 'vue'
 import { Plus, Trash2 } from '@lucide/vue'
 import { Button, Message, Spin } from '@/components/ui'
 import FmsTable from '@/components/fms-table/FmsTable.vue'
-import { loadDataApi, nextIdApi } from '@/services/api'
+import { loadDataApi } from '@/services/api'
 import { createTempId } from '@/utils/common'
 import { sqlStringLiteral } from './utils'
-import { createRefRuleRow, isCompleteRelationKey, relationScopeId } from './ruleUtils'
 
 const props = defineProps({
   /** 当前模块编码：源侧关系的 b_source_module_id */
@@ -36,16 +36,13 @@ const props = defineProps({
   modules: { type: Array, default: () => [] },
   /** 其他模块指向本模块的引用行（只读展示） */
   reverseRows: { type: Array, default: () => [] },
+  /** 删除行为由「删除策略」面板编辑时为 true，本面板该列改只读 */
+  deletePolicyReadonly: { type: Boolean, default: false },
   loading: { type: Boolean, default: false },
 })
 
 /** 当前模块作为源的关系行（s_relation），父级 v-model 绑定 relations */
 const relations = defineModel({ type: Array, default: () => [] })
-/**
- * 关系上的引用规则草稿（s_rule，scope_type='relation'），父级 v-model:ref-rules 绑定。
- * 它不属于 s_relation：勾选「有引用时拒绝删除」时在这里增/删行，走规则表的正常 diff。
- */
-const refRules = defineModel('refRules', { type: Array, default: () => [] })
 
 const RELATION_TYPE_OPTIONS = [
   { label: '一对一', value: 'one_to_one' },
@@ -55,29 +52,16 @@ const RELATION_TYPE_OPTIONS = [
 const RELATION_TYPE_VALUES = RELATION_TYPE_OPTIONS.map((item) => item.value)
 const RELATION_TYPE_LABELS = new Map(RELATION_TYPE_OPTIONS.map((item) => [item.value, item.label]))
 
-/** 删除连带策略：连带删除/连带归档只在源→目标（一对多 / 一对一）上成立 */
+/** 关联删除处理：三值，多对一同样允许配置 cascade（设计 §3.2） */
 const DELETE_POLICY_OPTIONS = [
-  { label: '不连带', value: 'none' },
+  { label: '拒绝删除（有引用）', value: 'restrict' },
   { label: '连带删除', value: 'cascade' },
-  { label: '连带归档', value: 'archive' },
+  { label: '不处理', value: 'none' },
 ]
 const DELETE_POLICY_VALUES = DELETE_POLICY_OPTIONS.map((item) => item.value)
-/** 关系主键列（改动即换业务键，挂在旧键上的引用规则必须作废） */
-const KEY_COLUMNS = new Set(['b_source_field', 'b_target_module_id', 'b_target_field'])
-
-function isManyToOne(row) {
-  return String(row?.b_relation_type ?? '') === 'many_to_one'
-}
 
 /* ================= 行本地派生列 ================= */
-// FmsTable 的行身份用 _rowKey；_hasRefRule / _refScopeId 是引用规则勾选态与旧业务键的记忆，
-// 三者都是 _ 前缀：不落 s_relation、不参与 diff 与脏判定，加载回填不会置脏
-function hasRefRule(row) {
-  if (!isCompleteRelationKey(row)) return 0
-  const key = relationScopeId(row)
-  return refRules.value.some((rule) => String(rule.b_scope_id ?? '') === key) ? 1 : 0
-}
-
+// FmsTable 的行身份用 _rowKey；_ 前缀不落 s_relation、不参与 diff 与脏判定
 function syncRelationRows() {
   let changed = false
   for (const row of relations.value || []) {
@@ -85,51 +69,11 @@ function syncRelationRows() {
       row._rowKey = createTempId()
       changed = true
     }
-    const nextKey = isCompleteRelationKey(row)
-      ? relationScopeId(row)
-      : String(row._refScopeId ?? '')
-    if (row._refScopeId !== nextKey) {
-      row._refScopeId = nextKey
-      changed = true
-    }
-    const nextRef = hasRefRule(row)
-    if (row._hasRefRule !== nextRef) {
-      row._hasRefRule = nextRef
-      changed = true
-    }
   }
   if (changed) relations.value = [...relations.value]
 }
 
-watch([() => relations.value, () => refRules.value], syncRelationRows, {
-  deep: true,
-  immediate: true,
-})
-
-/** 勾选态与规则草稿的联动：勾上建行（先取雪花号）、取消删行 */
-async function setRefRule(row, enabled) {
-  const key = relationScopeId(row)
-  if (!key || !isCompleteRelationKey(row)) {
-    row._hasRefRule = 0
-    return
-  }
-  const exists = refRules.value.some((rule) => String(rule.b_scope_id ?? '') === key)
-  if (enabled && !exists) {
-    const idRes = await nextIdApi()
-    refRules.value = [...refRules.value, createRefRuleRow(key, String(idRes?.data ?? ''))]
-  } else if (!enabled && exists) {
-    refRules.value = refRules.value.filter((rule) => String(rule.b_scope_id ?? '') !== key)
-  }
-}
-
-/** 按业务键删掉引用规则（删行 / 换主键时调用） */
-function removeRefRulesOf(keys) {
-  const set = new Set(keys.filter(Boolean).map(String))
-  if (!set.size) return false
-  const before = refRules.value.length
-  refRules.value = refRules.value.filter((rule) => !set.has(String(rule.b_scope_id ?? '')))
-  return refRules.value.length !== before
-}
+watch(() => relations.value, syncRelationRows, { deep: true, immediate: true })
 
 /* ================= 模块选项与名称解析 ================= */
 const moduleById = computed(
@@ -256,22 +200,15 @@ const columns = shallowRef([
   },
   {
     dataIndex: 'b_on_delete',
-    title: '删除连带',
-    width: 130,
-    // 多对一是「多条指向同一条」：删源连带删目标会波及其他引用方，只允许不连带
+    title: '关联删除处理',
+    width: 150,
+    // 三值对多对一同样开放（设计 §3.2）：不再按关系类型禁用 cascade
     editor: {
       type: 'select',
       options: DELETE_POLICY_OPTIONS,
-      disabled: (row) => isManyToOne(row),
+      disabled: () => props.deletePolicyReadonly,
     },
   },
-  {
-    dataIndex: '_hasRefRule',
-    title: '有引用时拒绝删除',
-    width: 140,
-    align: 'center',
-    editor: { type: 'checkbox', disabled: (row) => !isCompleteRelationKey(row) },
-  },
   {
     dataIndex: 'b_canuse',
     title: '启用',
@@ -313,25 +250,6 @@ function onCellChange(row, col) {
     row.b_target_field = null
     void ensureTargetFields(row.b_target_module_id)
   }
-  // 关系类型切到多对一时连带策略不再成立，清回不连带
-  if (dataIndex === 'b_relation_type' && isManyToOne(row) && row.b_on_delete !== 'none') {
-    row.b_on_delete = 'none'
-    Message.warning('多对一关系不支持连带删除/连带归档，已重置为不连带')
-  }
-  // 勾选/取消「有引用时拒绝删除」：在规则草稿里增/删一条引用规则
-  if (dataIndex === '_hasRefRule') {
-    void setRefRule(row, row._hasRefRule === 1)
-  }
-  // 关系主键列改动 → 业务键变了，挂在旧键上的引用规则必须作废（否则库里留下孤儿规则）
-  if (KEY_COLUMNS.has(dataIndex)) {
-    const prevKey = String(row._refScopeId ?? '')
-    const nextKey = isCompleteRelationKey(row) ? relationScopeId(row) : ''
-    if (prevKey && prevKey !== nextKey) {
-      const removed = removeRefRulesOf([prevKey])
-      row._hasRefRule = 0
-      if (removed) Message.info('关系主键已变化，「有引用时拒绝删除」已取消，请重新勾选')
-    }
-  }
   // 行对象已就地 patch，换新数组引用触发表格重渲染
   relations.value = [...relations.value]
 }
@@ -345,7 +263,8 @@ async function addRow() {
     b_target_module_id: null,
     b_target_field: null,
     b_relation_type: 'many_to_one',
-    b_on_delete: 'none',
+    // 新建关系默认 restrict：被引用时拒绝删除（设计 §3.1）
+    b_on_delete: 'restrict',
     b_canuse: 1,
     b_xh: (relations.value.length + 1) * 10,
   }
@@ -358,8 +277,6 @@ async function addRow() {
 
 function removeRow(row) {
   relations.value = relations.value.filter((item) => item !== row)
-  // 关系行没了，挂在它上面的引用规则也要一起消失
-  removeRefRulesOf([row._refScopeId])
   if (String(row._rowKey) === String(activeKey.value)) activeKey.value = null
   selectedRowKeys.value = selectedRowKeys.value.filter((key) => key !== String(row._rowKey))
 }
@@ -369,9 +286,7 @@ function batchDelete() {
   const keys = selectedRowKeys.value
   if (!keys.length) return
   const delSet = new Set(keys.map(String))
-  const removed = relations.value.filter((row) => delSet.has(String(row._rowKey)))
   relations.value = relations.value.filter((row) => !delSet.has(String(row._rowKey)))
-  removeRefRulesOf(removed.map((row) => row._refScopeId))
   selectedRowKeys.value = []
   if (activeKey.value && delSet.has(String(activeKey.value))) activeKey.value = null
   Message.success(`已删除 ${keys.length} 条关联`)
@@ -414,7 +329,7 @@ function relationKeyOf(row) {
     .join('|')
 }
 
-/** 保存前校验：四列非空、关系类型合法、组合不重复、删除连带合法（空列会撞行身份，落库即主键冲突） */
+/** 保存前校验：四列非空、关系类型合法、组合不重复、删除处置合法（空列会撞行身份，落库即主键冲突） */
 function validate() {
   const errors = []
   const seen = new Set()
@@ -426,11 +341,11 @@ function validate() {
     if (!RELATION_TYPE_VALUES.includes(String(row.b_relation_type ?? ''))) {
       errors.push(`${label}：关系类型不合法`)
     }
-    const policy = String(row.b_on_delete ?? 'none')
+    // 三值对多对一同样合法（设计 §3.2）：不再按关系类型额外限制。
+    // 存量行可能没有 b_on_delete（列晚于数据），按历史默认 none 兜底，不阻断保存。
+    const policy = String(row.b_on_delete ?? '') || 'none'
     if (!DELETE_POLICY_VALUES.includes(policy)) {
-      errors.push(`${label}：删除连带取值不合法`)
-    } else if (policy !== 'none' && isManyToOne(row)) {
-      errors.push(`${label}：多对一关系不支持连带删除/连带归档`)
+      errors.push(`${label}：关联删除处理取值不合法`)
     }
     const key = relationKeyOf(row)
     if (seen.has(key)) errors.push(`${label}：与前面的关联重复`)
diff --git a/code/fms/fms-vue/src/views/module/module-management/ModuleRuleEditModal.vue b/code/fms/fms-vue/src/views/module/module-management/ModuleRuleEditModal.vue
index 5b5889c3..8363bc59 100644
--- a/code/fms/fms-vue/src/views/module/module-management/ModuleRuleEditModal.vue
+++ b/code/fms/fms-vue/src/views/module/module-management/ModuleRuleEditModal.vue
@@ -1,24 +1,16 @@
 <script setup>
 /**
- * 删除规则编辑弹窗（s_rule）。
+ * 删除 SQL 规则编辑弹窗（s_delete_rule）。
  *
  * 规则没有名称/编码，界面上只填"什么情况不许删"和"拦下来说什么"：
- *   - 勾条件：复用高级查询抽屉（FmsAdvancedQueryPanel）编辑，保存为 {"kind":"dsl","expr":AST}，
- *     提示文案可留空（引擎按条件自动生成人话）；
- *   - 写 SQL：文本直存，`:ids` 会自动替换为待删记录 id，查出有结果即拦截；提示文案必填。
+ *   - b_sql：只读查询，用 :ids 标记本次待删记录 id；查出有结果即拦截；
+ *   - b_message：拦下时给用户看的提示文案（第一阶段固定文案，不做占位符替换）。
  * 主键 b_id 在打开弹窗前由面板取号，本弹窗不涉及。
  * 编辑对象是父级传入的行副本，取消不污染草稿。
  */
 import { computed, ref, watch } from 'vue'
-import { Button, Form, FormItem, Input, Modal, Radio, RadioGroup, Switch } from '@/components/ui'
-import FmsAdvancedQueryPanel from '@/components/fms-module-list/FmsAdvancedQueryPanel.vue'
-import {
-  advancedQueryFromAst,
-  buildAdvancedAst,
-  describeAdvancedQuery,
-} from '@/components/fms-module-common/queryUtils'
-import { useI18nStore } from '@/stores/i18n'
-import { RULE_HOOK_DELETE, itemMapOf, parseRulePredicate } from './ruleUtils'
+import { Button, Form, FormItem, Input, Modal, Switch } from '@/components/ui'
+import { IDS_PLACEHOLDER } from './ruleUtils'
 
 const props = defineProps({
   open: { type: Boolean, default: false },
@@ -26,97 +18,59 @@ const props = defineProps({
   row: { type: Object, default: null },
   /** 新增还是编辑：只影响标题 */
   isNew: { type: Boolean, default: false },
-  /** 条件面板 items（当前模块字段 + 查询配置） */
-  items: { type: Array, default: () => [] },
 })
 const emit = defineEmits(['update:open', 'ok'])
 
-const { t } = useI18nStore()
-
-const RULE_TYPE_OPTIONS = [
-  { value: 'dsl', label: '勾条件' },
-  { value: 'sql', label: '写 SQL' },
-]
-
-const ruleType = ref('dsl')
-const conditionState = ref({ nodes: [], groups: [] })
-const conditionOpen = ref(false)
-const conditionDegraded = ref(false)
 const sqlText = ref('')
-const conditionError = ref('')
+const messageText = ref('')
 const sqlError = ref('')
+const messageError = ref('')
 
-const itemByField = computed(() => itemMapOf(props.items))
-const conditionSummary = computed(() =>
-  describeAdvancedQuery(conditionState.value, itemByField.value, t),
-)
 const modalTitle = computed(() => (props.isNew ? '新增删除规则' : '编辑删除规则'))
 
-// 每次打开按当前行还原表单（predicate 三态 → 类型 + 各自内容）
+// 每次打开按当前行还原表单
 watch(
   () => [props.open, props.row],
   () => {
     if (!props.open || !props.row) return
-    const parsed = parseRulePredicate(props.row)
-    ruleType.value = parsed.kind === 'sql' ? 'sql' : 'dsl'
-    sqlText.value = parsed.kind === 'sql' ? parsed.sql : ''
-    if (parsed.kind === 'dsl') {
-      const state = advancedQueryFromAst(parsed.expr)
-      conditionState.value = { nodes: state.nodes, groups: state.groups }
-      conditionDegraded.value = state.degraded
-    } else {
-      conditionState.value = { nodes: [], groups: [] }
-      conditionDegraded.value = false
-    }
-    conditionError.value = ''
+    sqlText.value = String(props.row.b_sql ?? '')
+    messageText.value = String(props.row.b_message ?? '')
     sqlError.value = ''
+    messageError.value = ''
   },
   { immediate: true },
 )
 
-function onTypeChange() {
-  conditionError.value = ''
-  sqlError.value = ''
-}
-
-function onConditionChange() {
-  conditionError.value = ''
-}
-
-function onConditionApply() {
-  conditionOpen.value = false
-}
-
 function close() {
   emit('update:open', false)
 }
 
-async function onOk() {
+function onOk() {
   const row = props.row
   if (!row) return close()
-  conditionError.value = ''
   sqlError.value = ''
+  messageError.value = ''
 
-  if (ruleType.value === 'sql') {
-    const sql = sqlText.value.trim()
-    if (!sql) {
-      sqlError.value = '请填写规则 SQL'
-      return
-    }
-    if (!String(row.b_message ?? '').trim()) {
-      sqlError.value = '写 SQL 的规则必须填写提示文案'
-      return
-    }
-    row.b_predicate = sql
-  } else {
-    const ast = buildAdvancedAst(conditionState.value)
-    if (!(ast.children || []).length) {
-      conditionError.value = '勾条件规则至少要有一个条件'
-      return
-    }
-    row.b_predicate = JSON.stringify({ kind: 'dsl', expr: ast })
+  const sql = sqlText.value.trim()
+  if (!sql) {
+    sqlError.value = '请填写规则 SQL'
+    return
   }
-  row.b_hook = RULE_HOOK_DELETE
+  if (!/^(select|with)\b/i.test(sql)) {
+    sqlError.value = '规则 SQL 必须是只读查询（以 select 或 with 开头）'
+    return
+  }
+  if (!sql.includes(IDS_PLACEHOLDER)) {
+    sqlError.value = `规则 SQL 必须包含 ${IDS_PLACEHOLDER} 标记，用于限定本次待删记录`
+    return
+  }
+  if (!messageText.value.trim()) {
+    messageError.value = '请填写提示文案'
+    return
+  }
+
+  row.b_sql = sql
+  row.b_message = messageText.value.trim()
   emit('ok', row)
   emit('update:open', false)
 }
@@ -130,48 +84,22 @@ async function onOk() {
     centered
     :resizable="false"
     :fullscreen="false"
-    :mask-closable="false"
+    :mask-closable="true"
     @update:open="(value) => emit('update:open', value)"
     @ok="onOk"
   >
     <Form v-if="row" :model="row" :columns="1">
-      <FormItem label="规则类型" name="_rule_type">
-        <RadioGroup v-model="ruleType" @change="onTypeChange">
-          <Radio v-for="option in RULE_TYPE_OPTIONS" :key="option.value" :value="option.value">
-            {{ option.label }}
-          </Radio>
-        </RadioGroup>
-      </FormItem>
-
       <FormItem
-        v-if="ruleType === 'dsl'"
-        label="判定条件"
-        name="_condition"
-        :validate-status="conditionError ? 'error' : ''"
-        :help="conditionError"
-      >
-        <div class="mre-condition">
-          <span class="mre-condition__text">{{ conditionSummary || '尚未配置条件' }}</span>
-          <Button type="outline" @click="conditionOpen = true">编辑条件</Button>
-        </div>
-        <div v-if="conditionDegraded" class="mre-condition__warn">
-          原条件含多层分组，已按单层展开，保存前请确认
-        </div>
-      </FormItem>
-
-      <FormItem
-        v-else
         label="规则 SQL"
-        name="_sql"
+        name="b_sql"
         :validate-status="sqlError ? 'error' : ''"
         :help="sqlError"
-        extra=":ids 会自动替换为本次待删记录的 id 列表；查出有结果即拦截，每次执行都会记技术日志"
       >
         <Input
           type="textarea"
-          :rows="6"
+          :rows="7"
           :model-value="sqlText"
-          placeholder="select b_id from bill where b_id in (:ids) and b_settled = 1"
+          placeholder="select b_id from cw_receipt where b_id in (:ids) and b_status in ('审核中', '已生效')"
           @update:model-value="(value) => (sqlText = value)"
         />
       </FormItem>
@@ -179,16 +107,13 @@ async function onOk() {
       <FormItem
         label="提示文案"
         name="b_message"
-        :extra="
-          ruleType === 'sql'
-            ? '写 SQL 时必填，可用 {列名} 引用查询结果'
-            : '留空则由系统按条件自动生成'
-        "
+        :validate-status="messageError ? 'error' : ''"
+        :help="messageError"
       >
         <Input
-          :model-value="row.b_message"
-          :placeholder="ruleType === 'sql' ? '如：单据 {b_no} 已销账，不能删除' : '可留空'"
-          @update:model-value="(value) => (row.b_message = value)"
+          :model-value="messageText"
+          placeholder="如：单据已审核或已生效，不能删除"
+          @update:model-value="(value) => (messageText = value)"
         />
       </FormItem>
 
@@ -200,36 +125,9 @@ async function onOk() {
       </FormItem>
     </Form>
 
-    <!-- 条件抽屉：挂在弹窗之上（滚动锁是引用计数，关闭抽屉不会解锁弹窗） -->
-    <FmsAdvancedQueryPanel
-      v-model="conditionState"
-      v-model:open="conditionOpen"
-      :items="items"
-      @apply="onConditionApply"
-      @update:model-value="onConditionChange"
-    />
+    <template #footer>
+      <Button @click="close">取消</Button>
+      <Button type="primary" @click="onOk">确定</Button>
+    </template>
   </Modal>
 </template>
-
-<style lang="scss" scoped>
-.mre-condition {
-  display: flex;
-  align-items: center;
-  gap: 12px;
-  min-width: 0;
-}
-
-.mre-condition__text {
-  flex: 1;
-  min-width: 0;
-  color: var(--fms-text);
-  font-size: var(--fms-font-size);
-  overflow-wrap: anywhere;
-}
-
-.mre-condition__warn {
-  margin-top: 6px;
-  color: var(--fms-warning, #d97706);
-  font-size: 12px;
-}
-</style>
diff --git a/code/fms/fms-vue/src/views/module/module-management/ModuleRulePanel.vue b/code/fms/fms-vue/src/views/module/module-management/ModuleRulePanel.vue
index 78255963..f301e476 100644
--- a/code/fms/fms-vue/src/views/module/module-management/ModuleRulePanel.vue
+++ b/code/fms/fms-vue/src/views/module/module-management/ModuleRulePanel.vue
@@ -1,62 +1,33 @@
 <script setup>
 /**
- * 模块删除规则面板（s_rule，scope_type='module'）：当前模块下"什么情况不许删"的规则表。
+ * 删除 SQL 规则面板（s_delete_rule）：当前模块下"什么情况不许删"的规则表。
  *
- * 规则没有名称/编码：列表靠内容自述识别——勾条件显示条件中文摘要，写 SQL 显示它的提示文案，
+ * 规则没有名称/编码：列表靠内容自述识别——优先显示提示文案（人话），没填时显示 SQL 片段；
  * 主键是新增时取号的雪花 b_id（IT 不可见）。
  *
- * 数据契约：默认 v-model 与父级 rules 双向绑定（父级另持 rules_org 基线用于保存 diff）；
- * 关系上的引用规则（scope_type='relation'）不在本面板编辑，只在只读区展示并可跳转到模块关联。
+ * 数据契约：默认 v-model 与父级 rules 双向绑定（父级另持 rules_org 基线用于保存 diff）。
+ * 关系上的关联处置（restrict / cascade / none）由「关联删除处理」面板维护，不在本面板编辑。
  *
- * 列派生说明：_rowKey / _typeText / _labelText 都是界面派生列（_ 前缀不落库、不判脏），
- * 由 watch 就地补齐后换数组引用触发表格刷新。
+ * 列派生说明：_rowKey / _labelText 是界面派生列（_ 前缀不落库、不判脏）。
  */
 import { computed, ref, shallowRef, watch } from 'vue'
 import { Plus, Trash2 } from '@lucide/vue'
 import { Button, Message, Spin } from '@/components/ui'
 import FmsTable from '@/components/fms-table/FmsTable.vue'
 import { nextIdApi } from '@/services/api'
-import { useI18nStore } from '@/stores/i18n'
 import { createTempId } from '@/utils/common'
 import ModuleRuleEditModal from './ModuleRuleEditModal.vue'
-import {
-  REF_RULE_HINT,
-  buildRuleQueryItems,
-  createRuleRow,
-  itemMapOf,
-  parseRelationScopeId,
-  parseRulePredicate,
-  ruleHasCondition,
-  ruleLabel,
-  ruleTypeText,
-} from './ruleUtils'
+import { createRuleRow, ruleHasSql, ruleIsReadOnlySql, ruleLabel } from './ruleUtils'
 
 const props = defineProps({
-  /** 当前模块编码：规则的 b_scope_id */
+  /** 当前模块编码：规则的 b_module_id */
   moduleId: { type: String, default: '' },
-  /** 当前模块字段（勾条件的可选字段） */
-  fields: { type: Array, default: () => [] },
-  /** 查询配置 JSON：字段的操作符 / 控件 / 选项从它继承 */
-  querySchema: { type: Object, default: () => ({}) },
-  /** 其他模块指向本模块的关系上挂的引用规则（只读展示） */
-  refRulesReverse: { type: Array, default: () => [] },
-  /** 全量模块：把引用规则里的模块编码解析成名称 */
-  modules: { type: Array, default: () => [] },
   loading: { type: Boolean, default: false },
 })
 
-/** 当前模块的删除规则行（s_rule，scope_type='module'），父级 v-model 绑定 rules */
+/** 当前模块的删除规则行（s_delete_rule），父级 v-model 绑定 rules */
 const rules = defineModel({ type: Array, default: () => [] })
 
-/** navigate：跳到关系所属模块（父级决定切 tab 还是切模块） */
-const emit = defineEmits(['navigate'])
-
-const { t } = useI18nStore()
-
-/** 条件面板 items 与字段索引（勾条件的字段下拉与中文摘要共用） */
-const items = computed(() => buildRuleQueryItems(props.fields, props.querySchema))
-const itemByField = computed(() => itemMapOf(items.value))
-
 /* ================= 派生列 ================= */
 function syncRuleRows() {
   let changed = false
@@ -65,12 +36,7 @@ function syncRuleRows() {
       row._rowKey = createTempId()
       changed = true
     }
-    const typeText = ruleTypeText(row)
-    if (row._typeText !== typeText) {
-      row._typeText = typeText
-      changed = true
-    }
-    const labelText = ruleLabel(row, itemByField.value, t)
+    const labelText = ruleLabel(row)
     if (row._labelText !== labelText) {
       row._labelText = labelText
       changed = true
@@ -79,7 +45,7 @@ function syncRuleRows() {
   if (changed) rules.value = [...rules.value]
 }
 
-watch([() => rules.value, itemByField], syncRuleRows, { deep: true, immediate: true })
+watch(() => rules.value, syncRuleRows, { deep: true, immediate: true })
 
 /* ================= 表格 ================= */
 const tableRef = ref(null)
@@ -87,8 +53,7 @@ const activeKey = ref(null)
 const selectedRowKeys = ref([])
 
 const columns = shallowRef([
-  { dataIndex: '_typeText', title: '类型', width: 80 },
-  { dataIndex: '_labelText', title: '判定条件 / 提示文案', minWidth: 320 },
+  { dataIndex: '_labelText', title: '提示文案 / 规则 SQL', minWidth: 380 },
   {
     dataIndex: 'b_canuse',
     title: '启用',
@@ -120,7 +85,7 @@ function onRowOrderChange(rows) {
   rules.value = rows.map((row, index) => ({ ...row, b_xh: (index + 1) * 10 }))
 }
 
-function onCellChange(row) {
+function onCellChange() {
   // 就地 patch 后换新数组引用触发表格重渲染
   rules.value = [...rules.value]
 }
@@ -143,7 +108,6 @@ function batchDelete() {
 }
 
 /* ================= 编辑弹窗 ================= */
-// 弹窗编辑的是行副本：取消不污染草稿；确定后按 _rowKey 替换（新增则追加）
 const ruleModalOpen = ref(false)
 const editingRow = ref(null)
 const editingIsNew = ref(false)
@@ -176,74 +140,25 @@ function onRuleOk(row) {
   activeKey.value = String(row._rowKey)
 }
 
-/* ================= 引用规则只读区 ================= */
-const moduleById = computed(
-  () => new Map((props.modules || []).map((item) => [String(item.b_id), item])),
-)
-
-function moduleText(code) {
-  const id = String(code ?? '')
-  if (!id) return ''
-  const module = moduleById.value.get(id)
-  return module ? `${module.b_name || id}（${id}）` : id
-}
-
-const reverseDisplayRows = computed(() =>
-  (props.refRulesReverse || []).map((row, index) => {
-    const key = parseRelationScopeId(row.b_scope_id)
-    return {
-      _rowKey: `ref-${index}-${row.b_scope_id}`,
-      sourceModuleText: moduleText(key.sourceModuleId),
-      sourceFieldText: key.sourceField,
-      targetModuleText: moduleText(key.targetModuleId),
-      targetFieldText: key.targetField,
-      summaryText: REF_RULE_HINT,
-      ownerModuleId: key.sourceModuleId,
-    }
-  }),
-)
-
-const reverseColumns = shallowRef([
-  { dataIndex: 'sourceModuleText', title: '源模块（谁配的）', width: 200 },
-  { dataIndex: 'sourceFieldText', title: '源字段', width: 160 },
-  { dataIndex: 'targetModuleText', title: '目标模块', width: 200 },
-  { dataIndex: 'targetFieldText', title: '目标字段', width: 160 },
-  { dataIndex: 'summaryText', title: '说明', minWidth: 160 },
-  {
-    dataIndex: 'actions',
-    title: '操作',
-    align: 'center',
-    width: 80,
-    actions: [
-      {
-        type: 'view',
-        label: '查看',
-        onClick: (row) => emit('navigate', row.ownerModuleId),
-      },
-    ],
-  },
-])
-
 /* ================= 校验 ================= */
-/** 保存前校验：规则要有主键；勾条件要真有条件、写 SQL 要有提示文案（引用规则不归本面板管） */
+/** 保存前校验：规则要有主键、只读 SQL、包含 :ids 标记和提示文案 */
 function validate() {
   const errors = []
   for (const [index, row] of (rules.value || []).entries()) {
     const label = `第 ${index + 1} 条规则`
-    if (!String(row.b_id ?? '').trim()) errors.push(`${label}：缺少主键（请重新新增）`)
-
-    const parsed = parseRulePredicate(row)
-    if (parsed.kind === 'sql') {
-      if (!String(row.b_message ?? '').trim()) {
-        errors.push(`${label}：写 SQL 的规则必须填写提示文案`)
-      }
-      if (!String(row.b_predicate ?? '').trim()) {
-        errors.push(`${label}：请填写规则 SQL`)
-      }
-    } else if (parsed.kind === 'reference') {
-      errors.push(`${label}：引用规则请到「模块关联」面板维护`)
-    } else if (!ruleHasCondition(row)) {
-      errors.push(`${label}：至少配置一个判定条件`)
+    if (!String(row.b_id ?? '').trim()) {
+      errors.push(`${label}：缺少主键（请重新新增）`)
+      continue
+    }
+    if (!ruleHasSql(row)) {
+      errors.push(`${label}：规则 SQL 必须包含 :ids 标记`)
+      continue
+    }
+    if (!ruleIsReadOnlySql(row)) {
+      errors.push(`${label}：规则 SQL 必须是只读查询（以 select 或 with 开头）`)
+    }
+    if (!String(row.b_message ?? '').trim()) {
+      errors.push(`${label}：请填写提示文案`)
     }
   }
   return errors
@@ -254,85 +169,49 @@ defineExpose({ validate })
 
 <template>
   <div class="mm-rule">
-    <div class="mm-rule__section mm-rule__section--main">
-      <div class="mm-rule__toolbar">
-        <Button type="primary" :disabled="loading" @click="openRuleModal(null)">
-          <Plus :size="14" /> 新增规则
-        </Button>
-        <Button type="danger" :disabled="loading || !selectedRowKeys.length" @click="batchDelete">
-          <Trash2 :size="14" /> 批量删除
-        </Button>
-      </div>
-      <div v-if="loading" class="mm-rule__state"><Spin /></div>
-      <div v-else class="mm-rule__table">
-        <FmsTable
-          ref="tableRef"
-          v-model:columns="columns"
-          :data-source="rules"
-          :editable="!loading"
-          :row-draggable="!loading"
-          :row-selection="rowSelection"
-          row-key="_rowKey"
-          :active-row-key="activeKey"
-          :col-resizable="true"
-          @row-click="(_, row) => (activeKey = String(row._rowKey))"
-          @change="onCellChange"
-          @row-order-change="onRowOrderChange"
-        />
-      </div>
+    <div class="mm-rule__toolbar">
+      <Button type="primary" :disabled="loading" @click="openRuleModal(null)">
+        <Plus :size="14" /> 新增规则
+      </Button>
+      <Button type="danger" :disabled="loading || !selectedRowKeys.length" @click="batchDelete">
+        <Trash2 :size="14" /> 批量删除
+      </Button>
     </div>
-
-    <div v-if="reverseDisplayRows.length" class="mm-rule__section mm-rule__section--reverse">
-      <div class="mm-rule__caption">
-        其他模块在本模块上配置的引用规则（只读）：这些关系指向本模块，存在引用时源侧记录不许删除
-      </div>
-      <div class="mm-rule__table">
-        <FmsTable
-          v-model:columns="reverseColumns"
-          :data-source="reverseDisplayRows"
-          :editable="false"
-          :seq="false"
-          row-key="_rowKey"
-        />
-      </div>
+    <div v-if="loading" class="mm-rule__state"><Spin /></div>
+    <div v-else class="mm-rule__table">
+      <FmsTable
+        ref="tableRef"
+        v-model:columns="columns"
+        :data-source="rules"
+        :editable="!loading"
+        :row-draggable="!loading"
+        :row-selection="rowSelection"
+        row-key="_rowKey"
+        :active-row-key="activeKey"
+        :col-resizable="true"
+        @row-click="(_, row) => (activeKey = String(row._rowKey))"
+        @change="onCellChange"
+        @row-order-change="onRowOrderChange"
+      />
     </div>
 
     <ModuleRuleEditModal
       v-model:open="ruleModalOpen"
       :row="editingRow"
       :is-new="editingIsNew"
-      :items="items"
       @ok="onRuleOk"
     />
   </div>
 </template>
 
 <style lang="scss" scoped>
-/* 上区可编辑规则表（撑满剩余高度），下区只读引用规则（内容少时按自身高度） */
 .mm-rule {
   display: flex;
   flex: 1;
   flex-direction: column;
-  gap: 12px;
   min-height: 0;
 }
 
-.mm-rule__section {
-  display: flex;
-  flex-direction: column;
-  min-width: 0;
-  min-height: 0;
-}
-
-.mm-rule__section--main {
-  flex: 1;
-}
-
-.mm-rule__section--reverse {
-  flex: none;
-  max-height: 45%;
-}
-
 .mm-rule__toolbar {
   display: flex;
   flex: none;
@@ -341,13 +220,6 @@ defineExpose({ validate })
   padding: 0 0 8px;
 }
 
-.mm-rule__caption {
-  flex: none;
-  padding: 0 0 6px;
-  color: var(--fms-text-secondary);
-  font-size: var(--fms-font-size);
-}
-
 .mm-rule__state {
   padding: 24px 0;
   color: var(--fms-text-secondary);
@@ -360,8 +232,4 @@ defineExpose({ validate })
   flex: 1;
   min-height: 0;
 }
-
-.mm-rule__section--reverse .mm-rule__table {
-  min-height: 120px;
-}
 </style>
diff --git a/code/fms/fms-vue/src/views/module/module-management/index.vue b/code/fms/fms-vue/src/views/module/module-management/index.vue
index 3b698453..f8e7f8a2 100644
--- a/code/fms/fms-vue/src/views/module/module-management/index.vue
+++ b/code/fms/fms-vue/src/views/module/module-management/index.vue
@@ -93,7 +93,6 @@ import ModuleRulePanel from './ModuleRulePanel.vue'
 import ModuleI18nPanel from './ModuleI18nPanel.vue'
 import { useI18nStore } from '@/stores/i18n'
 import { createTempId } from '@/utils/common'
-import { relationScopeId } from './ruleUtils'
 
 /** 生成安全 SQL 字符串字面量（search_condition 为后端拼 SQL，需要转义引号） */
 function sqlText(value) {
@@ -133,12 +132,8 @@ const relations = ref([]) // 本模块作为源的关系行（s_relation，仅 d
 const relations_org = ref([])
 /** 其他模块指向本模块的引用行（s_relation 目标侧）：只读展示，不参与 diff 与脏判定 */
 const reverseRelations = ref([])
-const rules = ref([]) // 模块级删除规则（s_rule，scope_type='module'）
+const rules = ref([]) // 删除 SQL 规则（s_delete_rule）
 const rules_org = ref([])
-/** 关系上的引用规则（s_rule，scope_type='relation'）：源侧可编辑，目标侧只读展示 */
-const refRules = ref([])
-const refRules_org = ref([])
-const refRulesReverse = ref([])
 const i18n = ref([]) // 多语言透视行（s_i18n）
 const i18n_org = ref([])
 /** 多语言草稿的加载基线指纹：s_i18n 不在下面的逐行 pairs 里比较，用稳定指纹判脏 */
@@ -170,9 +165,6 @@ function clearModuleData() {
   reverseRelations.value = []
   rules.value = []
   rules_org.value = []
-  refRules.value = []
-  refRules_org.value = []
-  refRulesReverse.value = []
   i18n.value = []
   i18n_org.value = []
   i18nBaselineFingerprint.value = ''
@@ -556,33 +548,18 @@ async function buildSaveData() {
       )
       if (hasChanges(relationReq)) saveReqs.push(relationReq)
 
-      // 模块级删除规则（s_rule，scope_type='module'）：scope 两列物化后按雪花主键 diff
+      // 删除 SQL 规则（s_delete_rule）：按雪花主键 diff，模块列在保存前物化
       for (const row of rules.value) {
-        row.b_scope_type = 'module'
-        if (String(row.b_scope_id ?? '').trim() !== moduleId) row.b_scope_id = moduleId
+        if (String(row.b_module_id ?? '').trim() !== moduleId) row.b_module_id = moduleId
       }
       const ruleReq = tableChange(
-        's_rule',
+        's_delete_rule',
         diffRows(stripInternalKeys(rules.value), stripInternalKeys(rules_org.value), {
           keyFields: ['b_id'],
         }),
         ['b_id'],
       )
       if (hasChanges(ruleReq)) saveReqs.push(ruleReq)
-
-      // 关系上的引用规则（s_rule，scope_type='relation'）：行由关联面板勾选增删，这里只物化 scope
-      for (const row of refRules.value) {
-        row.b_scope_type = 'relation'
-        if (!String(row.b_hook ?? '').trim()) row.b_hook = 'delete.pre'
-      }
-      const refRuleReq = tableChange(
-        's_rule',
-        diffRows(stripInternalKeys(refRules.value), stripInternalKeys(refRules_org.value), {
-          keyFields: ['b_id'],
-        }),
-        ['b_id'],
-      )
-      if (hasChanges(refRuleReq)) saveReqs.push(refRuleReq)
     }
   }
 
@@ -872,30 +849,13 @@ async function deleteModule(id) {
             key_field: 'b_object_type,b_object_id',
             deletes: [{ b_object_type: 'module', b_object_id: id2 }],
           },
-          // 删除规则（s_rule）：模块级规则按 scope 两列清；关系级规则挂在关系业务键上，
-          // 规则表没有模块列，需先查一次双向关系拿到键再批量删
+          // 删除 SQL 规则（s_delete_rule）挂在模块上，随模块删除
           {
-            table: 's_rule',
-            key_field: 'b_scope_type,b_scope_id',
-            deletes: [{ b_scope_type: 'module', b_scope_id: id2 }],
+            table: 's_delete_rule',
+            key_field: 'b_module_id',
+            deletes: [{ b_module_id: id2 }],
           },
         ]
-        const relationRes = await loadDataApi(
-          's_relation',
-          `b_source_module_id = ${sqlText(id2)} OR b_target_module_id = ${sqlText(id2)}`,
-          'b_source_module_id ASC, b_xh ASC, b_source_field ASC',
-        )
-        const relationDeletes = (relationRes.data || []).map((row) => ({
-          b_scope_type: 'relation',
-          b_scope_id: relationScopeId(row),
-        }))
-        if (relationDeletes.length) {
-          reqs.push({
-            table: 's_rule',
-            key_field: 'b_scope_type,b_scope_id',
-            deletes: relationDeletes,
-          })
-        }
         // s_i18n 无 b_module_id：按模块资源键（module.*/field.*/分组键）逐格删除；
         // 权限点的 action.* 动词键不在模块资源键范围内，天然不被误删
         const keys = await collectModuleI18nKeys(id2)
@@ -1020,11 +980,11 @@ async function loadModuleConfig(moduleId) {
               'b_source_module_id ASC, b_xh ASC, b_source_field ASC',
             )
           : Promise.resolve({ data: [] }),
-        // 模块级删除规则（s_rule，scope_type='module'）：无模块列，按 scope 两列定位
+        // 删除 SQL 规则（s_delete_rule）：按模块列定位
         type === 'data'
           ? loadDataApi(
-              's_rule',
-              `b_scope_type = 'module' AND b_scope_id = ${sqlText(id)}`,
+              's_delete_rule',
+              `b_module_id = ${sqlText(id)}`,
               'b_xh ASC, b_id ASC',
             )
           : Promise.resolve({ data: [] }),
@@ -1041,36 +1001,13 @@ async function loadModuleConfig(moduleId) {
     const isSourceRow = (row) => String(row.b_source_module_id ?? '').trim() === id
     relations_org.value = relationRows.filter(isSourceRow)
     reverseRelations.value = relationRows.filter((row) => !isSourceRow(row))
-    // 关系上的引用规则（s_rule，scope_type='relation'）：规则表没有模块列，
-    // 必须拿双向关系的业务键再查一次；源侧可编辑、目标侧只读展示
-    if (relationRows.length) {
-      const sourceKeys = relations_org.value.map(relationScopeId)
-      const targetKeys = reverseRelations.value.map(relationScopeId)
-      const refRuleRes = await loadDataApi(
-        's_rule',
-        `b_scope_type = 'relation' AND b_scope_id IN (${[...sourceKeys, ...targetKeys]
-          .map(sqlText)
-          .join(', ')})`,
-        'b_scope_id ASC, b_id ASC',
-      )
-      if (String(moduleSelectedId.value) !== id) return
-      const sourceKeySet = new Set(sourceKeys)
-      const refRows = refRuleRes.data || []
-      refRules_org.value = refRows.filter((row) => sourceKeySet.has(String(row.b_scope_id ?? '')))
-      refRulesReverse.value = refRows.filter(
-        (row) => !sourceKeySet.has(String(row.b_scope_id ?? '')),
-      )
-    } else {
-      refRules_org.value = []
-      refRulesReverse.value = []
-    }
+    // 关系上的引用规则已取消：引用保护由 s_relation.b_on_delete = restrict 表达
     maindata.value = cloneData(maindata_org.value)
     fields.value = cloneData(fields_org.value)
     autocode.value = cloneData(autocode_org.value)
     powers.value = cloneData(powers_org.value)
     relations.value = cloneData(relations_org.value)
     rules.value = cloneData(rules_org.value)
-    refRules.value = cloneData(refRules_org.value)
 
     for (const schemaType of SCHEMA_TYPES) {
       const row = (schemaRes.data || []).find((item) => String(item.b_schema_type) === schemaType)
@@ -1191,7 +1128,6 @@ function hasUnsavedChanges() {
     [powers, powers_org],
     [relations, relations_org],
     [rules, rules_org],
-    [refRules, refRules_org],
   ]
   return pairs.some(
     ([current, original]) =>
@@ -1275,17 +1211,6 @@ function onModuleAdd({ parentId, moduleType: newType }) {
   void addModule(parentId, newType)
 }
 
-/* ================= 删除规则只读区的跳转 ================= */
-/** 引用规则跳转：本模块的关系直接切到「模块关联」；其他模块则切换模块（走未保存守卫） */
-function onRuleNavigate(targetModuleId) {
-  const target = String(targetModuleId ?? '')
-  if (!target || target === String(moduleSelectedId.value)) {
-    activeSection.value = 'relation'
-    return
-  }
-  onModuleSelect(target)
-}
-
 /* ================= 初始化 ================= */
 void langStore.loadLanguages()
 loadModuleTree()
@@ -1443,7 +1368,6 @@ loadModuleTree()
                     <ModuleRelationPanel
                       ref="relationPanelRef"
                       v-model="relations"
-                      v-model:ref-rules="refRules"
                       :module-id="String(maindata.b_id || '')"
                       :fields="fields"
                       :modules="relationModules"
@@ -1457,12 +1381,7 @@ loadModuleTree()
                       ref="rulePanelRef"
                       v-model="rules"
                       :module-id="String(maindata.b_id || '')"
-                      :fields="fields"
-                      :query-schema="query_schema"
-                      :ref-rules-reverse="refRulesReverse"
-                      :modules="relationModules"
                       :loading="busy"
-                      @navigate="onRuleNavigate"
                     />
                   </div>
 
diff --git a/code/fms/fms-vue/src/views/module/module-management/ruleUtils.js b/code/fms/fms-vue/src/views/module/module-management/ruleUtils.js
index 9a66c31d..caf16055 100644
--- a/code/fms/fms-vue/src/views/module/module-management/ruleUtils.js
+++ b/code/fms/fms-vue/src/views/module/module-management/ruleUtils.js
@@ -1,195 +1,55 @@
 /**
- * 删除规则（s_rule）配置工具。
+ * 删除 SQL 规则（s_delete_rule）配置工具。
  *
- * 规则类型不单独存列（设计定案）：b_predicate 为空 = 引用规则；可解析为 JSON 且 kind='dsl'
- * = 勾条件；其余 = SQL 文本。scope_type='module' 挂模块（勾条件 / 写 SQL），
- * scope_type='relation' 挂关系（存在引用即拒绝删除，由模块关联面板勾选生成，一个关系最多一条）。
- * 规则没有业务键：主键是雪花 b_id（新增时前端取号），界面上不出现任何"编码/名称"字段，
- * 列表里靠自动摘要（勾条件）或提示文案（写 SQL）识别。
+ * 设计定案（FMS删除策略重构设计.md v1.2）：
+ *   - 一条规则只表达"哪些记录不允许删除"：b_sql 是只读查询，返回至少一行即拒绝本批删除；
+ *   - 用 :ids 标记本次待删 ID 集合，执行前由后端替换为经过校验的字面量 IN 列表；
+ *   - 关系上的关联处置（含引用保护）由 s_relation.b_on_delete 表达，不再产生规则行。
  *
- * 条件面板（FmsAdvancedQueryPanel）需要的 items 在这里按当前模块字段 + 查询配置组装。
+ * 规则没有业务键：主键是雪花 b_id（新增时前端取号），界面上不出现编码/名称字段。
  */
-import {
-  advancedQueryFromAst,
-  buildAdvancedAst,
-  defaultOperator,
-  describeAdvancedQuery,
-} from '@/components/fms-module-common/queryUtils'
-import { buildQueryRender } from '@/components/fms-module-common/schemaRender'
-import { parseOptions } from '@/components/fms-module-common/fieldUtils'
 import { createTempId } from '@/utils/common'
 
-export const RULE_SCOPE_MODULE = 'module'
-export const RULE_SCOPE_RELATION = 'relation'
-export const RULE_HOOK_DELETE = 'delete.pre'
-/** 引用规则（predicate 为空）在列表与只读区里的固定说明 */
-export const REF_RULE_HINT = '存在其他模块引用时拒绝删除'
+/** :ids 占位标记（与后端 delete 引擎约定一致） */
+export const IDS_PLACEHOLDER = ':ids'
 
-/** 关系行的业务键（与 s_relation 四列主键同序）：源模块|源字段|目标模块|目标字段 */
-export function relationScopeId(row) {
-  return [
-    row?.b_source_module_id,
-    row?.b_source_field,
-    row?.b_target_module_id,
-    row?.b_target_field,
-  ]
-    .map((value) => String(value ?? '').trim())
-    .join('|')
-}
-
-/** 关系行是否已填全四列（拼出的键才可用） */
-export function isCompleteRelationKey(row) {
-  return [
-    row?.b_source_module_id,
-    row?.b_source_field,
-    row?.b_target_module_id,
-    row?.b_target_field,
-  ].every((value) => String(value ?? '').trim())
-}
-
-/** 关系业务键 → 四列（与 relationScopeId 互逆），用于把引用规则还原成可读列 */
-export function parseRelationScopeId(scopeId) {
-  const [sourceModuleId = '', sourceField = '', targetModuleId = '', targetField = ''] = String(
-    scopeId ?? '',
-  ).split('|')
-  return { sourceModuleId, sourceField, targetModuleId, targetField }
-}
-
-/**
- * 规则类型三态：reference（引用规则）/ dsl（勾条件）/ sql（写 SQL）。
- * 非法 JSON（以 { 开头但解析失败）按 SQL 文本处理，避免把内容吞掉。
- */
-export function parseRulePredicate(row) {
-  const text = String(row?.b_predicate ?? '').trim()
-  if (!text) return { kind: 'reference' }
-  if (text.startsWith('{')) {
-    try {
-      const parsed = JSON.parse(text)
-      if (parsed?.kind === 'dsl' && parsed.expr) return { kind: 'dsl', expr: parsed.expr }
-    } catch {
-      // 解析失败继续按 SQL 处理
-    }
-  }
-  return { kind: 'sql', sql: text }
-}
-
-/** 类型列文案 */
-export function ruleTypeText(row) {
-  const { kind } = parseRulePredicate(row)
-  if (kind === 'dsl') return '条件'
-  if (kind === 'sql') return 'SQL'
-  return '引用'
-}
-
-/** 条件摘要：勾条件走中文描述，SQL 取单行化后的前 80 字，引用规则固定文案 */
-export function ruleSummary(row, itemByField, translate) {
-  const parsed = parseRulePredicate(row)
-  if (parsed.kind === 'dsl') {
-    const state = advancedQueryFromAst(parsed.expr)
-    return describeAdvancedQuery(state, itemByField, translate)
-  }
-  if (parsed.kind === 'sql') return parsed.sql.replace(/\s+/g, ' ').trim().slice(0, 80)
-  return REF_RULE_HINT
-}
-
-/**
- * 列表里识别规则用的文案（没有规则名，靠内容自述）：
- *   勾条件 → 条件中文摘要；写 SQL → 提示文案（写 SQL 必填，是人话），没填时退回 SQL 片段；引用 → 固定说明。
- */
-export function ruleLabel(row, itemByField, translate) {
-  const parsed = parseRulePredicate(row)
-  if (parsed.kind === 'sql') {
-    const message = String(row?.b_message ?? '').trim()
-    return message || ruleSummary(row, itemByField, translate)
-  }
-  return ruleSummary(row, itemByField, translate)
-}
-
-/**
- * 规则是否真有可执行内容：勾条件要有至少一个填好值的条件；写 SQL 要有文本；引用规则恒真。
- * 用于保存前拦住"改空了条件"的历史数据（弹窗入口也会拦一次）。
- */
-export function ruleHasCondition(row) {
-  const parsed = parseRulePredicate(row)
-  if (parsed.kind === 'reference') return true
-  if (parsed.kind === 'sql') return true
-  const state = advancedQueryFromAst(parsed.expr)
-  return (buildAdvancedAst(state).children || []).length > 0
-}
-
-/** 新增模块级规则行（勾条件类型起步，条件在编辑弹窗里填）；id 由调用方取号传入 */
+/** 新增规则行；id 由调用方取号传入 */
 export function createRuleRow(moduleId, { id, xh = 10 } = {}) {
   return {
     _rowKey: createTempId(),
     b_id: String(id ?? ''),
-    b_scope_type: RULE_SCOPE_MODULE,
-    b_scope_id: String(moduleId || ''),
-    b_hook: RULE_HOOK_DELETE,
-    b_predicate: null,
+    b_module_id: String(moduleId || ''),
+    b_sql: `select b_id from ${String(moduleId || '')} where b_id in (${IDS_PLACEHOLDER})`,
     b_message: null,
     b_canuse: 1,
     b_xh: xh,
   }
 }
 
-/** 引用规则行：由模块关联面板勾选「有引用时拒绝删除」时生成 */
-export function createRefRuleRow(scopeId, id, xh = 10) {
-  return {
-    _rowKey: createTempId(),
-    b_id: String(id ?? ''),
-    b_scope_type: RULE_SCOPE_RELATION,
-    b_scope_id: String(scopeId || ''),
-    b_hook: RULE_HOOK_DELETE,
-    b_predicate: null,
-    b_message: null,
-    b_canuse: 1,
-    b_xh: xh,
-  }
+/** SQL 单行化后的摘要（列表里识别规则用，规则没有名称） */
+export function ruleSummary(row) {
+  const sql = String(row?.b_sql ?? '')
+    .replace(/\s+/g, ' ')
+    .trim()
+  if (!sql) return '未填写 SQL'
+  return sql.length > 80 ? `${sql.slice(0, 80)}…` : sql
 }
 
-/** 字段类型 → 条件值控件（与查询配置的默认控件对齐） */
-const COMPONENT_BY_TYPE = {
-  select: 'select',
-  date: 'date-picker',
-  datetime: 'date-picker',
-  number: 'number',
-  money: 'number',
-  checkbox: 'checkbox',
+/** 列表识别文案：优先提示文案（人话），没填时退回 SQL 片段 */
+export function ruleLabel(row) {
+  const message = String(row?.b_message ?? '').trim()
+  return message || ruleSummary(row)
 }
 
-/**
- * 组装条件面板（FmsAdvancedQueryPanel）需要的 items：
- * 当前模块启用字段，叠加查询配置里的操作符 / 控件 / 选项。
- * select 字段若在查询配置里没有选项定义，降级为输入框（避免空下拉无路可走）。
- */
-export function buildRuleQueryItems(fields, querySchema) {
-  const fromQuery = new Map()
-  for (const condition of buildQueryRender(querySchema).conditions) {
-    fromQuery.set(String(condition.field), condition)
-  }
-  const items = []
-  for (const field of fields || []) {
-    if (Number(field.b_canuse) !== 1) continue
-    const condition = fromQuery.get(String(field.b_field))
-    const optionInfo = parseOptions({ options: condition?.options })
-    let component = condition?.component || COMPONENT_BY_TYPE[field.b_type] || 'input'
-    if (component === 'select' && !(optionInfo.options || []).length) component = 'input'
-    items.push({
-      config: {
-        b_field: String(field.b_field),
-        b_operator: condition?.operator || defaultOperator(field),
-        b_component: component,
-        b_default_value: null,
-      },
-      field,
-      optionConfig: optionInfo.optionConfig,
-      options: optionInfo.options,
-    })
-  }
-  return items
+/** 规则是否真有可执行内容：SQL 非空且包含 :ids 标记 */
+export function ruleHasSql(row) {
+  const sql = String(row?.b_sql ?? '').trim()
+  return sql.length > 0 && sql.includes(IDS_PLACEHOLDER)
 }
 
-/** items → 字段编码 Map（describeAdvancedQuery 与摘要展示用） */
-export function itemMapOf(items) {
-  return new Map((items || []).map((item) => [String(item.field.b_field), item]))
+/** 规则是否只读查询（前端预检；后端也会校验，这里只为提前提示） */
+export function ruleIsReadOnlySql(row) {
+  const sql = String(row?.b_sql ?? '').trim()
+  if (!sql) return false
+  return /^(select|with)\b/i.test(sql)
 }
diff --git a/code/fms/fms-vue/tests/unit/module-column-pref.spec.js b/code/fms/fms-vue/tests/unit/module-column-pref.spec.js
new file mode 100644
index 00000000..e365aac4
--- /dev/null
+++ b/code/fms/fms-vue/tests/unit/module-column-pref.spec.js
@@ -0,0 +1,152 @@
+import { describe, expect, it, vi } from 'vitest'
+
+vi.mock('@/services/api', () => ({
+  loadDataApi: vi.fn(),
+  saveObjectApi: vi.fn(),
+}))
+vi.mock('@/stores/auth', () => ({
+  useAuthStore: () => ({ userInfo: { account: 'u001' } }),
+}))
+
+const {
+  PREF_SCHEMA_TYPES,
+  columnSettingsDelta,
+  isEmptyColumnDelta,
+  mergeColumnPref,
+  sameColumnSettings,
+} = await import('@/components/fms-module-list/useModulePref')
+
+/** 通用栏位行：字段 + 宽度，数组顺序即通用顺序 */
+const base = [
+  { b_field: 'b_id', b_width: 120, b_visible: 1 },
+  { b_field: 'b_name', b_width: 200, b_visible: 1 },
+  { b_field: 'b_amount', b_width: 160, b_visible: 1 },
+]
+
+/** 表格当前栏位设置（getColumnSettings 的形态） */
+const current = (...pairs) => pairs.map(([b_field, b_width]) => ({ b_field, b_width }))
+
+describe('栏位设置：个人层合并', () => {
+  it('无个人偏好时原样返回通用栏位', () => {
+    expect(mergeColumnPref(base, null)).toBe(base)
+  })
+
+  it('只覆盖宽度，保留通用行上的其它属性（b_visible 等）', () => {
+    const merged = mergeColumnPref(base, { columns: { b_name: { width: 300 } } })
+    const name = merged.find((row) => row.b_field === 'b_name')
+    expect(name.b_width).toBe(300)
+    expect(name.b_visible).toBe(1)
+    // 未覆盖的字段保持通用宽度
+    expect(merged.find((row) => row.b_field === 'b_id').b_width).toBe(120)
+  })
+
+  it('按 order 重排并重编 b_xh（10/20/30）', () => {
+    const merged = mergeColumnPref(base, { order: ['b_amount', 'b_id', 'b_name'] })
+    expect(merged.map((row) => row.b_field)).toEqual(['b_amount', 'b_id', 'b_name'])
+    expect(merged.map((row) => row.b_xh)).toEqual([10, 20, 30])
+  })
+
+  it('order 未列出的字段保持原有相对顺序、追加在后', () => {
+    const merged = mergeColumnPref(base, { order: ['b_amount'] })
+    expect(merged.map((row) => row.b_field)).toEqual(['b_amount', 'b_id', 'b_name'])
+  })
+
+  it('个人层不得新增字段：order 里的未知字段一律忽略', () => {
+    const merged = mergeColumnPref(base, { order: ['b_hack', 'b_id'] })
+    expect(merged.map((row) => row.b_field)).toEqual(['b_id', 'b_name', 'b_amount'])
+  })
+
+  it('个人层不得给未知字段设宽度', () => {
+    const merged = mergeColumnPref(base, { columns: { b_hack: { width: 999 } } })
+    expect(merged.some((row) => row.b_field === 'b_hack')).toBe(false)
+  })
+})
+
+describe('栏位设置：增量计算', () => {
+  it('完全一致时增量为空且不含 order（不把通用顺序固化）', () => {
+    const delta = columnSettingsDelta(
+      current(['b_id', 120], ['b_name', 200], ['b_amount', 160]),
+      base,
+    )
+    expect(delta.columns).toEqual({})
+    expect(delta.order).toBeUndefined()
+    expect(isEmptyColumnDelta(delta)).toBe(true)
+  })
+
+  it('只记改过的宽度，同宽字段不入增量（通用改宽仍能透传）', () => {
+    const delta = columnSettingsDelta(
+      current(['b_id', 120], ['b_name', 320], ['b_amount', 160]),
+      base,
+    )
+    expect(delta.columns).toEqual({ b_name: { width: 320 } })
+    expect(delta.order).toBeUndefined()
+  })
+
+  it('顺序变化时整体记 order', () => {
+    const delta = columnSettingsDelta(
+      current(['b_amount', 160], ['b_id', 120], ['b_name', 200]),
+      base,
+    )
+    expect(delta.order).toEqual(['b_amount', 'b_id', 'b_name'])
+    expect(isEmptyColumnDelta(delta)).toBe(false)
+  })
+
+  it('宽度与顺序都变了，两部分都记', () => {
+    const delta = columnSettingsDelta(
+      current(['b_name', 320], ['b_id', 120], ['b_amount', 160]),
+      base,
+    )
+    expect(delta.columns).toEqual({ b_name: { width: 320 } })
+    expect(delta.order).toEqual(['b_name', 'b_id', 'b_amount'])
+  })
+
+  it('未知字段不产生宽度增量', () => {
+    const delta = columnSettingsDelta(
+      current(['b_id', 120], ['b_name', 200], ['b_hack', 300]),
+      base,
+    )
+    expect(delta.columns).toEqual({})
+  })
+})
+
+describe('栏位设置：与基线比较', () => {
+  it('宽度相同且顺序相同 → 未调整', () => {
+    expect(
+      sameColumnSettings(current(['b_id', 120], ['b_name', 200], ['b_amount', 160]), base),
+    ).toBe(true)
+  })
+
+  it('宽度不同 → 已调整', () => {
+    expect(
+      sameColumnSettings(current(['b_id', 120], ['b_name', 260], ['b_amount', 160]), base),
+    ).toBe(false)
+  })
+
+  it('顺序不同 → 已调整（即使宽度全同）', () => {
+    expect(
+      sameColumnSettings(current(['b_name', 200], ['b_id', 120], ['b_amount', 160]), base),
+    ).toBe(false)
+  })
+
+  it('数量不同 → 已调整', () => {
+    expect(sameColumnSettings(current(['b_id', 120]), base)).toBe(false)
+  })
+
+  it('当前宽度为 null 而通用有宽度 → 视为已调整', () => {
+    expect(
+      sameColumnSettings(current(['b_id', null], ['b_name', 200], ['b_amount', 160]), base),
+    ).toBe(false)
+  })
+
+  it('两侧宽度都是 null/未设置时视为一致', () => {
+    const noWidth = [{ b_field: 'b_id', b_width: null }, { b_field: 'b_name' }]
+    expect(sameColumnSettings(current(['b_id', null], ['b_name', undefined]), noWidth)).toBe(true)
+  })
+})
+
+describe('栏位设置：schema 类型常量', () => {
+  it('个人层栏位用 view，与查询布局的 query 区分开', () => {
+    expect(PREF_SCHEMA_TYPES.view).toBe('view')
+    expect(PREF_SCHEMA_TYPES.query).toBe('query')
+  })
+})
diff --git a/code/fms/fms-vue/tests/unit/module-column-smoke.spec.js b/code/fms/fms-vue/tests/unit/module-column-smoke.spec.js
new file mode 100644
index 00000000..9444ce5c
--- /dev/null
+++ b/code/fms/fms-vue/tests/unit/module-column-smoke.spec.js
@@ -0,0 +1,394 @@
+/**
+ * 栏位设置（列宽/顺序）冒烟测试：模拟真实操作链路。
+ *
+ * 覆盖：
+ *   1. 未改动 → 操作条不出现（不占内容区）；
+ *   2. 拖列宽 → 操作条出现，撤销后消失且不落库；
+ *   3. 保存为个人 → 只写 s_user_module_pref(b_schema_type='view')，且只存相对通用的增量；
+ *   4. 保存为通用 → 写 s_module_schema（且只对管理员可见按钮）；
+ *   5. 个人层加载 → 合并进列配置，且不得引入通用没有的字段。
+ */
+import { flushPromises, mount } from '@vue/test-utils'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { createPinia, setActivePinia } from 'pinia'
+import { registerFeature, useAreaSelection } from 'stk-table-vue'
+
+registerFeature(useAreaSelection)
+
+// vi.mock 工厂被提升到 import 之上，工厂内引用的变量必须同样提升
+const EMPTY = vi.hoisted(() => Object.freeze({}))
+
+vi.mock('vue-router', () => ({
+  useRoute: () => ({ path: '/module/i18n-type', meta: EMPTY }),
+}))
+
+vi.mock('@/services/exportService', () => ({
+  exportListApi: vi.fn(async () => 'data.xlsx'),
+  loadTotalsApi: vi.fn(async () => ({ data: EMPTY })),
+  countExportApi: vi.fn(async () => ({ data: EMPTY })),
+}))
+
+/** 通用栏位：b_id 120 / b_name 180。测试按需注入个人层偏好。 */
+const GLOBAL_VIEW = {
+  schemaVersion: 1,
+  columns: [
+    { field: 'b_id', width: 120 },
+    { field: 'b_name', width: 180 },
+  ],
+}
+
+let personalColumnPref = null
+let currentAccount = 'u001'
+
+const loadDataApi = vi.fn(async (viewName) => {
+  if (viewName === 's_module') {
+    return {
+      data: [
+        {
+          b_id: 's_i18n_type',
+          b_module_type: 'data',
+          b_canuse: 1,
+          b_view_table: 's_i18n_type',
+          b_save_table: 's_i18n_type',
+          b_key_field: 'b_id',
+        },
+      ],
+    }
+  }
+  if (viewName === 's_field') {
+    return {
+      data: [
+        { b_field: 'b_id', b_name: '语言编码', b_type: 'input', b_canuse: 1, b_i18n: null },
+        { b_field: 'b_name', b_name: '语言名称', b_type: 'input', b_canuse: 1, b_i18n: null },
+      ],
+    }
+  }
+  if (viewName === 's_module_schema') {
+    return {
+      data: [
+        {
+          b_module_id: 's_i18n_type',
+          b_schema_type: 'view',
+          b_schema_json: JSON.stringify(GLOBAL_VIEW),
+        },
+      ],
+    }
+  }
+  if (viewName === 's_user_module_pref') {
+    if (!personalColumnPref) return { data: [] }
+    return {
+      data: [
+        {
+          b_user_id: currentAccount,
+          b_module_id: 's_i18n_type',
+          b_schema_type: 'view',
+          b_schema_json: JSON.stringify(personalColumnPref),
+        },
+      ],
+    }
+  }
+  return { data: [] }
+})
+
+const saveObjectApi = vi.fn(async () => ({}))
+
+vi.mock('@/services/api', () => ({
+  loadDataApi: (...args) => loadDataApi(...args),
+  saveObjectApi: (...args) => saveObjectApi(...args),
+  pageDataApi: vi.fn(async () => ({ data: { rows: [{ b_id: 'zh-CN' }], total: 1 } })),
+  nextIdApi: vi.fn(async () => ({ data: '1' })),
+  loadDataBySqlApi: vi.fn(async () => ({ data: [] })),
+}))
+
+vi.mock('@/stores/auth', async () => {
+  const actual = await vi.importActual('@/stores/auth')
+  return {
+    ...actual,
+    useAuthStore: () => ({
+      userInfo: { account: currentAccount },
+      loginInfo: { user: { account: currentAccount, b_id: currentAccount } },
+    }),
+  }
+})
+
+// 权限 store 决定「保存为通用」按钮是否渲染：默认按非管理员（普通用户）跑
+let isG3soft = false
+vi.mock('@/stores/permissions', () => ({
+  usePermissionStore: () => ({
+    get isG3soft() {
+      return isG3soft
+    },
+  }),
+}))
+
+import FmsModuleListPage from '@/components/fms-module-list/FmsModuleListPage.vue'
+import FmsModuleTable from '@/components/fms-module-list/FmsModuleTable.vue'
+import FmsTable from '@/components/fms-table/FmsTable.vue'
+
+beforeEach(() => {
+  setActivePinia(createPinia())
+  loadDataApi.mockClear()
+  saveObjectApi.mockClear()
+  personalColumnPref = null
+  currentAccount = 'u001'
+  isG3soft = false
+  Object.defineProperty(HTMLElement.prototype, 'clientWidth', {
+    configurable: true,
+    get: () => 5000,
+  })
+})
+
+async function mountPage() {
+  const wrapper = mount(FmsModuleListPage, {
+    props: { dataCode: 's_i18n_type' },
+    attachTo: document.body,
+  })
+  await flushPromises()
+  return wrapper
+}
+
+/**
+ * 模拟用户拖拽列宽：FmsTable 收到后会 emit('update:columns', 渲染列数组)，
+ * 其中每项保留 dataIndex/key，只有 width 变化——按这个真实形态构造，别只传 b_field/b_width，
+ * 否则 FmsTable.onColumnsUpdate 按 key/dataIndex 匹配不到原始列，回传结果会变成空数组。
+ */
+async function resizeColumn(wrapper, dataIndex, width) {
+  const table = wrapper.findComponent(FmsModuleTable)
+  const fmsTable = table.findComponent(FmsTable)
+  const rendered = fmsTable
+    .props('columns')
+    .map((column) => (column.dataIndex === dataIndex ? { ...column, width } : { ...column }))
+  fmsTable.vm.$emit('update:columns', rendered)
+  await flushPromises()
+}
+
+/** 操作条内的按钮 */
+const barButton = (wrapper, text) =>
+  wrapper.findAll('.list-column-bar button').find((button) => button.text().trim() === text)
+
+describe('栏位设置冒烟', () => {
+  it('未改动时不出现操作条，也不渲染栏位相关按钮', async () => {
+    const wrapper = await mountPage()
+    expect(wrapper.find('.list-column-bar').exists()).toBe(false)
+    wrapper.unmount()
+  })
+
+  it('下拉菜单不再包含栏位相关项（已迁到操作条）', async () => {
+    const wrapper = await mountPage()
+    const menuText = wrapper.find('.list-toolbar__group--tools').text()
+    expect(menuText).not.toContain('恢复栏位设置')
+    expect(menuText).not.toContain('保存栏位设置')
+    wrapper.unmount()
+  })
+
+  it('拖列宽后操作条出现；撤销后消失且不落库', async () => {
+    const wrapper = await mountPage()
+    await resizeColumn(wrapper, 'b_name', 320)
+    expect(wrapper.find('.list-column-bar').exists()).toBe(true)
+    expect(wrapper.find('.list-column-bar').text()).toContain('列宽或顺序已调整')
+
+    await barButton(wrapper, '撤销').trigger('click')
+    await flushPromises()
+    expect(wrapper.find('.list-column-bar').exists()).toBe(false)
+    expect(saveObjectApi).not.toHaveBeenCalled()
+    wrapper.unmount()
+  })
+
+  it('普通用户看不到「保存为通用」，只看到个人与撤销', async () => {
+    const wrapper = await mountPage()
+    await resizeColumn(wrapper, 'b_name', 320)
+    const bar = wrapper.find('.list-column-bar')
+    expect(bar.text()).toContain('撤销')
+    expect(bar.text()).toContain('保存为个人')
+    expect(bar.text()).not.toContain('保存为通用')
+    wrapper.unmount()
+  })
+
+  it('管理员能看到「保存为通用」', async () => {
+    isG3soft = true
+    const wrapper = await mountPage()
+    await resizeColumn(wrapper, 'b_name', 320)
+    expect(wrapper.find('.list-column-bar').text()).toContain('保存为通用')
+    wrapper.unmount()
+  })
+
+  it('保存为个人：只写 s_user_module_pref，且只存改过的字段宽度', async () => {
+    const wrapper = await mountPage()
+    await resizeColumn(wrapper, 'b_name', 320)
+    await barButton(wrapper, '保存为个人').trigger('click')
+    await flushPromises()
+
+    expect(saveObjectApi).toHaveBeenCalledTimes(1)
+    const requests = saveObjectApi.mock.calls[0][0]
+    expect(requests).toHaveLength(1)
+    const req = requests[0]
+    expect(req.table).toBe('s_user_module_pref')
+    expect(req.key_field).toBe('b_user_id,b_module_id,b_schema_type')
+
+    const row = req.inserts[0]
+    expect(row.b_user_id).toBe('u001')
+    expect(row.b_module_id).toBe('s_i18n_type')
+    expect(row.b_schema_type).toBe('view')
+    const delta = JSON.parse(row.b_schema_json)
+    // 只有 b_name 改了宽度 → 增量里只应出现它，通用改 b_id 仍能透传
+    expect(delta.columns).toEqual({ b_name: { width: 320 } })
+    // 顺序未变 → 不应写 order（否则会把通用顺序固化）
+    expect(delta.order).toBeUndefined()
+
+    // 保存成功后操作条消失（已成本新基线）
+    expect(wrapper.find('.list-column-bar').exists()).toBe(false)
+    wrapper.unmount()
+  })
+
+  it('保存为个人不碰 s_module_schema（不污染通用）', async () => {
+    const wrapper = await mountPage()
+    await resizeColumn(wrapper, 'b_name', 320)
+    await barButton(wrapper, '保存为个人').trigger('click')
+    await flushPromises()
+    const tables = saveObjectApi.mock.calls.flatMap((call) => call[0].map((r) => r.table))
+    expect(tables).not.toContain('s_module_schema')
+    wrapper.unmount()
+  })
+
+  it('保存为通用：写 s_module_schema 并回写宽度', async () => {
+    isG3soft = true
+    const wrapper = await mountPage()
+    await resizeColumn(wrapper, 'b_name', 320)
+    await barButton(wrapper, '保存为通用').trigger('click')
+    await flushPromises()
+
+    const requests = saveObjectApi.mock.calls.at(-1)[0]
+    const req = requests.find((r) => r.table === 's_module_schema')
+    expect(req).toBeTruthy()
+    expect(req.key_field).toBe('b_module_id,b_schema_type')
+    const patch = req.updates ? req.updates[0] : req.inserts[0]
+    expect(patch.b_schema_type).toBe('view')
+    const schema = JSON.parse(patch.b_schema_json)
+    const nameNode = schema.columns.find((node) => node.field === 'b_name')
+    expect(nameNode.width).toBe(320)
+    expect(wrapper.find('.list-column-bar').exists()).toBe(false)
+    wrapper.unmount()
+  })
+
+  it('个人层加载：合并进列配置（宽度生效）', async () => {
+    personalColumnPref = { schemaVersion: 1, columns: { b_name: { width: 260 } } }
+    const wrapper = await mountPage()
+    const table = wrapper.findComponent(FmsModuleTable)
+    const nameConfig = table.props('listConfig').find((item) => item.b_field === 'b_name')
+    expect(nameConfig.b_width).toBe(260)
+    // 已按个人层加载 → 与基线一致 → 不应立即显示「已调整」
+    expect(wrapper.find('.list-column-bar').exists()).toBe(false)
+    wrapper.unmount()
+  })
+
+  it('个人层不得引入通用没有的字段（越权字段被忽略）', async () => {
+    personalColumnPref = {
+      schemaVersion: 1,
+      columns: { b_hack: { width: 999 } },
+      order: ['b_hack', 'b_id'],
+    }
+    const wrapper = await mountPage()
+    const table = wrapper.findComponent(FmsModuleTable)
+    const fields = table.props('listConfig').map((item) => item.b_field)
+    expect(fields).not.toContain('b_hack')
+    expect(fields).toEqual(['b_id', 'b_name'])
+    wrapper.unmount()
+  })
+
+  it('个人层顺序生效，且不误报为「已调整」', async () => {
+    personalColumnPref = { schemaVersion: 1, order: ['b_name', 'b_id'] }
+    const wrapper = await mountPage()
+    const table = wrapper.findComponent(FmsModuleTable)
+    expect(table.props('listConfig').map((item) => item.b_field)).toEqual(['b_name', 'b_id'])
+    expect(wrapper.find('.list-column-bar').exists()).toBe(false)
+    wrapper.unmount()
+  })
+
+  it('保留个人设置再次保存时走 updates 而非 inserts（避免主键冲突）', async () => {
+    personalColumnPref = { schemaVersion: 1, columns: { b_name: { width: 260 } } }
+    const wrapper = await mountPage()
+    await resizeColumn(wrapper, 'b_name', 300)
+    await barButton(wrapper, '保存为个人').trigger('click')
+    await flushPromises()
+
+    const req = saveObjectApi.mock.calls.at(-1)[0].find((r) => r.table === 's_user_module_pref')
+    expect(req.updates).toBeTruthy()
+    expect(req.inserts).toBeUndefined()
+    // 增量是相对通用（180），不是相对个人上一次（260）
+    expect(JSON.parse(req.updates[0].b_schema_json).columns).toEqual({ b_name: { width: 300 } })
+    wrapper.unmount()
+  })
+
+  it('连续改动只累积一次落库，保存后操作条消失', async () => {
+    const wrapper = await mountPage()
+    await resizeColumn(wrapper, 'b_id', 140)
+    await resizeColumn(wrapper, 'b_id', 150)
+    await resizeColumn(wrapper, 'b_name', 260)
+    expect(wrapper.find('.list-column-bar').exists()).toBe(true)
+
+    await barButton(wrapper, '保存为个人').trigger('click')
+    await flushPromises()
+
+    expect(saveObjectApi).toHaveBeenCalledTimes(1)
+    const delta = JSON.parse(saveObjectApi.mock.calls[0][0][0].inserts[0].b_schema_json)
+    // 只记最终值（150 / 260），中间态不入增量
+    expect(delta.columns).toEqual({ b_id: { width: 150 }, b_name: { width: 260 } })
+    expect(wrapper.find('.list-column-bar').exists()).toBe(false)
+    wrapper.unmount()
+  })
+
+  it('保存后再次改动会重新出现操作条（基线已前移）', async () => {
+    const wrapper = await mountPage()
+    await resizeColumn(wrapper, 'b_name', 320)
+    await barButton(wrapper, '保存为个人').trigger('click')
+    await flushPromises()
+    expect(wrapper.find('.list-column-bar').exists()).toBe(false)
+
+    // 保存后把宽度改回通用值 → 与「新基线 320」不同，仍应提示
+    await resizeColumn(wrapper, 'b_name', 180)
+    expect(wrapper.find('.list-column-bar').exists()).toBe(true)
+    wrapper.unmount()
+  })
+
+  it('改回通用值后保存：清空个人层而非留下空壳覆盖', async () => {
+    personalColumnPref = { schemaVersion: 1, columns: { b_name: { width: 260 } } }
+    const wrapper = await mountPage()
+    // 改回与通用一致（b_name 通用宽度 180）
+    await resizeColumn(wrapper, 'b_name', 180)
+    await barButton(wrapper, '保存为个人').trigger('click')
+    await flushPromises()
+
+    const req = saveObjectApi.mock.calls.at(-1)[0].find((r) => r.table === 's_user_module_pref')
+    // 无增量可存 → 走删除，不写空 columns
+    expect(req.deletes).toBeTruthy()
+    expect(req.inserts).toBeUndefined()
+    expect(req.updates).toBeUndefined()
+    expect(req.deletes[0]).toMatchObject({
+      b_user_id: 'u001',
+      b_module_id: 's_i18n_type',
+      b_schema_type: 'view',
+    })
+    expect(wrapper.find('.list-column-bar').exists()).toBe(false)
+    wrapper.unmount()
+  })
+
+  it('已有个人设置但本次改动恰好等于通用时，也走删除清理', async () => {
+    // 个人层只改了顺序，本次把顺序也拖回通用顺序
+    personalColumnPref = { schemaVersion: 1, order: ['b_name', 'b_id'] }
+    const wrapper = await mountPage()
+    const table = wrapper.findComponent(FmsModuleTable)
+    const fmsTable = table.findComponent(FmsTable)
+    // 拖回通用顺序 b_id, b_name
+    const reordered = fmsTable.props('columns').toReversed()
+    fmsTable.vm.$emit('update:columns', reordered)
+    await flushPromises()
+
+    expect(wrapper.find('.list-column-bar').exists()).toBe(true)
+    await barButton(wrapper, '保存为个人').trigger('click')
+    await flushPromises()
+
+    const req = saveObjectApi.mock.calls.at(-1)[0].find((r) => r.table === 's_user_module_pref')
+    expect(req.deletes).toBeTruthy()
+    wrapper.unmount()
+  })
+})
diff --git a/code/fms/fms-vue/tests/unit/module-relation-panel.spec.js b/code/fms/fms-vue/tests/unit/module-relation-panel.spec.js
index 6cfa7419..1436991e 100644
--- a/code/fms/fms-vue/tests/unit/module-relation-panel.spec.js
+++ b/code/fms/fms-vue/tests/unit/module-relation-panel.spec.js
@@ -2,12 +2,13 @@
  * 模块关联面板（s_relation）：
  * - 加载回填行只补本地行键（_rowKey），不得改动业务列——否则打开模块即提示「未保存」；
  * - 新增关联：追加「源模块 = 当前模块」的空行，主键四列留待用户填写；
+ *   新建关系默认关联删除处理为 restrict（设计 §3.1）；
  * - 换目标模块：原目标字段必然失效，需清空并按目标模块加载字段选项；
- * - 保存前校验：四列非空、关系类型合法、四列组合不重复（空列会撞行身份，落库即主键冲突）。
+ * - 关联删除处理三值对多对一同样开放：类型切成多对一时不得重置 b_on_delete（设计 §3.2）；
+ * - 保存前校验：四列非空、关系类型合法、删除处置合法、四列组合不重复。
  */
 import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
-import { mount } from '@vue/test-utils'
-import { flushPromises } from '@vue/test-utils'
+import { mount, flushPromises } from '@vue/test-utils'
 import { createPinia, setActivePinia } from 'pinia'
 import { nextTick } from 'vue'
 import ModuleRelationPanel from '@/views/module/module-management/ModuleRelationPanel.vue'
@@ -51,13 +52,13 @@ const sourceRow = {
   b_target_module_id: 'order_item',
   b_target_field: 'b_order_id',
   b_relation_type: 'one_to_many',
+  b_on_delete: 'restrict',
   b_canuse: 1,
   b_xh: 10,
 }
 
-async function mountPanel(modelValue = [], { refRules = [] } = {}) {
+async function mountPanel(modelValue = []) {
   const pinia = createPinia()
-  pinia.install({ provide() {}, config: { globalProperties: {} } })
   setActivePinia(pinia)
   const wrapper = mount(ModuleRelationPanel, {
     props: {
@@ -67,7 +68,6 @@ async function mountPanel(modelValue = [], { refRules = [] } = {}) {
       reverseRows: [],
       loading: false,
       modelValue,
-      refRules,
     },
     global: { plugins: [pinia] },
     attachTo: document.body,
@@ -82,23 +82,6 @@ const lastRelations = (wrapper) => {
   return events.length ? events[events.length - 1][0] : null
 }
 
-const lastRefRules = (wrapper) => {
-  const events = wrapper.emitted('update:refRules') || []
-  return events.length ? events[events.length - 1][0] : null
-}
-
-/** 已勾选引用规则的关系行（refRules 里挂着对应的 relation 规则） */
-const REF_SCOPE_ID = 'order|b_id|order_item|b_order_id'
-const refRuleRow = {
-  b_id: '1900000000000000001',
-  b_scope_type: 'relation',
-  b_scope_id: REF_SCOPE_ID,
-  b_hook: 'delete.pre',
-  b_predicate: null,
-  b_canuse: 1,
-  b_xh: 10,
-}
-
 beforeEach(() => {
   document.body.innerHTML = ''
   loadDataApi.mockReset()
@@ -119,7 +102,7 @@ describe('模块关联面板', () => {
     expect(stripInternalKeys(next[0])).toEqual(sourceRow)
   })
 
-  it('新增关联：追加源模块为当前模块的空行并进入编辑', async () => {
+  it('新增关联：追加源模块为当前模块的空行，默认关联删除处理为 restrict', async () => {
     const wrapper = await mountPanel([{ ...sourceRow }])
     await wrapper.vm.addRow()
     await nextTick()
@@ -132,6 +115,7 @@ describe('模块关联面板', () => {
       b_target_module_id: null,
       b_target_field: null,
       b_relation_type: 'many_to_one',
+      b_on_delete: 'restrict',
       b_canuse: 1,
       b_xh: 20,
     })
@@ -216,88 +200,31 @@ describe('模块关联面板', () => {
     expect(wrapper.vm.selectedRowKeys).toEqual([])
   })
 
-  it('删除连带：加载回填不置脏，多对一自动清回不连带', async () => {
-    const cascadeRow = { ...sourceRow, b_on_delete: 'cascade' }
+  it('关联删除处理：加载回填不置脏，多对一不再被重置（允许 cascade）', async () => {
+    const cascadeRow = { ...sourceRow, b_relation_type: 'many_to_one', b_on_delete: 'cascade' }
     // 传入副本：面板会往行对象上补 _ 前缀派生列
     const wrapper = await mountPanel([{ ...cascadeRow }])
     const row = lastRelations(wrapper)[0]
     expect(stripInternalKeys(row)).toEqual(cascadeRow)
 
-    // 类型改成多对一：连带策略不再成立，自动清回 none 并提示
+    // 类型在多对一与一对多之间切换：处置值必须原样保留，不再被硬编码清回 none
     row.b_relation_type = 'many_to_one'
     wrapper.vm.onCellChange(row, { dataIndex: 'b_relation_type' })
     await nextTick()
 
-    expect(row.b_on_delete).toBe('none')
-    expect(Message.warning).toHaveBeenCalledWith(
-      '多对一关系不支持连带删除/连带归档，已重置为不连带',
-    )
+    expect(row.b_on_delete).toBe('cascade')
+    expect(Message.warning).not.toHaveBeenCalled()
   })
 
-  it('校验：多对一上配连带删除/归档被拦，取值非法被拦', async () => {
+  it('校验：多对一配 cascade 合法，仅取值非法被拦', async () => {
     const wrapper = await mountPanel([
       { ...sourceRow, b_relation_type: 'many_to_one', b_on_delete: 'cascade' },
       { ...sourceRow, b_target_field: 'b_other', b_on_delete: 'remove' },
     ])
     const errors = wrapper.vm.validate()
 
-    expect(errors).toContain('第 1 行：多对一关系不支持连带删除/连带归档')
-    expect(errors).toContain('第 2 行：删除连带取值不合法')
-  })
-
-  it('引用规则：勾选取号建行、取消删行，回填按业务键还原勾选态', async () => {
-    const wrapper = await mountPanel([{ ...sourceRow }], { refRules: [] })
-    const row = wrapper.vm.relations[0]
-
-    row._hasRefRule = 1
-    wrapper.vm.onCellChange(row, { dataIndex: '_hasRefRule' })
-    await flushPromises()
-    await nextTick()
-
-    const added = lastRefRules(wrapper)
-    expect(added).toHaveLength(1)
-    expect(added[0]).toMatchObject({
-      b_id: '1900000000000000009',
-      b_scope_type: 'relation',
-      b_scope_id: REF_SCOPE_ID,
-      b_predicate: null,
-    })
-
-    // 已有规则时加载：勾选态由业务键还原（不置脏）
-    const withRule = await mountPanel([{ ...sourceRow }], { refRules: [{ ...refRuleRow }] })
-    expect(stripInternalKeys(withRule.vm.relations[0])).toEqual(sourceRow)
-    expect(withRule.vm.relations[0]._hasRefRule).toBe(1)
-
-    // 取消勾选：规则行被移除
-    const target = withRule.vm.relations[0]
-    target._hasRefRule = 0
-    withRule.vm.onCellChange(target, { dataIndex: '_hasRefRule' })
-    await nextTick()
-    expect(lastRefRules(withRule)).toEqual([])
-  })
-
-  it('改关系主键：自动取消引用保护并删掉旧键规则，避免库中残留孤儿规则', async () => {
-    const wrapper = await mountPanel([{ ...sourceRow }], { refRules: [{ ...refRuleRow }] })
-    const row = wrapper.vm.relations[0]
-    expect(row._hasRefRule).toBe(1)
-
-    row.b_target_module_id = 'legacy'
-    wrapper.vm.onCellChange(row, { dataIndex: 'b_target_module_id' })
-    await nextTick()
-
-    expect(row._hasRefRule).toBe(0)
-    expect(lastRefRules(wrapper)).toEqual([])
-    expect(Message.info).toHaveBeenCalledWith(
-      '关系主键已变化，「有引用时拒绝删除」已取消，请重新勾选',
-    )
-  })
-
-  it('删掉关系行时，挂在它上面的引用规则一并移除', async () => {
-    const wrapper = await mountPanel([{ ...sourceRow }], { refRules: [{ ...refRuleRow }] })
-    wrapper.vm.removeRow(wrapper.vm.relations[0])
-    await nextTick()
-
-    expect(lastRefRules(wrapper)).toEqual([])
-    expect(lastRelations(wrapper)).toHaveLength(0)
+    // 多对一 + cascade 是允许的场景（如「明细 → 主单」删主单级联删明细）
+    expect(errors.some((item) => item.includes('第 1 行'))).toBe(false)
+    expect(errors).toContain('第 2 行：关联删除处理取值不合法')
   })
 })
diff --git a/code/fms/fms-vue/tests/unit/module-rule-edit-modal.spec.js b/code/fms/fms-vue/tests/unit/module-rule-edit-modal.spec.js
index 565c2823..54e836ca 100644
--- a/code/fms/fms-vue/tests/unit/module-rule-edit-modal.spec.js
+++ b/code/fms/fms-vue/tests/unit/module-rule-edit-modal.spec.js
@@ -1,16 +1,15 @@
 /**
- * 删除规则编辑弹窗（ModuleRuleEditModal）：
- * - 勾条件 → predicate 存 {"kind":"dsl","expr":AST}；写 SQL → predicate 存文本；
- * - 两种类型各自的必填校验（无条件 / 缺提示文案）不通过时不提交；
- * - 打开时按 predicate 三态回显类型与内容；标题按新增/编辑切换。
+ * 删除 SQL 规则编辑弹窗（ModuleRuleEditModal）：
+ * - 只编辑 b_sql + b_message：SQL 必填、必须只读、必须含 :ids；提示文案必填；
+ * - 校验不通过时不提交（不 emit ok）；
+ * - 打开时按当前行回显 SQL 与文案；标题按新增/编辑切换。
  */
 import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
-import { mount } from '@vue/test-utils'
-import { flushPromises } from '@vue/test-utils'
+import { mount, flushPromises } from '@vue/test-utils'
 import { createPinia, setActivePinia } from 'pinia'
 import { nextTick } from 'vue'
 import ModuleRuleEditModal from '@/views/module/module-management/ModuleRuleEditModal.vue'
-import { buildRuleQueryItems } from '@/views/module/module-management/ruleUtils'
+import { IDS_PLACEHOLDER } from '@/views/module/module-management/ruleUtils'
 
 vi.mock('@/services/api', () => ({ loadDataApi: vi.fn() }))
 
@@ -28,32 +27,21 @@ beforeAll(() => {
   })
 })
 
-const ITEMS = buildRuleQueryItems(
-  [
-    { b_field: 'b_status', b_name: '状态', b_type: 'select', b_canuse: 1 },
-    { b_field: 'b_no', b_name: '单号', b_type: 'input', b_canuse: 1 },
-  ],
-  {},
-)
-
 const ruleRow = () => ({
   _rowKey: '-1',
   b_id: '1900000000000000001',
-  b_scope_type: 'module',
-  b_scope_id: 'order',
-  b_hook: 'delete.pre',
-  b_predicate: null,
-  b_message: null,
+  b_module_id: 'order',
+  b_sql: `select b_id from bill where b_id in (${IDS_PLACEHOLDER})`,
+  b_message: '单据已销账，不能删除',
   b_canuse: 1,
   b_xh: 10,
 })
 
 async function mountModal(row = ruleRow(), isNew = false) {
   const pinia = createPinia()
-  pinia.install({ provide() {}, config: { globalProperties: {} } })
   setActivePinia(pinia)
   const wrapper = mount(ModuleRuleEditModal, {
-    props: { open: true, row, isNew, items: ITEMS },
+    props: { open: true, row, isNew },
     global: { plugins: [pinia] },
     attachTo: document.body,
   })
@@ -66,57 +54,9 @@ beforeEach(() => {
   document.body.innerHTML = ''
 })
 
-describe('删除规则编辑弹窗', () => {
-  it('勾条件：没有条件时不提交，选了条件后按 AST 组装 predicate', async () => {
-    const row = ruleRow()
-    const wrapper = await mountModal(row)
-
-    await wrapper.vm.onOk()
-    expect(wrapper.vm.conditionError).toBe('勾条件规则至少要有一个条件')
-    expect(wrapper.emitted('ok')).toBeFalsy()
-
-    wrapper.vm.conditionState = {
-      nodes: [{ id: 'n1', at: 1, join: 'and', field: 'b_status', operator: 'eq', value: 'audit' }],
-      groups: [],
-    }
-    await nextTick()
-    expect(wrapper.vm.conditionSummary).toBe('状态 等于 audit')
-
-    await wrapper.vm.onOk()
-    const saved = wrapper.emitted('ok')?.[0]?.[0]
-    expect(saved.b_hook).toBe('delete.pre')
-    const predicate = JSON.parse(saved.b_predicate)
-    expect(predicate.kind).toBe('dsl')
-    expect(predicate.expr.children[0]).toMatchObject({
-      type: 'condition',
-      field: 'b_status',
-      operator: 'eq',
-      value: 'audit',
-    })
-    expect(wrapper.emitted('update:open')?.at(-1)).toEqual([false])
-  })
-
-  it('写 SQL：缺提示文案不提交，填好后原样存文本', async () => {
-    const row = ruleRow()
-    const wrapper = await mountModal(row)
-    wrapper.vm.ruleType = 'sql'
-    wrapper.vm.sqlText = 'select b_id from bill where b_id in (:ids) and b_settled = 1'
-    await nextTick()
-
-    await wrapper.vm.onOk()
-    expect(wrapper.vm.sqlError).toBe('写 SQL 的规则必须填写提示文案')
-    expect(wrapper.emitted('ok')).toBeFalsy()
-
-    row.b_message = '单据已销账，不能删除'
-    await wrapper.vm.onOk()
-    expect(wrapper.emitted('ok')?.[0]?.[0].b_predicate).toBe(
-      'select b_id from bill where b_id in (:ids) and b_settled = 1',
-    )
-  })
-
-  it('写 SQL：SQL 为空时不提交', async () => {
-    const wrapper = await mountModal(ruleRow())
-    wrapper.vm.ruleType = 'sql'
+describe('删除 SQL 规则编辑弹窗', () => {
+  it('SQL 为空时不提交', async () => {
+    const wrapper = await mountModal()
     wrapper.vm.sqlText = '   '
     await nextTick()
 
@@ -125,15 +65,59 @@ describe('删除规则编辑弹窗', () => {
     expect(wrapper.emitted('ok')).toBeFalsy()
   })
 
-  it('回显与标题：SQL 类型直接进 SQL 分支；新增/编辑标题不同', async () => {
-    const row = { ...ruleRow(), b_predicate: 'select 1 as b_id' }
-    const wrapper = await mountModal(row, true)
+  it('SQL 非只读时不提交', async () => {
+    const wrapper = await mountModal()
+    wrapper.vm.sqlText = `delete from bill where b_id in (${IDS_PLACEHOLDER})`
+    await nextTick()
 
-    expect(wrapper.vm.ruleType).toBe('sql')
-    expect(wrapper.vm.sqlText).toBe('select 1 as b_id')
+    await wrapper.vm.onOk()
+    expect(wrapper.vm.sqlError).toBe('规则 SQL 必须是只读查询（以 select 或 with 开头）')
+    expect(wrapper.emitted('ok')).toBeFalsy()
+  })
+
+  it('SQL 缺少 :ids 标记时不提交', async () => {
+    const wrapper = await mountModal()
+    wrapper.vm.sqlText = 'select b_id from bill'
+    await nextTick()
+
+    await wrapper.vm.onOk()
+    expect(wrapper.vm.sqlError).toBe('规则 SQL 必须包含 :ids 标记，用于限定本次待删记录')
+    expect(wrapper.emitted('ok')).toBeFalsy()
+  })
+
+  it('缺提示文案时不提交，填好后原样存 SQL 与文案', async () => {
+    const row = { ...ruleRow(), b_message: '' }
+    const wrapper = await mountModal(row)
+    wrapper.vm.sqlText = `select b_id from bill where b_id in (${IDS_PLACEHOLDER}) and b_settled = 1`
+    await nextTick()
+
+    await wrapper.vm.onOk()
+    expect(wrapper.vm.messageError).toBe('请填写提示文案')
+    expect(wrapper.emitted('ok')).toBeFalsy()
+
+    wrapper.vm.messageText = '单据已销账，不能删除'
+    await nextTick()
+    await wrapper.vm.onOk()
+
+    const saved = wrapper.emitted('ok')?.[0]?.[0]
+    expect(saved.b_sql).toBe(
+      `select b_id from bill where b_id in (${IDS_PLACEHOLDER}) and b_settled = 1`,
+    )
+    expect(saved.b_message).toBe('单据已销账，不能删除')
+    // 旧字段不再写入
+    expect(saved.b_predicate).toBeUndefined()
+    expect(saved.b_hook).toBeUndefined()
+    expect(wrapper.emitted('update:open')?.at(-1)).toEqual([false])
+  })
+
+  it('回显与标题：按当前行还原 SQL 与文案；新增/编辑标题不同', async () => {
+    const wrapper = await mountModal({ ...ruleRow() }, true)
+
+    expect(wrapper.vm.sqlText).toBe(`select b_id from bill where b_id in (${IDS_PLACEHOLDER})`)
+    expect(wrapper.vm.messageText).toBe('单据已销账，不能删除')
     expect(wrapper.vm.modalTitle).toBe('新增删除规则')
 
-    const editWrapper = await mountModal({ ...ruleRow() }, false)
+    const editWrapper = await mountModal(ruleRow(), false)
     expect(editWrapper.vm.modalTitle).toBe('编辑删除规则')
   })
 })
diff --git a/code/fms/fms-vue/tests/unit/module-rule-panel.spec.js b/code/fms/fms-vue/tests/unit/module-rule-panel.spec.js
index 6115425a..5e992902 100644
--- a/code/fms/fms-vue/tests/unit/module-rule-panel.spec.js
+++ b/code/fms/fms-vue/tests/unit/module-rule-panel.spec.js
@@ -1,17 +1,17 @@
 /**
- * 删除规则面板（module-management/ModuleRulePanel）：
- * - 加载回填只补界面派生列（_rowKey / _typeText / _labelText），业务列不变（不置脏）；
- * - 列表识别：勾条件显示条件中文摘要，写 SQL 显示提示文案；
- * - 保存前校验：勾条件要有条件、写 SQL 要有 SQL 与提示文案；
- * - 其他模块在本模块上配的引用规则只读展示，可跳转到源模块。
+ * 删除 SQL 规则面板（module-management/ModuleRulePanel）：
+ * - 加载回填只补界面派生列（_rowKey / _labelText），业务列不变（不置脏）；
+ * - 列表识别：优先提示文案，缺文案退回 SQL 片段；
+ * - 保存前校验：必须有主键、SQL 含 :ids 且为只读查询、必须填提示文案；
+ * - 新增规则：取号后打开弹窗，确定时才落草稿。
  */
 import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
-import { mount } from '@vue/test-utils'
-import { flushPromises } from '@vue/test-utils'
+import { mount, flushPromises } from '@vue/test-utils'
 import { createPinia, setActivePinia } from 'pinia'
 import { nextTick } from 'vue'
 import ModuleRulePanel from '@/views/module/module-management/ModuleRulePanel.vue'
 import { stripInternalKeys } from '@/utils/dataChanges'
+import { IDS_PLACEHOLDER } from '@/views/module/module-management/ruleUtils'
 
 vi.mock('@/services/api', () => ({
   loadDataApi: vi.fn(),
@@ -33,47 +33,22 @@ beforeAll(() => {
   })
 })
 
-const FIELDS = [
-  { b_field: 'b_status', b_name: '状态', b_type: 'select', b_canuse: 1 },
-  { b_field: 'b_settled', b_name: '已销账', b_type: 'checkbox', b_canuse: 1 },
-]
-
-const MODULES = [
-  { b_id: 'order', b_name: '订单', b_canuse: 1 },
-  { b_id: 'order_item', b_name: '订单明细', b_canuse: 1 },
-]
-
-/** 库中已有的一条勾条件规则：状态等于 audit */
-const dslRow = {
+/** 库中已有的一条删除 SQL 规则 */
+const sqlRow = {
   b_id: '1900000000000000001',
-  b_scope_type: 'module',
-  b_scope_id: 'order',
-  b_hook: 'delete.pre',
-  b_predicate: JSON.stringify({
-    kind: 'dsl',
-    expr: {
-      type: 'group',
-      children: [
-        { type: 'condition', field: 'b_status', operator: 'eq', value: 'audit', join: 'and' },
-      ],
-    },
-  }),
-  b_message: null,
+  b_module_id: 'order',
+  b_sql: `select b_id from bill where b_id in (${IDS_PLACEHOLDER}) and b_settled = 1`,
+  b_message: '单据已销账，不能删除',
   b_canuse: 1,
   b_xh: 10,
 }
 
-async function mountPanel({ rules = [], refRulesReverse = [] } = {}) {
+async function mountPanel({ rules = [] } = {}) {
   const pinia = createPinia()
-  pinia.install({ provide() {}, config: { globalProperties: {} } })
   setActivePinia(pinia)
   const wrapper = mount(ModuleRulePanel, {
     props: {
       moduleId: 'order',
-      fields: FIELDS,
-      querySchema: {},
-      refRulesReverse,
-      modules: MODULES,
       loading: false,
       modelValue: rules,
     },
@@ -94,56 +69,47 @@ beforeEach(() => {
   document.body.innerHTML = ''
 })
 
-describe('删除规则面板', () => {
+describe('删除 SQL 规则面板', () => {
   it('加载回填只补界面派生列，业务列不变', async () => {
-    const wrapper = await mountPanel({ rules: [{ ...dslRow }] })
+    const wrapper = await mountPanel({ rules: [{ ...sqlRow }] })
     const next = lastRules(wrapper)
 
     expect(next).toHaveLength(1)
     expect(next[0]._rowKey).toBeTruthy()
-    expect(next[0]._typeText).toBe('条件')
-    expect(next[0]._labelText).toBe('状态 等于 audit')
+    expect(next[0]._labelText).toBe('单据已销账，不能删除')
     // 剥掉 _ 前缀的内部键后与库中行完全一致（不置脏）
-    expect(stripInternalKeys(next[0])).toEqual(dslRow)
+    expect(stripInternalKeys(next[0])).toEqual(sqlRow)
   })
 
-  it('识别文案：写 SQL 的规则用提示文案当列表文案', async () => {
-    const sqlRow = {
-      ...dslRow,
-      b_id: '1900000000000000002',
-      b_predicate: 'select b_id from bill where b_settled = 1',
-      b_message: '单据已销账，不能删除',
-    }
-    const wrapper = await mountPanel({ rules: [sqlRow] })
+  it('识别文案：缺提示文案时退回 SQL 片段', async () => {
+    const wrapper = await mountPanel({
+      rules: [{ ...sqlRow, b_message: null }],
+    })
     const next = lastRules(wrapper)
 
-    expect(next[0]._typeText).toBe('SQL')
-    expect(next[0]._labelText).toBe('单据已销账，不能删除')
+    expect(next[0]._labelText).toContain('select b_id from bill')
   })
 
-  it('校验：勾条件必须真有条件，写 SQL 必须有 SQL 与提示文案', async () => {
-    const emptyDsl = {
-      ...dslRow,
+  it('校验：主键、:ids 标记、只读查询、提示文案都要满足', async () => {
+    const noId = { ...sqlRow, b_id: '' }
+    const noPlaceholder = { ...sqlRow, b_id: '1900000000000000002', b_sql: 'select b_id from bill' }
+    const notReadOnly = {
+      ...sqlRow,
       b_id: '1900000000000000003',
-      b_predicate: JSON.stringify({ kind: 'dsl', expr: { type: 'group', children: [] } }),
+      b_sql: `delete from bill where b_id in (${IDS_PLACEHOLDER})`,
     }
-    const sqlWithoutMessage = {
-      ...dslRow,
+    const noMessage = {
+      ...sqlRow,
       b_id: '1900000000000000004',
-      b_predicate: 'select b_id from bill where b_id in (:ids)',
       b_message: '',
     }
-    const wrapper = await mountPanel({ rules: [emptyDsl, sqlWithoutMessage] })
+    const wrapper = await mountPanel({ rules: [noId, noPlaceholder, notReadOnly, noMessage] })
     const errors = wrapper.vm.validate()
 
-    expect(errors).toContain('第 1 条规则：至少配置一个判定条件')
-    expect(errors).toContain('第 2 条规则：写 SQL 的规则必须填写提示文案')
-
-    // 引用规则不该出现在模块级列表里；没有主键的行也要拦住（新增取号失败的情况）
-    const refWrapper = await mountPanel({ rules: [{ ...dslRow, b_predicate: null }] })
-    expect(refWrapper.vm.validate()).toContain('第 1 条规则：引用规则请到「模块关联」面板维护')
-    const noIdWrapper = await mountPanel({ rules: [{ ...dslRow, b_id: '' }] })
-    expect(noIdWrapper.vm.validate()).toContain('第 1 条规则：缺少主键（请重新新增）')
+    expect(errors).toContain('第 1 条规则：缺少主键（请重新新增）')
+    expect(errors).toContain('第 2 条规则：规则 SQL 必须包含 :ids 标记')
+    expect(errors).toContain('第 3 条规则：规则 SQL 必须是只读查询（以 select 或 with 开头）')
+    expect(errors).toContain('第 4 条规则：请填写提示文案')
   })
 
   it('新增规则：取号后打开弹窗，确定时才落草稿', async () => {
@@ -153,39 +119,14 @@ describe('删除规则面板', () => {
 
     expect(wrapper.vm.editingIsNew).toBe(true)
     expect(wrapper.vm.editingRow.b_id).toBe('1900000000000000009')
+    expect(wrapper.vm.editingRow.b_module_id).toBe('order')
     expect(wrapper.vm.ruleModalOpen).toBe(true)
     // 未确定前不进列表
     expect(lastRules(wrapper)).toBe(null)
 
-    wrapper.vm.onRuleOk({ ...wrapper.vm.editingRow, b_predicate: 'select 1 as b_id' })
+    wrapper.vm.onRuleOk({ ...wrapper.vm.editingRow, b_sql: 'select 1 as b_id' })
     await nextTick()
     expect(lastRules(wrapper)).toHaveLength(1)
     expect(lastRules(wrapper)[0].b_id).toBe('1900000000000000009')
   })
-
-  it('只读区：把引用规则还原成模块名/字段列，并支持跳转到源模块', async () => {
-    const wrapper = await mountPanel({
-      refRulesReverse: [
-        {
-          b_id: '1900000000000000005',
-          b_scope_type: 'relation',
-          b_scope_id: 'order_item|b_order_id|order|b_id',
-          b_hook: 'delete.pre',
-          b_predicate: null,
-          b_canuse: 1,
-          b_xh: 10,
-        },
-      ],
-    })
-    await nextTick()
-
-    expect(wrapper.text()).toContain('其他模块在本模块上配置的引用规则')
-    expect(wrapper.text()).toContain('订单明细（order_item）')
-    expect(wrapper.text()).toContain('订单（order）')
-
-    const viewButton = wrapper.findAll('button').find((button) => button.text().includes('查看'))
-    expect(viewButton, '只读区应有查看按钮').toBeTruthy()
-    await viewButton.trigger('click')
-    expect(wrapper.emitted('navigate')?.[0]).toEqual(['order_item'])
-  })
 })
diff --git a/code/fms/fms-vue/tests/unit/module-rule-utils.spec.js b/code/fms/fms-vue/tests/unit/module-rule-utils.spec.js
index 9a30f929..00aa81e3 100644
--- a/code/fms/fms-vue/tests/unit/module-rule-utils.spec.js
+++ b/code/fms/fms-vue/tests/unit/module-rule-utils.spec.js
@@ -1,156 +1,66 @@
 /**
- * 删除规则配置工具（module-management/ruleUtils）：
- * 关系业务键拼串/还原、predicate 三态推断、识别文案、新增行构造、条件面板 items 构造。
+ * 删除 SQL 规则配置工具（module-management/ruleUtils）：
+ * 新增行构造、列表识别文案、SQL 内容校验。
  */
 import { describe, expect, it } from 'vitest'
 import {
-  REF_RULE_HINT,
-  buildRuleQueryItems,
-  createRefRuleRow,
+  IDS_PLACEHOLDER,
   createRuleRow,
-  isCompleteRelationKey,
-  itemMapOf,
-  parseRelationScopeId,
-  parseRulePredicate,
-  relationScopeId,
+  ruleHasSql,
+  ruleIsReadOnlySql,
   ruleLabel,
   ruleSummary,
-  ruleTypeText,
 } from '@/views/module/module-management/ruleUtils'
 
-const relation = {
-  b_source_module_id: 'order',
-  b_source_field: 'b_id',
-  b_target_module_id: 'order_item',
-  b_target_field: 'b_order_id',
-}
-
-const fields = [
-  { b_field: 'b_status', b_name: '状态', b_type: 'select', b_canuse: 1 },
-  { b_field: 'b_amount', b_name: '金额', b_type: 'money', b_canuse: 1 },
-  { b_field: 'b_off', b_name: '停用字段', b_type: 'input', b_canuse: 0 },
-]
-
-describe('删除规则工具', () => {
-  it('关系业务键与四列互逆', () => {
-    expect(relationScopeId(relation)).toBe('order|b_id|order_item|b_order_id')
-    expect(parseRelationScopeId('order|b_id|order_item|b_order_id')).toEqual({
-      sourceModuleId: 'order',
-      sourceField: 'b_id',
-      targetModuleId: 'order_item',
-      targetField: 'b_order_id',
-    })
-    expect(isCompleteRelationKey(relation)).toBe(true)
-    expect(isCompleteRelationKey({ ...relation, b_target_field: null })).toBe(false)
-  })
-
-  it('predicate 三态：空=引用、JSON=勾条件、其余=SQL（非法 JSON 降级为 SQL）', () => {
-    expect(parseRulePredicate({ b_predicate: null }).kind).toBe('reference')
-    expect(parseRulePredicate({ b_predicate: '   ' }).kind).toBe('reference')
-
-    const dsl = parseRulePredicate({
-      b_predicate: JSON.stringify({
-        kind: 'dsl',
-        expr: { type: 'group', children: [{ type: 'condition', field: 'b_status' }] },
-      }),
-    })
-    expect(dsl.kind).toBe('dsl')
-    expect(dsl.expr.children).toHaveLength(1)
-
-    expect(parseRulePredicate({ b_predicate: 'select 1 where b_id in (:ids)' })).toMatchObject({
-      kind: 'sql',
-    })
-    expect(parseRulePredicate({ b_predicate: '{不是合法 JSON' })).toMatchObject({ kind: 'sql' })
-    // JSON 合法但不是 dsl 形状：按 SQL 文本处理，内容不丢
-    expect(parseRulePredicate({ b_predicate: '{"foo":1}' })).toMatchObject({ kind: 'sql' })
-  })
-
-  it('类型文案与摘要：条件走中文描述、SQL 单行截断、引用固定说明', () => {
-    const itemByField = itemMapOf(buildRuleQueryItems(fields, {}))
-
-    const dslRow = {
-      b_predicate: JSON.stringify({
-        kind: 'dsl',
-        expr: {
-          type: 'group',
-          children: [{ type: 'condition', field: 'b_amount', operator: 'gt', value: 0 }],
-        },
-      }),
-    }
-    expect(ruleTypeText(dslRow)).toBe('条件')
-    expect(ruleSummary(dslRow, itemByField)).toBe('金额 大于 0')
-
-    const sqlRow = { b_predicate: 'select\n  b_id\nfrom bill where b_settled = 1' }
-    expect(ruleTypeText(sqlRow)).toBe('SQL')
-    expect(ruleSummary(sqlRow, itemByField)).toBe('select b_id from bill where b_settled = 1')
-
-    const refRow = { b_predicate: null }
-    expect(ruleTypeText(refRow)).toBe('引用')
-    expect(ruleSummary(refRow, itemByField)).toBe(REF_RULE_HINT)
-  })
-
-  it('识别文案：勾条件显示条件摘要，写 SQL 显示提示文案（缺文案退回 SQL 片段）', () => {
-    const itemByField = itemMapOf(buildRuleQueryItems(fields, {}))
-
-    const dslRow = {
-      b_predicate: JSON.stringify({
-        kind: 'dsl',
-        expr: {
-          type: 'group',
-          children: [{ type: 'condition', field: 'b_status', operator: 'eq', value: 'audit' }],
-        },
-      }),
-    }
-    expect(ruleLabel(dslRow, itemByField)).toBe('状态 等于 audit')
-
-    const sqlRow = { b_predicate: 'select 1 as b_id', b_message: '单据已销账，不能删除' }
-    expect(ruleLabel(sqlRow, itemByField)).toBe('单据已销账，不能删除')
-    expect(ruleLabel({ ...sqlRow, b_message: null }, itemByField)).toBe('select 1 as b_id')
-
-    expect(ruleLabel({ b_predicate: null }, itemByField)).toBe(REF_RULE_HINT)
-  })
-
-  it('新增行：主键由调用方取号传入，无名称/编码字段', () => {
+describe('删除 SQL 规则工具', () => {
+  it('新增行：主键由调用方取号传入，模块列直接物化，无名称/编码字段', () => {
     const rule = createRuleRow('order', { id: '1900000000000000001', xh: 30 })
     expect(rule).toMatchObject({
       b_id: '1900000000000000001',
-      b_scope_type: 'module',
-      b_scope_id: 'order',
-      b_hook: 'delete.pre',
-      b_predicate: null,
+      b_module_id: 'order',
       b_canuse: 1,
       b_xh: 30,
     })
+    // 新增行的 SQL 预填 :ids 骨架，直接可改
+    expect(rule.b_sql).toContain(IDS_PLACEHOLDER)
     expect(rule.b_code).toBeUndefined()
     expect(rule.b_name).toBeUndefined()
-
-    const ref = createRefRuleRow('order|b_id|order_item|b_order_id', '1900000000000000002')
-    expect(ref).toMatchObject({
-      b_id: '1900000000000000002',
-      b_scope_type: 'relation',
-      b_scope_id: 'order|b_id|order_item|b_order_id',
-      b_predicate: null,
-      b_hook: 'delete.pre',
-    })
+    // 旧设计的字段不再出现
+    expect(rule.b_scope_type).toBeUndefined()
+    expect(rule.b_scope_id).toBeUndefined()
+    expect(rule.b_predicate).toBeUndefined()
+    expect(rule.b_hook).toBeUndefined()
   })
 
-  it('items 构造：只列启用字段，类型映射控件，select 缺选项时降级为输入', () => {
-    const items = buildRuleQueryItems(fields, {
-      groups: [
-        {
-          conditions: [
-            { field: 'b_status', operator: 'in', component: 'select', options: [{ value: 'a' }] },
-          ],
-        },
-      ],
-    })
+  it('摘要：SQL 单行化并按长度截断，空 SQL 给可读提示', () => {
+    const row = { b_sql: 'select\n  b_id\nfrom bill where b_settled = 1' }
+    expect(ruleSummary(row)).toBe('select b_id from bill where b_settled = 1')
+    expect(ruleSummary({ b_sql: null })).toBe('未填写 SQL')
 
-    expect(items.map((item) => item.field.b_field)).toEqual(['b_status', 'b_amount'])
-    // 查询配置里定义过：沿用其操作符/控件/选项
-    expect(items[0].config).toMatchObject({ b_operator: 'in', b_component: 'select' })
-    expect(items[0].options).toEqual([{ value: 'a', label: 'a' }])
-    // 未定义过：按字段类型推导（金额 → 数字输入）
-    expect(items[1].config.b_component).toBe('number')
-    expect(items[1].config.b_operator).toBe('eq')
+    const long = { b_sql: `select b_id from t where ${'x'.repeat(100)}` }
+    const summary = ruleSummary(long)
+    expect(summary.endsWith('…')).toBe(true)
+    expect(summary.length).toBeLessThanOrEqual(81)
+  })
+
+  it('识别文案：优先提示文案，缺文案退回 SQL 片段', () => {
+    const row = {
+      b_sql: 'select 1 as b_id',
+      b_message: '单据已销账，不能删除',
+    }
+    expect(ruleLabel(row)).toBe('单据已销账，不能删除')
+    expect(ruleLabel({ ...row, b_message: null })).toBe('select 1 as b_id')
+    expect(ruleLabel({ ...row, b_message: '   ' })).toBe('select 1 as b_id')
+  })
+
+  it('SQL 校验：必须非空、包含 :ids、且是只读查询', () => {
+    expect(ruleHasSql({ b_sql: 'select b_id from t where b_id in (:ids)' })).toBe(true)
+    expect(ruleHasSql({ b_sql: 'select b_id from t' })).toBe(false)
+    expect(ruleHasSql({ b_sql: null })).toBe(false)
+
+    expect(ruleIsReadOnlySql({ b_sql: 'select b_id from t' })).toBe(true)
+    expect(ruleIsReadOnlySql({ b_sql: '  WITH x AS (select 1) select * from x' })).toBe(true)
+    expect(ruleIsReadOnlySql({ b_sql: 'delete from t' })).toBe(false)
+    expect(ruleIsReadOnlySql({ b_sql: null })).toBe(false)
   })
 })
diff --git a/code/fms/fms-vue/tests/views/module-unsaved-after-save.spec.js b/code/fms/fms-vue/tests/views/module-unsaved-after-save.spec.js
index 3f8a1134..56e46940 100644
--- a/code/fms/fms-vue/tests/views/module-unsaved-after-save.spec.js
+++ b/code/fms/fms-vue/tests/views/module-unsaved-after-save.spec.js
@@ -31,7 +31,6 @@ vi.mock('@/components/ui/message/message-manager.js', () => {
 
 import { loadDataApi, saveObjectApi } from '@/services/api'
 import { Message } from '@/components/ui/message/message-manager.js'
-import { createRefRuleRow } from '@/views/module/module-management/ruleUtils'
 
 /** 库中的一条关系：demo.b_name → other.b_name（一对多，源侧即当前模块） */
 function relationRow() {
@@ -110,7 +109,7 @@ function buildDb() {
     s_autocode: [],
     s_power: [],
     s_relation: [],
-    s_rule: [],
+    s_delete_rule: [],
     s_i18n: [{ b_key: 'module.demo', b_locale: 'en-US', b_value: 'Demo module' }],
   }
 }
@@ -130,20 +129,6 @@ beforeEach(() => {
           { b_id: 'en-US', b_name: 'English', b_default: 0 },
         ],
       })
-    // s_rule 的 scope 条件是两列（模块级 / 关系级）拼在同一个查询条件里，
-    // 这里按条件过滤，模拟后端 search_condition 的真实行为
-    if (view === 's_rule' && typeof condition === 'string') {
-      if (condition.includes("b_scope_type = 'module'")) {
-        return Promise.resolve({
-          data: rowsOf(view).filter((row) => row.b_scope_type === 'module'),
-        })
-      }
-      if (condition.includes("b_scope_type = 'relation'")) {
-        return Promise.resolve({
-          data: rowsOf(view).filter((row) => row.b_scope_type === 'relation'),
-        })
-      }
-    }
     return Promise.resolve({ data: rowsOf(view) })
   })
 
@@ -487,34 +472,14 @@ describe('模块管理：保存后的未保存判定', () => {
     ])
   })
 
-  it('删除规则：模块级规则加载不脏，只提交变更（雪花主键）', async () => {
+  it('删除 SQL 规则：加载不脏，只提交变更（雪花主键）', async () => {
     db.s_relation = [relationRow()]
-    db.s_rule = [
+    db.s_delete_rule = [
       {
         b_id: '1900000000000000001',
-        b_scope_type: 'module',
-        b_scope_id: 'demo',
-        b_hook: 'delete.pre',
-        b_predicate: JSON.stringify({
-          kind: 'dsl',
-          expr: {
-            type: 'group',
-            children: [
-              { type: 'condition', field: 'b_name', operator: 'like', value: 'a', join: 'and' },
-            ],
-          },
-        }),
-        b_message: null,
-        b_canuse: 1,
-        b_xh: 10,
-      },
-      {
-        b_id: '1900000000000000002',
-        b_scope_type: 'relation',
-        b_scope_id: 'demo|b_name|other|b_name',
-        b_hook: 'delete.pre',
-        b_predicate: null,
-        b_message: null,
+        b_module_id: 'demo',
+        b_sql: 'select b_id from demo where b_id in (:ids) and b_name like N\'a\'',
+        b_message: '示例模块记录已锁定，不能删除',
         b_canuse: 1,
         b_xh: 10,
       },
@@ -526,9 +491,8 @@ describe('模块管理：保存后的未保存判定', () => {
     await flushPromises()
     await flushPromises()
 
-    // 模块级规则进 rules，关系级进 refRules；打开即干净
+    // 规则进 rules；打开即干净
     expect(wrapper.vm.rules).toHaveLength(1)
-    expect(wrapper.vm.refRules).toHaveLength(1)
     expect(wrapper.vm.hasUnsavedChanges()).toBe(false)
 
     wrapper.vm.rules[0].b_canuse = 0
@@ -537,13 +501,12 @@ describe('模块管理：保存后的未保存判定', () => {
     await wrapper.vm.handleSave()
     await settleConfigReload(wrapper)
 
-    const ruleReq = savedRequests.find((request) => request.table === 's_rule')
-    expect(ruleReq, '规则变更应提交 s_rule').toBeTruthy()
+    const ruleReq = savedRequests.find((request) => request.table === 's_delete_rule')
+    expect(ruleReq, '规则变更应提交 s_delete_rule').toBeTruthy()
     expect(ruleReq.key_field).toBe('b_id')
     expect(ruleReq.updates?.[0]).toMatchObject({
       b_id: '1900000000000000001',
-      b_scope_type: 'module',
-      b_scope_id: 'demo',
+      b_module_id: 'demo',
       b_canuse: 0,
     })
     // 关系未变：不产生 s_relation 请求
@@ -551,7 +514,7 @@ describe('模块管理：保存后的未保存判定', () => {
     expect(wrapper.vm.hasUnsavedChanges()).toBe(false)
   })
 
-  it('关联面板勾选引用保护：保存时新增一条 relation 范围的规则', async () => {
+  it('关联删除处理：改 b_on_delete 随 s_relation 一起提交，不产生规则行', async () => {
     db.s_relation = [relationRow()]
     const wrapper = await mountManagement()
     await flushPromises()
@@ -559,41 +522,34 @@ describe('模块管理：保存后的未保存判定', () => {
     await flushPromises()
     await flushPromises()
 
-    expect(wrapper.vm.refRules).toEqual([])
-    wrapper.vm.refRules = [createRefRuleRow('demo|b_name|other|b_name', '1900000000000000003')]
+    expect(wrapper.vm.rules).toEqual([])
+    wrapper.vm.relations[0].b_on_delete = 'cascade'
     expect(wrapper.vm.hasUnsavedChanges()).toBe(true)
 
     await wrapper.vm.handleSave()
     await settleConfigReload(wrapper)
 
-    const refReq = savedRequests.find((request) => request.table === 's_rule')
-    expect(refReq?.key_field).toBe('b_id')
-    expect(refReq?.inserts?.[0]).toMatchObject({
-      b_id: '1900000000000000003',
-      b_scope_type: 'relation',
-      b_scope_id: 'demo|b_name|other|b_name',
-      b_predicate: null,
-      b_hook: 'delete.pre',
-    })
+    const relationReq = savedRequests.find((request) => request.table === 's_relation')
+    expect(relationReq?.updates?.[0]).toMatchObject({ b_on_delete: 'cascade' })
+    // 关联处置收敛到 s_relation，不再生成任何规则表请求
+    expect(savedRequests.some((request) => request.table === 's_delete_rule')).toBe(false)
     expect(wrapper.vm.hasUnsavedChanges()).toBe(false)
   })
 
-  it('删除模块应一并清理模块级与关系级删除规则（s_rule）', async () => {
+  it('删除模块应一并清理删除 SQL 规则（s_delete_rule）', async () => {
     db.s_relation = [relationRow()]
-    db.s_rule = [
+    db.s_delete_rule = [
       {
         b_id: '1900000000000000001',
-        b_scope_type: 'module',
-        b_scope_id: 'demo',
-        b_hook: 'delete.pre',
-        b_predicate: 'select 1 as b_id',
+        b_module_id: 'demo',
+        b_sql: 'select 1 as b_id',
+        b_message: '不能删除',
       },
       {
         b_id: '1900000000000000002',
-        b_scope_type: 'relation',
-        b_scope_id: 'demo|b_name|other|b_name',
-        b_hook: 'delete.pre',
-        b_predicate: null,
+        b_module_id: 'other',
+        b_sql: 'select 1 as b_id',
+        b_message: '不能删除',
       },
     ]
     const wrapper = await mountManagement()
@@ -607,16 +563,12 @@ describe('模块管理：保存后的未保存判定', () => {
     await wrapper.vm.onConfirmOk()
     await flushPromises()
 
-    const ruleReqs = savedRequests.filter((request) => request.table === 's_rule')
-    const moduleReq = ruleReqs.find(
-      (request) => request.deletes?.[0]?.b_scope_type === 'module' && request.deletes.length === 1,
+    const ruleReqs = savedRequests.filter((request) => request.table === 's_delete_rule')
+    const moduleReq = ruleReqs.find((request) => request.deletes?.[0]?.b_module_id === 'demo')
+    expect(moduleReq?.deletes).toEqual([{ b_module_id: 'demo' }])
+    // 只按模块列清理，不误伤其他模块的规则
+    expect(ruleReqs.every((request) => request.deletes.every((row) => row.b_module_id === 'demo'))).toBe(
+      true,
     )
-    expect(moduleReq?.deletes).toEqual([{ b_scope_type: 'module', b_scope_id: 'demo' }])
-    const relationReq = ruleReqs.find((request) =>
-      request.deletes?.some((row) => row.b_scope_type === 'relation'),
-    )
-    expect(relationReq?.deletes).toEqual([
-      { b_scope_type: 'relation', b_scope_id: 'demo|b_name|other|b_name' },
-    ])
   })
 })
diff --git a/code/fms/sql/fms_core.sql b/code/fms/sql/fms_core.sql
index 4f94cac5..3d6ca79f 100644
--- a/code/fms/sql/fms_core.sql
+++ b/code/fms/sql/fms_core.sql
@@ -205,7 +205,7 @@ create table dbo.s_relation (
     b_target_module_id varchar(50) not null,   -- 目标模块
     b_target_field varchar(50) not null,       -- 目标字段
     b_relation_type varchar(20) not null,      -- one_to_one / one_to_many / many_to_one
-    b_on_delete varchar(20) not null default 'none', -- 删除连带：none不连带 / cascade连带删除 / archive连带归档
+    b_on_delete varchar(20) not null default 'restrict', -- 删除处置：restrict有外部引用即拒绝 / cascade连带删除 / none不处理不保护
     b_canuse tinyint not null default 1,       -- 是否启用（0/1）
     b_xh int not null default 0,               -- 显示顺序
     primary key (
@@ -226,21 +226,19 @@ create index ix_s_relation_target
 GO
 
 /* ============================================================================
-   9.1 删除规则
+   9.1 删除 SQL 规则
 
-   挂在模块（业务条件：勾条件 / 写 SQL）或模块关系（存在引用即拒绝删除）上的删除前规则。
-   规则类型不单独存列，由 b_predicate 推断：空=引用规则；JSON=勾条件；其余=SQL 文本。
-   b_scope_id 是挂载对象的业务键：模块=模块编码；关系=源模块|源字段|目标模块|目标字段。
-   主键用雪花 id（新增时前端取号，与业务表一致）：规则没有天然业务键，也不要求 IT 填编码。
+   模块级“什么情况下不允许删除”的规则：b_sql 是只读查询，返回至少一行即拒绝本批删除。
+   只服务模块删除（target=module）；无模块的技术表走直接删除，不受本表约束。
+   关系上的关联处置（含引用保护）由 s_relation.b_on_delete 表达，不再挂规则行。
+   主键用雪花 id（新增时前端取号）：规则没有天然业务键，也不要求 IT 填编码。
    ============================================================================ */
 
-create table dbo.s_rule (
+create table dbo.s_delete_rule (
     b_id bigint not null,                      -- 雪花主键（新增时前端经 /data/nextid 取号）
-    b_scope_type varchar(20) not null,         -- module / relation（挂载范围）
-    b_scope_id varchar(250) not null,          -- module=模块编码；relation=源模块|源字段|目标模块|目标字段
-    b_hook varchar(30) not null,               -- delete.pre（一期只做这个），save.pre 留位
-    b_predicate nvarchar(max) null,            -- 空=引用规则；JSON={"kind":"dsl","expr":…}=勾条件；其余=SQL 文本
-    b_message nvarchar(500) null,              -- 提示文案（写 SQL 必填；勾条件可空，引擎按条件自动生成）
+    b_module_id varchar(50) not null,          -- 规则所属数据模块编码（对应 s_module.b_id）
+    b_sql nvarchar(max) not null,              -- 只读查询 SQL，用 :ids 标记本次待删 ID 集合
+    b_message nvarchar(500) null,              -- 删除失败时的提示文案（第一阶段固定文案）
     b_canuse tinyint not null default 1,       -- 是否启用（0/1）
     b_xh int not null default 0,               -- 执行顺序（并列按 b_xh、b_id）
     b_created_by varchar(50) null,             -- 审计列由服务端维护，配置界面不提交
@@ -251,8 +249,8 @@ create table dbo.s_rule (
 );
 GO
 
-create index ix_s_rule_scope
-    on dbo.s_rule (b_scope_type, b_scope_id, b_hook, b_canuse, b_xh);
+create index ix_s_delete_rule_module
+    on dbo.s_delete_rule (b_module_id, b_canuse, b_xh);
 GO
 
 /* ============================================================================
diff --git a/code/fms/sql/fms_delete_rule.sql b/code/fms/sql/fms_delete_rule.sql
index 056580a1..dbb53b69 100644
--- a/code/fms/sql/fms_delete_rule.sql
+++ b/code/fms/sql/fms_delete_rule.sql
@@ -1,47 +1,100 @@
 /* ============================================================================
-   删除规则一期：s_relation 加删除连带列 + 新建规则表 s_rule
+   删除策略重构：s_relation 删除处置三值 + 新建删除 SQL 规则表 s_delete_rule
    ----------------------------------------------------------------------------
-   背景：见 FMS删除规则引擎设计.md（一期只落配置，后端引擎二期做）。
+   依据：FMS删除策略重构设计.md v1.2
+     第一阶段元数据脚本，只改结构，不含初始化数据。
    本脚本可重复执行：
-     - s_relation.b_on_delete 不存在时才加（存量行回填 'none'）；
-     - s_rule 直接重建（drop + create）——表里还没有规则数据时才可执行，
-       库中已有配置数据时请勿运行，改为手工迁移。
+     - s_relation.b_on_delete 不存在时才加，且默认值取 'restrict'；
+     - 存量关系的 b_on_delete 不批量回填（设计 §3.1：避免上线后突然改变存量删除行为）；
+       仅把历史遗留的 'archive' 归一到 'none'（阶段一不支持归档，避免执行器遇到未知值）；
+     - s_delete_rule 不存在才建；旧的 s_rule 已废弃，按需手工 drop（见文件末尾说明）。
    执行：fms-api 目录下
      java -cp "tools/migration/mssql-jdbc-13.4.0.jre11.jar" tools/migration/RunSqlFile.java \
           ../sql/fms_delete_rule.sql --dry-run
    确认分批正确后去掉 --dry-run 实跑（按 GO 分批、单事务、失败整体回滚）。
    ============================================================================ */
 
+/* 1. b_on_delete：补列并设定新语义的默认值。
+   新值域 restrict / cascade / none；默认 restrict 只作用于新建行，
+   存量行保持原值（历史为 'none'），由单独迁移决定是否升级。 */
 if col_length('dbo.s_relation', 'b_on_delete') is null
 begin
     alter table dbo.s_relation add
-        b_on_delete varchar(20) not null default 'none';  -- none不连带 / cascade连带删除 / archive连带归档
+        b_on_delete varchar(20) not null
+            constraint df_s_relation_on_delete default 'restrict';
 end
 GO
 
-drop table if exists dbo.s_rule;
+/* 2. 列已存在时，只改默认值约束，不动存量数据。 */
+if col_length('dbo.s_relation', 'b_on_delete') is not null
+begin
+    declare @constraint sysname;
+    select @constraint = dc.name
+    from sys.default_constraints dc
+    join sys.columns c
+      on c.object_id = dc.parent_object_id
+     and c.column_id = dc.parent_column_id
+    where dc.parent_object_id = object_id('dbo.s_relation')
+      and c.name = 'b_on_delete';
+
+    if @constraint is not null
+    begin
+        declare @dropSql nvarchar(400) =
+            N'alter table dbo.s_relation drop constraint ' + quotename(@constraint);
+        exec sp_executesql @dropSql;
+    end
+
+    alter table dbo.s_relation add
+        constraint df_s_relation_on_delete default 'restrict' for b_on_delete;
+end
 GO
 
-/* 删除规则表：挂在模块（业务条件）或模块关系（存在引用即拒绝删除）上。
-   规则类型不单独存列，由 b_predicate 推断：空=引用规则；JSON=勾条件；其余=SQL 文本。
-   主键用雪花 id（新增时前端取号，与业务表一致）：规则没有天然业务键，也不要求 IT 填编码。 */
-create table dbo.s_rule (
-    b_id bigint not null,                      -- 雪花主键（新增时前端经 /data/nextid 取号）
-    b_scope_type varchar(20) not null,         -- module / relation（挂载范围）
-    b_scope_id varchar(250) not null,          -- module=模块编码；relation=源模块|源字段|目标模块|目标字段
-    b_hook varchar(30) not null,               -- delete.pre（一期只做这个），save.pre 留位
-    b_predicate nvarchar(max) null,            -- 空=引用规则；JSON={"kind":"dsl","expr":…}=勾条件；其余=SQL 文本
-    b_message nvarchar(500) null,              -- 提示文案（写 SQL 必填；勾条件可空，引擎按条件自动生成）
-    b_canuse tinyint not null default 1,       -- 是否启用（0/1）
-    b_xh int not null default 0,               -- 执行顺序（并列按 b_xh、b_id）
-    b_created_by varchar(50) null,             -- 审计列由服务端维护，配置界面不提交
-    b_created_at datetime2 null,
-    b_updated_by varchar(50) null,
-    b_updated_at datetime2 null,
-    primary key (b_id)
-);
+/* 3. 历史 'archive' 阶段一不支持：归一为 'none'（不处理、不保护），
+   避免删除执行器读到未知处置值。空值与非法值同样归一，保证值域收敛。 */
+update dbo.s_relation
+   set b_on_delete = 'none'
+ where b_on_delete is null
+    or b_on_delete not in ('restrict', 'cascade', 'none');
 GO
 
-create index ix_s_rule_scope
-    on dbo.s_rule (b_scope_type, b_scope_id, b_hook, b_canuse, b_xh);
-GO
\ No newline at end of file
+/* 4. 删除 SQL 规则表。 */
+if object_id('dbo.s_delete_rule', 'U') is null
+begin
+    create table dbo.s_delete_rule (
+        b_id bigint not null,                      -- 雪花主键（新增时前端经 /data/nextid 取号）
+        b_module_id varchar(50) not null,          -- 规则所属数据模块编码（对应 s_module.b_id）
+        b_sql nvarchar(max) not null,              -- 只读查询 SQL，用 :ids 标记本次待删 ID 集合
+        b_message nvarchar(500) null,              -- 删除失败时的提示文案（第一阶段固定文案）
+        b_canuse tinyint not null default 1,       -- 是否启用（0/1）
+        b_xh int not null default 0,               -- 执行顺序（并列按 b_xh、b_id）
+        b_created_by varchar(50) null,             -- 审计列由服务端维护，配置界面不提交
+        b_created_at datetime2 null,
+        b_updated_by varchar(50) null,
+        b_updated_at datetime2 null,
+        primary key (b_id)
+    );
+end
+GO
+
+if not exists (
+    select 1 from sys.indexes
+    where name = 'ix_s_delete_rule_module'
+      and object_id = object_id('dbo.s_delete_rule')
+)
+begin
+    create index ix_s_delete_rule_module
+        on dbo.s_delete_rule (b_module_id, b_canuse, b_xh);
+end
+GO
+
+/* 5. 旧表 s_rule 的处置。
+   已确认库内 s_rule 无配置数据，可直接重建；此处刻意不 drop，
+   避免脚本误伤可能存在的历史配置。确认无数据后手工执行：
+
+     drop table if exists dbo.s_rule;
+
+   若库中确实存在规则数据，需先迁移：
+     - b_scope_type='module' 且 b_predicate 为 SQL 文本 → 写入 s_delete_rule
+       （b_module_id = b_scope_id，b_sql = b_predicate）；
+     - b_scope_type='relation'（引用规则）→ 置该关系 s_relation.b_on_delete='restrict'；
+     - b_predicate 为 JSON 勾条件的数据无法自动转换，需人工改写为等价 SQL。 */
diff --git a/code/fms/sql/fms_drop_s_rule.sql b/code/fms/sql/fms_drop_s_rule.sql
new file mode 100644
index 00000000..f889eabc
--- /dev/null
+++ b/code/fms/sql/fms_drop_s_rule.sql
@@ -0,0 +1,22 @@
+/* ============================================================================
+   删除废弃表 s_rule
+   ----------------------------------------------------------------------------
+   背景：删除策略重构（FMS删除策略重构设计.md v1.2）用 s_delete_rule 取代了
+   旧的泛化规则表 s_rule。s_rule 已无任何读取方（前端旧概念、后端引用均已移除），
+   且经核实库中行数为 0，可直接删除。
+
+   执行前已确认：
+     - catalog = FMS（RunSqlFile 自带校验）
+     - s_rule 行数 = 0
+     - s_delete_rule 已存在（新表就位）
+
+   执行：fms-api 目录下
+     java -cp "tools/migration/mssql-jdbc-13.4.0.jre11.jar" tools/migration/RunSqlFile.java \
+          ../sql/fms_drop_s_rule.sql
+   ============================================================================ */
+
+if object_id('dbo.s_rule', 'U') is not null
+begin
+    drop table dbo.s_rule;
+end
+GO
diff --git a/code/fms/sql/smoke_delete_seed.sql b/code/fms/sql/smoke_delete_seed.sql
new file mode 100644
index 00000000..a9608388
--- /dev/null
+++ b/code/fms/sql/smoke_delete_seed.sql
@@ -0,0 +1,17 @@
+/* 冒烟测试数据：主单 2 条，明细 3 条（O1 有 2 条明细，O2 有 1 条） */
+delete from dbo.smoke_order_item;
+GO
+delete from dbo.smoke_order;
+GO
+
+insert into dbo.smoke_order (b_id, b_no, b_status) values ('SO-1', N'单号一', 'draft');
+GO
+insert into dbo.smoke_order (b_id, b_no, b_status) values ('SO-2', N'单号二', 'audited');
+GO
+
+insert into dbo.smoke_order_item (b_item_id, b_order_id, b_name) values ('SI-1', 'SO-1', N'明细1');
+GO
+insert into dbo.smoke_order_item (b_item_id, b_order_id, b_name) values ('SI-2', 'SO-1', N'明细2');
+GO
+insert into dbo.smoke_order_item (b_item_id, b_order_id, b_name) values ('SI-3', 'SO-2', N'明细3');
+GO
diff --git a/code/fms/sql/smoke_delete_setup.sql b/code/fms/sql/smoke_delete_setup.sql
new file mode 100644
index 00000000..8856e282
--- /dev/null
+++ b/code/fms/sql/smoke_delete_setup.sql
@@ -0,0 +1,63 @@
+/* ============================================================================
+   删除策略冒烟测试夹具（可重复执行）
+   ----------------------------------------------------------------------------
+   建一对专用临时业务表 + 模块配置 + 删除规则，用于验证删除引擎：
+     smoke_order      主单（b_id varchar 业务键）
+     smoke_order_item 明细（b_item_id 主键，b_order_id 外键指向主单）
+
+   覆盖场景：
+     1. cascade：删主单连带删明细
+     2. restrict：明细被引用时拒绝删主单
+     3. SQL 规则：命中即整批拒绝
+     4. direct：按表直删
+
+   清理见 smoke_delete_teardown.sql。
+   ============================================================================ */
+
+if object_id('dbo.smoke_order_item', 'U') is null
+begin
+    create table dbo.smoke_order_item (
+        b_item_id varchar(50) not null primary key,
+        b_order_id varchar(50) not null,
+        b_name nvarchar(100) null
+    );
+end
+GO
+
+if object_id('dbo.smoke_order', 'U') is null
+begin
+    create table dbo.smoke_order (
+        b_id varchar(50) not null primary key,
+        b_no nvarchar(50) null,
+        b_status varchar(20) null
+    );
+end
+GO
+
+/* 模块配置：主单 */
+if not exists (select 1 from dbo.s_module where b_id = 'smoke_order')
+begin
+    insert into dbo.s_module (b_id, b_parent_id, b_depth, b_path, b_name, b_module_type, b_view_table, b_save_table, b_key_field, b_canuse, b_xh)
+    values ('smoke_order', null, 0, 'smoke_order', N'冒烟测试主单', 'data', 'smoke_order', 'smoke_order', 'b_id', 1, 9001);
+end
+GO
+
+/* 模块配置：明细 */
+if not exists (select 1 from dbo.s_module where b_id = 'smoke_order_item')
+begin
+    insert into dbo.s_module (b_id, b_parent_id, b_depth, b_path, b_name, b_module_type, b_view_table, b_save_table, b_key_field, b_canuse, b_xh)
+    values ('smoke_order_item', null, 0, 'smoke_order_item', N'冒烟测试明细', 'data', 'smoke_order_item', 'smoke_order_item', 'b_item_id', 1, 9002);
+end
+GO
+
+/* 关系：明细 → 主单，many_to_one。
+   按设计 §3.2，many_to_one 的外键在源字段：源字段 b_order_id 是明细表里的外键列，
+   目标字段 b_id 是主单被引用的列。删除主单时，明细（引用方）被 cascade 连带删除。 */
+delete from dbo.s_relation where b_source_module_id = 'smoke_order_item' and b_target_module_id = 'smoke_order';
+GO
+
+insert into dbo.s_relation
+    (b_source_module_id, b_source_field, b_target_module_id, b_target_field, b_relation_type, b_on_delete, b_canuse, b_xh)
+values
+    ('smoke_order_item', 'b_order_id', 'smoke_order', 'b_id', 'many_to_one', 'cascade', 1, 10);
+GO
diff --git a/code/fms/sql/smoke_delete_teardown.sql b/code/fms/sql/smoke_delete_teardown.sql
new file mode 100644
index 00000000..32c219f4
--- /dev/null
+++ b/code/fms/sql/smoke_delete_teardown.sql
@@ -0,0 +1,40 @@
+/* ============================================================================
+   删除策略冒烟测试夹具：清理（可重复执行，表不存在也能跑通）
+   ----------------------------------------------------------------------------
+   注意两点，都是实测踩出来的：
+   1. 关系行必须按双向清理：冒烟会临时造反向关系（环路场景 smoke_order → smoke_order_item），
+      只删一个方向会留下指向已 drop 表的孤儿行。
+   2. 业务表的 delete 必须用 object_id 守卫：清理可重入，表已 drop 时直接 delete 会报
+      Invalid object name，而 RunSqlFile 是单事务、一批失败整体回滚，
+      会导致整个清理静默失效（前面几批的删除也被回滚）。
+   ============================================================================ */
+
+delete from dbo.s_delete_rule where b_module_id in ('smoke_order', 'smoke_order_item');
+GO
+
+/* 关系行：双向清理，避免孤儿关系 */
+delete from dbo.s_relation
+ where b_source_module_id in ('smoke_order', 'smoke_order_item')
+    or b_target_module_id in ('smoke_order', 'smoke_order_item');
+GO
+
+delete from dbo.s_module where b_id in ('smoke_order', 'smoke_order_item');
+GO
+
+if object_id('dbo.smoke_order_item', 'U') is not null
+begin
+    delete from dbo.smoke_order_item;
+end
+GO
+
+if object_id('dbo.smoke_order', 'U') is not null
+begin
+    delete from dbo.smoke_order;
+end
+GO
+
+drop table if exists dbo.smoke_order_item;
+GO
+
+drop table if exists dbo.smoke_order;
+GO
diff --git a/code/fms/权限分配原型.html b/code/fms/权限分配原型.html
new file mode 100644
index 00000000..39718175
--- /dev/null
+++ b/code/fms/权限分配原型.html
@@ -0,0 +1,2350 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>FMS 权限分配原型</title>
+    <style>
+      :root {
+        --bg: #f4f7fb;
+        --surface: #ffffff;
+        --surface-muted: #f8fafc;
+        --surface-blue: #f0f6ff;
+        --line: #dfe7f1;
+        --line-strong: #c9d6e5;
+        --text: #162334;
+        --text-muted: #6d7c8f;
+        --text-soft: #8c9aac;
+        --blue: #1f67d6;
+        --blue-dark: #1451ad;
+        --blue-soft: #e8f1ff;
+        --green: #17835b;
+        --green-soft: #e9f8f1;
+        --amber: #a66608;
+        --amber-soft: #fff5df;
+        --red: #bd4d52;
+        --red-soft: #fff0f0;
+        --shadow: 0 12px 32px rgba(27, 52, 83, 0.08);
+        --radius: 12px;
+        --radius-sm: 8px;
+        --font: "Segoe UI", "Microsoft YaHei", "PingFang SC", Arial, sans-serif;
+      }
+
+      * { box-sizing: border-box; }
+
+      html, body { min-height: 100%; }
+
+      body {
+        margin: 0;
+        color: var(--text);
+        background: var(--bg);
+        font: 14px/1.5 var(--font);
+      }
+
+      button, input, select { font: inherit; }
+
+      button {
+        border: 0;
+        cursor: pointer;
+      }
+
+      button:focus-visible,
+      input:focus-visible,
+      select:focus-visible {
+        outline: 3px solid rgba(31, 103, 214, 0.22);
+        outline-offset: 2px;
+      }
+
+      .icon {
+        width: 17px;
+        height: 17px;
+        flex: 0 0 auto;
+        fill: none;
+        stroke: currentColor;
+        stroke-linecap: round;
+        stroke-linejoin: round;
+        stroke-width: 1.8;
+      }
+
+      .app-shell {
+        min-height: 100vh;
+        display: flex;
+        flex-direction: column;
+      }
+
+      .topbar {
+        min-height: 68px;
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        padding: 0 28px;
+        background: var(--surface);
+        border-bottom: 1px solid var(--line);
+      }
+
+      .brand,
+      .brand-mark,
+      .top-actions,
+      .crumbs,
+      .user-summary,
+      .button-row,
+      .inline,
+      .tab-button,
+      .section-title,
+      .page-title,
+      .status-line,
+      .node-main,
+      .node-meta,
+      .user-row,
+      .mini-stat,
+      .module-heading,
+      .module-meta,
+      .summary-item,
+      .notice,
+      .dependency-row,
+      .modal-actions {
+        display: flex;
+        align-items: center;
+      }
+
+      .brand { gap: 12px; }
+
+      .brand-mark {
+        width: 34px;
+        height: 34px;
+        justify-content: center;
+        color: #fff;
+        background: var(--blue);
+        border-radius: 9px;
+      }
+
+      .brand-name {
+        font-weight: 700;
+        letter-spacing: 0.02em;
+      }
+
+      .brand-subtitle {
+        margin-left: 5px;
+        color: var(--text-soft);
+        font-size: 12px;
+        font-weight: 400;
+      }
+
+      .top-actions { gap: 12px; }
+
+      .save-status {
+        display: inline-flex;
+        align-items: center;
+        gap: 6px;
+        color: var(--text-soft);
+        font-size: 12px;
+        white-space: nowrap;
+      }
+
+      .save-status::before {
+        width: 7px;
+        height: 7px;
+        content: "";
+        background: var(--green);
+        border-radius: 50%;
+      }
+
+      .save-status.pending { color: var(--amber); }
+      .save-status.pending::before { background: #d79a26; }
+
+      .top-discard { display: none; }
+      .top-discard.visible { display: inline-flex; }
+
+      .top-link {
+        display: inline-flex;
+        align-items: center;
+        gap: 7px;
+        min-height: 40px;
+        padding: 0 11px;
+        color: var(--text-muted);
+        background: transparent;
+        border-radius: var(--radius-sm);
+      }
+
+      .top-link:hover { color: var(--text); background: var(--surface-muted); }
+
+      .save-button,
+      .primary-button {
+        min-height: 40px;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        gap: 8px;
+        padding: 0 16px;
+        color: #fff;
+        background: var(--blue);
+        border-radius: var(--radius-sm);
+        box-shadow: 0 4px 12px rgba(31, 103, 214, 0.2);
+        transition: transform 160ms ease, background 160ms ease, box-shadow 160ms ease;
+      }
+
+      .save-button:hover,
+      .primary-button:hover {
+        background: var(--blue-dark);
+        box-shadow: 0 6px 16px rgba(31, 103, 214, 0.26);
+        transform: translateY(-1px);
+      }
+
+      .body-shell {
+        min-height: 0;
+        flex: 1;
+        display: flex;
+      }
+
+      .users-panel {
+        width: 252px;
+        flex: 0 0 252px;
+        padding: 22px 14px;
+        background: var(--surface);
+        border-right: 1px solid var(--line);
+      }
+
+      .panel-label {
+        margin: 0 12px 10px;
+        color: var(--text-soft);
+        font-size: 11px;
+        font-weight: 700;
+        letter-spacing: 0.1em;
+        text-transform: uppercase;
+      }
+
+      .search-box {
+        height: 38px;
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        margin: 0 2px 18px;
+        padding: 0 11px;
+        color: var(--text-soft);
+        background: var(--surface-muted);
+        border: 1px solid var(--line);
+        border-radius: var(--radius-sm);
+      }
+
+      .search-box input {
+        width: 100%;
+        min-width: 0;
+        color: var(--text);
+        background: transparent;
+        border: 0;
+        outline: none;
+      }
+
+      .user-list { display: grid; gap: 5px; }
+
+      .user-row {
+        width: 100%;
+        gap: 10px;
+        padding: 11px 10px;
+        text-align: left;
+        color: var(--text-muted);
+        background: transparent;
+        border: 1px solid transparent;
+        border-radius: 10px;
+        transition: background 160ms ease, border-color 160ms ease, color 160ms ease;
+      }
+
+      .user-row:hover { background: var(--surface-muted); color: var(--text); }
+
+      .user-row.active {
+        color: var(--blue-dark);
+        background: var(--surface-blue);
+        border-color: #cfe0fb;
+      }
+
+      .avatar {
+        width: 34px;
+        height: 34px;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        flex: 0 0 auto;
+        color: var(--blue-dark);
+        background: #dbeaff;
+        border-radius: 50%;
+        font-size: 12px;
+        font-weight: 700;
+      }
+
+      .avatar.green { color: #106a4c; background: #d9f3e7; }
+      .avatar.orange { color: #8c5c09; background: #ffedc6; }
+
+      .user-copy { min-width: 0; }
+
+      .user-name {
+        overflow: hidden;
+        color: inherit;
+        font-weight: 650;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .user-role {
+        overflow: hidden;
+        color: var(--text-soft);
+        font-size: 12px;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .user-row.active .user-role { color: #6284b4; }
+
+      .workspace {
+        min-width: 0;
+        flex: 1;
+        padding: 26px 30px 34px;
+        overflow: auto;
+      }
+
+      .workspace-head {
+        max-width: 1540px;
+        margin: 0 auto;
+      }
+
+      .crumbs {
+        gap: 7px;
+        margin-bottom: 7px;
+        color: var(--text-soft);
+        font-size: 12px;
+      }
+
+      .page-title {
+        justify-content: space-between;
+        gap: 16px;
+        margin-bottom: 18px;
+      }
+
+      .page-title h1 {
+        margin: 0;
+        font-size: 24px;
+        letter-spacing: -0.02em;
+      }
+
+      .page-title p {
+        margin: 5px 0 0;
+        color: var(--text-muted);
+      }
+
+      .user-summary {
+        gap: 10px;
+        padding: 8px 10px 8px 8px;
+        background: var(--surface);
+        border: 1px solid var(--line);
+        border-radius: 10px;
+      }
+
+      .summary-copy { line-height: 1.25; }
+      .summary-copy strong { display: block; font-size: 13px; }
+      .summary-copy span { color: var(--text-soft); font-size: 11px; }
+
+      .notice {
+        gap: 10px;
+        min-height: 47px;
+        margin-bottom: 18px;
+        padding: 10px 13px;
+        color: #315a8c;
+        background: var(--surface-blue);
+        border: 1px solid #cfe0fb;
+        border-radius: var(--radius-sm);
+      }
+
+      .notice strong { color: #1d4f8c; }
+
+      .authorization-toolbar {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 20px;
+        margin-bottom: 15px;
+        padding: 15px 17px;
+        background: var(--surface);
+        border: 1px solid var(--line);
+        border-radius: var(--radius);
+        box-shadow: var(--shadow);
+      }
+
+      .toolbar-copy { min-width: 0; }
+
+      .toolbar-eyebrow {
+        display: block;
+        margin-bottom: 4px;
+        color: var(--text-soft);
+        font-size: 11px;
+        font-weight: 700;
+        letter-spacing: 0.08em;
+        text-transform: uppercase;
+      }
+
+      .toolbar-title {
+        display: flex;
+        align-items: center;
+        flex-wrap: wrap;
+        gap: 8px;
+        margin: 0;
+        font-size: 16px;
+      }
+
+      .toolbar-copy p { margin: 3px 0 0; color: var(--text-muted); font-size: 12px; }
+
+      .toolbar-controls {
+        display: flex;
+        align-items: center;
+        justify-content: flex-end;
+        flex-wrap: wrap;
+        gap: 8px;
+      }
+
+      .toolbar-field {
+        display: inline-flex;
+        align-items: center;
+        gap: 7px;
+        color: var(--text-muted);
+        font-size: 12px;
+        white-space: nowrap;
+      }
+
+      .role-select {
+        min-height: 35px;
+        min-width: 170px;
+        padding: 0 27px 0 9px;
+        color: var(--text);
+        background: var(--surface);
+        border: 1px solid var(--line-strong);
+        border-radius: 7px;
+      }
+
+      .domain-overview {
+        margin-bottom: 15px;
+        padding: 16px 17px;
+        background: var(--surface);
+        border: 1px solid var(--line);
+        border-radius: var(--radius);
+        box-shadow: var(--shadow);
+      }
+
+      .domain-overview-head {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 12px;
+        margin-bottom: 11px;
+      }
+
+      .domain-overview-head h2 { margin: 0; font-size: 14px; }
+      .domain-overview-head p { margin: 3px 0 0; color: var(--text-muted); font-size: 12px; }
+
+      .domain-grid {
+        display: grid;
+        grid-template-columns: repeat(3, minmax(0, 1fr));
+        gap: 9px;
+      }
+
+      .domain-card {
+        min-width: 0;
+        display: flex;
+        align-items: center;
+        gap: 10px;
+        padding: 11px;
+        color: var(--text-muted);
+        background: var(--surface-muted);
+        border: 1px solid var(--line);
+        border-radius: 9px;
+        text-align: left;
+        transition: background 150ms ease, border-color 150ms ease, color 150ms ease, transform 150ms ease;
+      }
+
+      .domain-card:hover { color: var(--text); border-color: #b8cee9; transform: translateY(-1px); }
+      .domain-card.active { color: var(--blue-dark); background: var(--surface-blue); border-color: #aac8ec; }
+
+      .domain-card-icon {
+        width: 31px;
+        height: 31px;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        flex: 0 0 auto;
+        color: var(--blue);
+        background: var(--surface);
+        border: 1px solid var(--line);
+        border-radius: 8px;
+      }
+
+      .domain-card-copy { min-width: 0; flex: 1; }
+      .domain-card-name { display: block; font-weight: 650; }
+      .domain-card-desc { display: block; overflow: hidden; color: var(--text-soft); font-size: 11px; text-overflow: ellipsis; white-space: nowrap; }
+      .domain-card.active .domain-card-desc { color: #6284b4; }
+
+      .role-badge {
+        display: inline-flex;
+        align-items: center;
+        min-height: 21px;
+        padding: 0 6px;
+        color: var(--blue-dark);
+        background: var(--blue-soft);
+        border: 1px solid #cfe0fb;
+        border-radius: 5px;
+        font-size: 10px;
+        white-space: nowrap;
+      }
+
+      .preview-actions {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        margin-top: 12px;
+        padding-top: 12px;
+        border-top: 1px solid var(--line);
+      }
+
+      .preview-actions .ghost-button { flex: 1; }
+
+      .effective-summary {
+        display: grid;
+        grid-template-columns: repeat(3, minmax(0, 1fr));
+        gap: 8px;
+        margin-bottom: 15px;
+      }
+
+      .effective-stat {
+        padding: 10px;
+        background: var(--surface-muted);
+        border: 1px solid var(--line);
+        border-radius: 8px;
+      }
+
+      .effective-stat strong { display: block; font-size: 18px; }
+      .effective-stat span { color: var(--text-soft); font-size: 11px; }
+
+      .effective-section + .effective-section { margin-top: 16px; }
+      .effective-section h3 { margin: 0 0 8px; font-size: 13px; }
+
+      .effective-list { display: grid; gap: 7px; }
+
+      .effective-row {
+        display: flex;
+        align-items: flex-start;
+        justify-content: space-between;
+        gap: 12px;
+        padding: 9px 10px;
+        background: var(--surface-muted);
+        border: 1px solid var(--line);
+        border-radius: 7px;
+      }
+
+      .effective-row strong { display: block; font-size: 12px; }
+      .effective-row span { display: block; color: var(--text-soft); font-size: 11px; }
+      .effective-empty { padding: 12px; color: var(--text-soft); background: var(--surface-muted); border-radius: 8px; font-size: 12px; }
+
+      .change-list { display: grid; gap: 7px; margin-top: 12px; }
+
+      .change-item {
+        display: flex;
+        align-items: flex-start;
+        gap: 8px;
+        padding: 8px 9px;
+        color: var(--text-muted);
+        background: var(--amber-soft);
+        border: 1px solid #f3dfac;
+        border-radius: 7px;
+        font-size: 11px;
+      }
+
+      .change-item .icon { width: 14px; height: 14px; flex: 0 0 auto; color: var(--amber); }
+
+      .effective-modal .modal-body { max-height: min(590px, calc(100vh - 180px)); overflow: auto; }
+
+      .simple-workspace { display: grid; gap: 15px; }
+
+      .simple-intro {
+        display: flex;
+        align-items: flex-start;
+        justify-content: space-between;
+        gap: 18px;
+        padding: 20px;
+        background: var(--surface);
+        border: 1px solid var(--line);
+        border-radius: var(--radius);
+        box-shadow: var(--shadow);
+      }
+
+      .simple-intro h2 { margin: 7px 0 4px; font-size: 19px; letter-spacing: -0.02em; }
+      .simple-intro p { margin: 0; color: var(--text-muted); }
+
+      .simple-grid {
+        display: grid;
+        grid-template-columns: minmax(360px, 1.05fr) minmax(350px, 0.95fr);
+        gap: 15px;
+        align-items: stretch;
+      }
+
+      .business-card,
+      .simple-preview {
+        min-width: 0;
+        padding: 19px;
+        background: var(--surface);
+        border: 1px solid var(--line);
+        border-radius: var(--radius);
+        box-shadow: var(--shadow);
+      }
+
+      .business-head,
+      .simple-preview-head {
+        display: flex;
+        align-items: flex-start;
+        justify-content: space-between;
+        gap: 14px;
+      }
+
+      .business-head h2,
+      .simple-preview-head h2 { margin: 0; font-size: 18px; }
+      .business-head p,
+      .simple-preview-head p { margin: 4px 0 0; color: var(--text-muted); font-size: 12px; }
+
+      .business-icon {
+        width: 42px;
+        height: 42px;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        flex: 0 0 auto;
+        color: var(--blue);
+        background: var(--blue-soft);
+        border: 1px solid #cfe0fb;
+        border-radius: 10px;
+      }
+
+      .business-modules {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 7px;
+        margin: 18px 0;
+        padding: 11px;
+        background: var(--surface-muted);
+        border: 1px dashed var(--line-strong);
+        border-radius: 8px;
+      }
+
+      .business-module {
+        display: inline-flex;
+        align-items: center;
+        gap: 6px;
+        min-height: 29px;
+        padding: 0 9px;
+        color: var(--text-muted);
+        background: var(--surface);
+        border: 1px solid var(--line);
+        border-radius: 6px;
+        font-size: 12px;
+      }
+
+      .business-module .icon { width: 14px; height: 14px; color: var(--blue); }
+
+      .preset-title {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 10px;
+        margin-bottom: 9px;
+      }
+
+      .preset-title h3 { margin: 0; font-size: 13px; }
+      .preset-title span { color: var(--text-soft); font-size: 11px; }
+
+      .preset-grid { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 8px; }
+
+      .preset-button {
+        min-height: 78px;
+        display: flex;
+        flex-direction: column;
+        align-items: flex-start;
+        justify-content: center;
+        gap: 4px;
+        padding: 10px;
+        color: var(--text-muted);
+        background: var(--surface);
+        border: 1px solid var(--line-strong);
+        border-radius: 8px;
+        text-align: left;
+        transition: background 150ms ease, border-color 150ms ease, color 150ms ease, transform 150ms ease;
+      }
+
+      .preset-button:hover { color: var(--blue-dark); background: var(--surface-blue); border-color: #aac8ec; transform: translateY(-1px); }
+      .preset-button.active { color: var(--blue-dark); background: var(--surface-blue); border-color: var(--blue); box-shadow: inset 0 0 0 1px rgba(31, 103, 214, 0.08); }
+      .preset-button strong { font-size: 13px; }
+      .preset-button span { color: var(--text-soft); font-size: 11px; line-height: 1.35; }
+      .preset-button.active span { color: #6284b4; }
+
+      .preview-list { display: grid; gap: 9px; margin-top: 17px; }
+
+      .preview-row {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 12px;
+        min-height: 45px;
+        padding: 9px 10px;
+        background: var(--surface-muted);
+        border: 1px solid var(--line);
+        border-radius: 8px;
+      }
+
+      .preview-row-main { min-width: 0; display: flex; align-items: center; gap: 9px; }
+      .preview-row-main .icon { color: var(--blue); }
+      .preview-row-copy { min-width: 0; }
+      .preview-row-name { display: block; font-weight: 650; }
+      .preview-row-desc { display: block; color: var(--text-soft); font-size: 11px; }
+
+      .simple-note {
+        display: flex;
+        align-items: flex-start;
+        gap: 8px;
+        padding: 12px 14px;
+        color: var(--text-muted);
+        background: var(--surface-muted);
+        border: 1px solid var(--line);
+        border-radius: 9px;
+        font-size: 12px;
+      }
+
+      .simple-note .icon { color: var(--blue); margin-top: 1px; }
+
+      .advanced-bar {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 12px;
+        margin-bottom: 12px;
+      }
+
+      .advanced-bar p { margin: 0; color: var(--text-muted); font-size: 12px; }
+
+      .tabs {
+        display: flex;
+        gap: 5px;
+        margin-bottom: 14px;
+        padding-bottom: 1px;
+        border-bottom: 1px solid var(--line);
+      }
+
+      .tab-button {
+        gap: 8px;
+        min-height: 43px;
+        padding: 0 15px;
+        color: var(--text-muted);
+        background: transparent;
+        border-bottom: 2px solid transparent;
+      }
+
+      .tab-button:hover { color: var(--text); }
+
+      .tab-button.active {
+        color: var(--blue);
+        border-color: var(--blue);
+        font-weight: 650;
+      }
+
+      .view-panel { display: none; }
+      .view-panel.active { display: block; }
+
+      .module-layout {
+        display: grid;
+        grid-template-columns: minmax(255px, 0.78fr) minmax(390px, 1.35fr) minmax(245px, 0.74fr);
+        gap: 15px;
+        align-items: start;
+      }
+
+      .card {
+        min-width: 0;
+        background: var(--surface);
+        border: 1px solid var(--line);
+        border-radius: var(--radius);
+        box-shadow: var(--shadow);
+      }
+
+      .card-header {
+        min-height: 61px;
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 12px;
+        padding: 15px 17px;
+        border-bottom: 1px solid var(--line);
+      }
+
+      .card-header h2,
+      .card-header h3 {
+        margin: 0;
+        font-size: 14px;
+      }
+
+      .card-header p {
+        margin: 3px 0 0;
+        color: var(--text-soft);
+        font-size: 12px;
+      }
+
+      .small-button {
+        min-height: 33px;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        gap: 6px;
+        padding: 0 10px;
+        color: var(--blue-dark);
+        background: var(--blue-soft);
+        border: 1px solid #cfe0fb;
+        border-radius: 7px;
+        font-size: 12px;
+        white-space: nowrap;
+      }
+
+      .small-button:hover { background: #dceaff; }
+
+      .ghost-button {
+        min-height: 33px;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        gap: 6px;
+        padding: 0 10px;
+        color: var(--text-muted);
+        background: var(--surface);
+        border: 1px solid var(--line-strong);
+        border-radius: 7px;
+        font-size: 12px;
+        white-space: nowrap;
+      }
+
+      .ghost-button:hover { color: var(--text); background: var(--surface-muted); }
+
+      .tree-body { padding: 12px 10px 15px; }
+
+      .tree-root {
+        padding: 8px 8px 9px;
+        color: var(--text);
+        background: #fbfcfe;
+        border: 1px solid var(--line);
+        border-radius: 9px;
+      }
+
+      .tree-root-title {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 8px;
+        margin-bottom: 7px;
+        padding: 2px 3px 8px;
+        border-bottom: 1px dashed var(--line);
+      }
+
+      .node-row {
+        width: 100%;
+        min-height: 45px;
+        justify-content: space-between;
+        gap: 9px;
+        padding: 6px 7px;
+        color: var(--text-muted);
+        background: transparent;
+        border: 1px solid transparent;
+        border-radius: 8px;
+        text-align: left;
+        transition: background 150ms ease, border-color 150ms ease, color 150ms ease;
+      }
+
+      .node-row:hover { color: var(--text); background: var(--surface-muted); }
+
+      .node-row.selected {
+        color: var(--blue-dark);
+        background: var(--surface-blue);
+        border-color: #cfe0fb;
+      }
+
+      .node-row.domain { color: var(--text); font-weight: 650; }
+      .node-row.domain:hover { background: #eef4fb; }
+
+      .node-main { min-width: 0; gap: 8px; }
+      .node-main .icon { color: var(--text-soft); }
+      .node-row.selected .node-main .icon { color: var(--blue); }
+
+      .node-copy { min-width: 0; }
+
+      .node-name {
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .node-code {
+        overflow: hidden;
+        color: var(--text-soft);
+        font-size: 11px;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .node-meta { gap: 6px; }
+
+      .tree-indent { padding-left: 22px; }
+
+      .check {
+        width: 17px;
+        height: 17px;
+        flex: 0 0 auto;
+        accent-color: var(--blue);
+        cursor: pointer;
+      }
+
+      .tag {
+        display: inline-flex;
+        align-items: center;
+        min-height: 22px;
+        padding: 0 7px;
+        color: var(--text-muted);
+        background: var(--surface-muted);
+        border: 1px solid var(--line);
+        border-radius: 5px;
+        font-size: 11px;
+        white-space: nowrap;
+      }
+
+      .tag.blue { color: var(--blue-dark); background: var(--blue-soft); border-color: #cfe0fb; }
+      .tag.green { color: var(--green); background: var(--green-soft); border-color: #c8ebdc; }
+      .tag.amber { color: var(--amber); background: var(--amber-soft); border-color: #f3dfac; }
+      .tag.red { color: var(--red); background: var(--red-soft); border-color: #f4cece; }
+
+      .tree-footer {
+        display: flex;
+        gap: 8px;
+        margin-top: 13px;
+        padding-top: 13px;
+        border-top: 1px solid var(--line);
+      }
+
+      .tree-footer button { flex: 1; }
+
+      .detail-body { padding: 18px; }
+
+      .module-heading {
+        justify-content: space-between;
+        gap: 14px;
+        margin-bottom: 17px;
+      }
+
+      .module-heading-main { min-width: 0; }
+
+      .module-heading h2 {
+        margin: 0;
+        font-size: 20px;
+        letter-spacing: -0.02em;
+      }
+
+      .module-heading p {
+        margin: 4px 0 0;
+        color: var(--text-muted);
+      }
+
+      .module-icon {
+        width: 43px;
+        height: 43px;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        flex: 0 0 auto;
+        color: var(--blue);
+        background: var(--blue-soft);
+        border: 1px solid #cfe0fb;
+        border-radius: 10px;
+      }
+
+      .section-title {
+        justify-content: space-between;
+        gap: 10px;
+        margin: 20px 0 9px;
+      }
+
+      .section-title h3 {
+        margin: 0;
+        font-size: 13px;
+      }
+
+      .section-title span {
+        color: var(--text-soft);
+        font-size: 11px;
+      }
+
+      .permission-grid {
+        display: grid;
+        grid-template-columns: repeat(3, minmax(0, 1fr));
+        gap: 8px;
+      }
+
+      .permission-card {
+        min-height: 67px;
+        display: flex;
+        align-items: center;
+        gap: 9px;
+        padding: 10px;
+        color: var(--text-muted);
+        background: var(--surface-muted);
+        border: 1px solid var(--line);
+        border-radius: 8px;
+        cursor: pointer;
+        transition: background 150ms ease, border-color 150ms ease, color 150ms ease;
+      }
+
+      .permission-card:hover { border-color: #b8cee9; color: var(--text); }
+
+      .permission-card.enabled {
+        color: var(--blue-dark);
+        background: var(--surface-blue);
+        border-color: #bed5f6;
+      }
+
+      .permission-card .icon-box {
+        width: 28px;
+        height: 28px;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        flex: 0 0 auto;
+        color: var(--text-soft);
+        background: var(--surface);
+        border-radius: 7px;
+      }
+
+      .permission-card.enabled .icon-box { color: var(--blue); }
+
+      .permission-copy { min-width: 0; }
+      .permission-name { display: block; font-weight: 650; }
+      .permission-desc { display: block; overflow: hidden; color: var(--text-soft); font-size: 11px; text-overflow: ellipsis; white-space: nowrap; }
+
+      .quick-actions {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 7px;
+      }
+
+      .quick-action {
+        min-height: 34px;
+        padding: 0 11px;
+        color: var(--text-muted);
+        background: var(--surface);
+        border: 1px solid var(--line-strong);
+        border-radius: 7px;
+        font-size: 12px;
+      }
+
+      .quick-action:hover { color: var(--blue-dark); border-color: #a9c7ec; background: var(--surface-blue); }
+
+      .dependency-box {
+        padding: 12px;
+        background: #fbfcfe;
+        border: 1px solid var(--line);
+        border-radius: 9px;
+      }
+
+      .dependency-row {
+        justify-content: space-between;
+        gap: 12px;
+        min-height: 33px;
+        padding: 4px 0;
+        color: var(--text-muted);
+      }
+
+      .dependency-row + .dependency-row { border-top: 1px dashed var(--line); }
+      .dependency-row strong { color: var(--text); font-weight: 600; }
+
+      .helper-text {
+        display: flex;
+        gap: 7px;
+        margin-top: 17px;
+        padding: 10px 11px;
+        color: var(--text-muted);
+        background: var(--surface-muted);
+        border-radius: 8px;
+        font-size: 12px;
+      }
+
+      .helper-text .icon { color: var(--blue); }
+
+      .summary-body { padding: 15px; }
+
+      .summary-stat {
+        display: grid;
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+        gap: 8px;
+        margin-bottom: 16px;
+      }
+
+      .mini-stat {
+        min-height: 74px;
+        flex-direction: column;
+        align-items: flex-start;
+        justify-content: center;
+        padding: 12px;
+        background: var(--surface-muted);
+        border: 1px solid var(--line);
+        border-radius: 8px;
+      }
+
+      .mini-stat strong { font-size: 21px; line-height: 1.05; }
+      .mini-stat span { margin-top: 4px; color: var(--text-soft); font-size: 11px; }
+
+      .summary-list { display: grid; gap: 8px; }
+
+      .summary-item {
+        justify-content: space-between;
+        gap: 10px;
+        padding: 9px 0;
+        border-bottom: 1px solid var(--line);
+      }
+
+      .summary-item:last-child { border-bottom: 0; }
+      .summary-item-label { color: var(--text-muted); }
+      .summary-item-value { color: var(--text); font-weight: 650; text-align: right; }
+
+      .summary-note {
+        margin-top: 14px;
+        padding: 10px;
+        color: #315a8c;
+        background: var(--surface-blue);
+        border-radius: 8px;
+        font-size: 12px;
+      }
+
+      .menu-layout,
+      .scope-layout {
+        display: grid;
+        grid-template-columns: minmax(280px, 0.9fr) minmax(440px, 1.5fr);
+        gap: 15px;
+        align-items: start;
+      }
+
+      .menu-list,
+      .scope-list { padding: 10px; }
+
+      .menu-item {
+        width: 100%;
+        min-height: 55px;
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 9px;
+        padding: 8px 10px;
+        color: var(--text-muted);
+        background: transparent;
+        border: 1px solid transparent;
+        border-radius: 8px;
+        text-align: left;
+      }
+
+      .menu-item:hover { color: var(--text); background: var(--surface-muted); }
+      .menu-item.selected { color: var(--blue-dark); background: var(--surface-blue); border-color: #cfe0fb; }
+
+      .menu-item-main { min-width: 0; display: flex; align-items: center; gap: 9px; }
+      .menu-item-main .icon { color: var(--text-soft); }
+      .menu-item.selected .menu-item-main .icon { color: var(--blue); }
+      .menu-copy { min-width: 0; }
+      .menu-name { overflow: hidden; font-weight: 650; text-overflow: ellipsis; white-space: nowrap; }
+      .menu-desc { overflow: hidden; color: var(--text-soft); font-size: 11px; text-overflow: ellipsis; white-space: nowrap; }
+
+      .menu-detail { padding: 20px; }
+
+      .page-detail-head {
+        display: flex;
+        align-items: flex-start;
+        justify-content: space-between;
+        gap: 14px;
+        margin-bottom: 20px;
+      }
+
+      .page-detail-head h2 { margin: 0; font-size: 20px; }
+      .page-detail-head p { margin: 5px 0 0; color: var(--text-muted); }
+
+      .bound-module-list { display: grid; gap: 9px; }
+
+      .bound-module {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 12px;
+        padding: 12px;
+        background: var(--surface-muted);
+        border: 1px solid var(--line);
+        border-radius: 8px;
+      }
+
+      .bound-module-main { min-width: 0; display: flex; align-items: center; gap: 10px; }
+      .bound-module-main .icon { color: var(--blue); }
+      .bound-copy { min-width: 0; }
+      .bound-name { display: block; font-weight: 650; }
+      .bound-code { display: block; color: var(--text-soft); font-size: 11px; }
+
+      .scope-item {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 14px;
+        min-height: 60px;
+        padding: 10px;
+        border-bottom: 1px solid var(--line);
+      }
+
+      .scope-item:last-child { border-bottom: 0; }
+      .scope-item-main { min-width: 0; display: flex; align-items: center; gap: 10px; }
+      .scope-item-main .icon { color: var(--blue); }
+      .scope-item-name { display: block; font-weight: 650; }
+      .scope-item-code { display: block; color: var(--text-soft); font-size: 11px; }
+
+      .scope-control { display: flex; align-items: center; gap: 8px; }
+      .scope-select {
+        min-height: 34px;
+        padding: 0 28px 0 9px;
+        color: var(--text);
+        background: var(--surface);
+        border: 1px solid var(--line-strong);
+        border-radius: 7px;
+      }
+
+      .modal-backdrop {
+        position: fixed;
+        inset: 0;
+        z-index: 20;
+        display: none;
+        align-items: center;
+        justify-content: center;
+        padding: 20px;
+        background: rgba(15, 28, 45, 0.42);
+      }
+
+      .modal-backdrop.open { display: flex; }
+
+      .modal {
+        width: min(580px, 100%);
+        max-height: min(680px, calc(100vh - 40px));
+        overflow: auto;
+        background: var(--surface);
+        border: 1px solid var(--line);
+        border-radius: 14px;
+        box-shadow: 0 24px 70px rgba(15, 28, 45, 0.22);
+      }
+
+      .modal-head {
+        display: flex;
+        align-items: flex-start;
+        justify-content: space-between;
+        gap: 12px;
+        padding: 20px 20px 14px;
+        border-bottom: 1px solid var(--line);
+      }
+
+      .modal-head h2 { margin: 0; font-size: 18px; }
+      .modal-head p { margin: 4px 0 0; color: var(--text-muted); font-size: 12px; }
+
+      .close-button {
+        width: 34px;
+        height: 34px;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        color: var(--text-muted);
+        background: transparent;
+        border-radius: 7px;
+      }
+
+      .close-button:hover { color: var(--text); background: var(--surface-muted); }
+
+      .modal-body { padding: 16px 20px; }
+      .modal-page-list { display: grid; gap: 8px; }
+
+      .modal-page {
+        display: flex;
+        align-items: center;
+        gap: 10px;
+        min-height: 55px;
+        padding: 10px;
+        background: var(--surface-muted);
+        border: 1px solid var(--line);
+        border-radius: 8px;
+      }
+
+      .modal-page-copy { min-width: 0; }
+      .modal-page-copy strong { display: block; }
+      .modal-page-copy span { color: var(--text-soft); font-size: 11px; }
+
+      .modal-actions {
+        justify-content: flex-end;
+        gap: 8px;
+        padding: 14px 20px 20px;
+      }
+
+      .toast {
+        position: fixed;
+        right: 24px;
+        bottom: 24px;
+        z-index: 30;
+        min-width: 245px;
+        max-width: min(420px, calc(100vw - 48px));
+        display: flex;
+        align-items: center;
+        gap: 9px;
+        padding: 12px 14px;
+        color: #fff;
+        background: #18304d;
+        border-radius: 9px;
+        box-shadow: 0 10px 30px rgba(15, 28, 45, 0.22);
+        opacity: 0;
+        pointer-events: none;
+        transform: translateY(10px);
+        transition: opacity 180ms ease, transform 180ms ease;
+      }
+
+      .toast.show { opacity: 1; transform: translateY(0); }
+
+      @media (max-width: 1220px) {
+        .module-layout { grid-template-columns: minmax(255px, 0.8fr) minmax(390px, 1.4fr); }
+        .summary-card { grid-column: 1 / -1; }
+        .summary-body { display: grid; grid-template-columns: 260px 1fr; gap: 20px; align-items: start; }
+        .summary-stat { margin-bottom: 0; }
+      }
+
+      @media (max-width: 860px) {
+        .topbar { padding: 0 16px; }
+        .brand-subtitle, .top-link span { display: none; }
+        .users-panel { width: 210px; flex-basis: 210px; }
+        .workspace { padding: 20px 16px 28px; }
+        .page-title { align-items: flex-start; flex-direction: column; }
+        .menu-layout, .scope-layout { grid-template-columns: 1fr; }
+        .simple-grid { grid-template-columns: 1fr; }
+        .authorization-toolbar { align-items: flex-start; flex-direction: column; }
+        .toolbar-controls { justify-content: flex-start; }
+      }
+
+      @media (max-width: 680px) {
+        .body-shell { display: block; }
+        .users-panel { width: 100%; padding: 13px 16px; border-right: 0; border-bottom: 1px solid var(--line); }
+        .panel-label { margin-left: 0; }
+        .search-box { margin-left: 0; margin-right: 0; margin-bottom: 10px; }
+        .user-list { grid-template-columns: repeat(3, minmax(0, 1fr)); }
+        .user-row { padding: 8px; }
+        .user-role { display: none; }
+        .module-layout { grid-template-columns: 1fr; }
+        .summary-body { display: block; }
+        .summary-stat { margin-bottom: 16px; }
+        .permission-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+        .preset-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+        .simple-intro { flex-direction: column; }
+        .top-actions .save-button { padding: 0 11px; }
+        .page-title h1 { font-size: 21px; }
+        .domain-grid { grid-template-columns: 1fr; }
+        .effective-summary { grid-template-columns: 1fr; }
+        .save-status { display: none; }
+      }
+
+      @media (prefers-reduced-motion: reduce) {
+        *, *::before, *::after { scroll-behavior: auto !important; transition-duration: 0.01ms !important; animation-duration: 0.01ms !important; }
+      }
+    </style>
+  </head>
+  <body>
+    <svg aria-hidden="true" style="position:absolute;width:0;height:0;overflow:hidden">
+      <symbol id="i-grid" viewBox="0 0 24 24"><rect x="3" y="3" width="7" height="7" rx="1"/><rect x="14" y="3" width="7" height="7" rx="1"/><rect x="3" y="14" width="7" height="7" rx="1"/><rect x="14" y="14" width="7" height="7" rx="1"/></symbol>
+      <symbol id="i-search" viewBox="0 0 24 24"><circle cx="11" cy="11" r="7"/><path d="m20 20-4-4"/></symbol>
+      <symbol id="i-save" viewBox="0 0 24 24"><path d="M5 4h12l2 2v14H5z"/><path d="M8 4v6h8V4M8 20v-6h8v6"/></symbol>
+      <symbol id="i-info" viewBox="0 0 24 24"><circle cx="12" cy="12" r="9"/><path d="M12 10v6M12 7h.01"/></symbol>
+      <symbol id="i-users" viewBox="0 0 24 24"><path d="M16 20v-1.5a4 4 0 0 0-4-4H7a4 4 0 0 0-4 4V20"/><circle cx="9.5" cy="7" r="3"/><path d="M16 4.5a3 3 0 0 1 0 5.8M21 20v-1.5a4 4 0 0 0-3-3.87"/></symbol>
+      <symbol id="i-chevron-down" viewBox="0 0 24 24"><path d="m6 9 6 6 6-6"/></symbol>
+      <symbol id="i-chevron-right" viewBox="0 0 24 24"><path d="m9 6 6 6-6 6"/></symbol>
+      <symbol id="i-layers" viewBox="0 0 24 24"><path d="m12 3 9 5-9 5-9-5z"/><path d="m3 12 9 5 9-5M3 16l9 5 9-5"/></symbol>
+      <symbol id="i-database" viewBox="0 0 24 24"><ellipse cx="12" cy="5" rx="8" ry="3"/><path d="M4 5v7c0 1.7 3.6 3 8 3s8-1.3 8-3V5M4 12v7c0 1.7 3.6 3 8 3s8-1.3 8-3v-7"/></symbol>
+      <symbol id="i-menu" viewBox="0 0 24 24"><path d="M4 6h16M4 12h16M4 18h16"/></symbol>
+      <symbol id="i-key" viewBox="0 0 24 24"><circle cx="8" cy="15" r="4"/><path d="m11 12 8-8M16 7l2 2M14 9l2 2"/></symbol>
+      <symbol id="i-shield" viewBox="0 0 24 24"><path d="M12 3 20 6v5c0 5-3.2 8.3-8 10-4.8-1.7-8-5-8-10V6z"/><path d="m9 12 2 2 4-4"/></symbol>
+      <symbol id="i-eye" viewBox="0 0 24 24"><path d="M2.5 12s3.5-6 9.5-6 9.5 6 9.5 6-3.5 6-9.5 6-9.5-6-9.5-6Z"/><circle cx="12" cy="12" r="2.5"/></symbol>
+      <symbol id="i-plus" viewBox="0 0 24 24"><path d="M12 5v14M5 12h14"/></symbol>
+      <symbol id="i-x" viewBox="0 0 24 24"><path d="m6 6 12 12M18 6 6 18"/></symbol>
+      <symbol id="i-arrow-right" viewBox="0 0 24 24"><path d="M5 12h14M13 6l6 6-6 6"/></symbol>
+      <symbol id="i-check" viewBox="0 0 24 24"><path d="m5 12 4 4L19 6"/></symbol>
+      <symbol id="i-settings" viewBox="0 0 24 24"><path d="M12 8a4 4 0 1 0 0 8 4 4 0 0 0 0-8Z"/><path d="m4.9 4.9 1.4 1.4M17.7 17.7l1.4 1.4M4 12H2M22 12h-2M4.9 19.1l1.4-1.4M17.7 6.3l1.4-1.4M12 4V2M12 22v-2"/></symbol>
+      <symbol id="i-edit" viewBox="0 0 24 24"><path d="m4 16 10.5-10.5a2.1 2.1 0 0 1 3 3L7 19H4z"/><path d="m13 7 4 4"/></symbol>
+      <symbol id="i-trash" viewBox="0 0 24 24"><path d="M4 7h16M10 11v6M14 11v6M6 7l1 13h10l1-13M9 7V4h6v3"/></symbol>
+      <symbol id="i-download" viewBox="0 0 24 24"><path d="M12 3v12M7 10l5 5 5-5M5 20h14"/></symbol>
+      <symbol id="i-lock" viewBox="0 0 24 24"><rect x="4" y="10" width="16" height="10" rx="2"/><path d="M8 10V7a4 4 0 0 1 8 0v3"/></symbol>
+      <symbol id="i-chart" viewBox="0 0 24 24"><path d="M4 19V5M4 19h16"/><path d="m7 15 3-4 3 2 5-7"/></symbol>
+    </svg>
+
+    <div class="app-shell">
+      <header class="topbar">
+        <div class="brand">
+          <span class="brand-mark"><svg class="icon"><use href="#i-grid" /></svg></span>
+          <span class="brand-name">FMS<span class="brand-subtitle">管理控制台</span></span>
+        </div>
+        <div class="top-actions">
+          <button class="top-link" type="button" id="helpButton"><svg class="icon"><use href="#i-info" /></svg><span>授权说明</span></button>
+          <span class="save-status" id="saveStatus">已保存</span>
+          <button class="ghost-button top-discard" type="button" id="discardButton">撤销修改</button>
+          <button class="save-button" type="button" id="saveButton"><svg class="icon"><use href="#i-save" /></svg><span id="saveLabel">保存权限</span></button>
+        </div>
+      </header>
+
+      <div class="body-shell">
+        <aside class="users-panel" aria-label="授权用户">
+          <p class="panel-label">授权对象</p>
+          <label class="search-box" aria-label="搜索用户">
+            <svg class="icon"><use href="#i-search" /></svg>
+            <input id="userSearch" type="search" placeholder="搜索姓名或部门" />
+          </label>
+          <div class="user-list" id="userList"></div>
+        </aside>
+
+        <main class="workspace">
+          <div class="workspace-head">
+            <div class="crumbs"><span>系统设置</span><svg class="icon" style="width:13px;height:13px"><use href="#i-chevron-right" /></svg><span>权限管理</span></div>
+            <div class="page-title">
+              <div>
+                <h1>用户权限分配</h1>
+                <p>先给入口，再给模块能力；模块权限会在所有菜单和接口中保持一致。</p>
+              </div>
+              <div class="user-summary" id="userSummary"></div>
+            </div>
+            <div class="notice">
+              <svg class="icon"><use href="#i-shield" /></svg>
+              <span><strong>当前授权原则：</strong>菜单控制能否进入页面，模块控制能否使用数据；选择“海运”只做批量操作，不会通过数据关联自动扩大权限。</span>
+            </div>
+
+            <section class="authorization-toolbar" aria-label="授权来源">
+              <div class="toolbar-copy">
+                <span class="toolbar-eyebrow">授权来源</span>
+                <h2 class="toolbar-title"><span id="roleSourceName">海运·经办</span><span class="tag blue" id="roleSourceTag">角色方案</span></h2>
+                <p id="roleSourceDesc">角色方案会一次生成菜单入口和模块动作，之后仍可按用户单独微调。</p>
+              </div>
+              <div class="toolbar-controls">
+                <label class="toolbar-field" for="roleSelect">套用角色方案
+                  <select class="role-select" id="roleSelect" aria-label="选择角色方案"></select>
+                </label>
+                <button class="small-button" type="button" id="applyRole"><svg class="icon"><use href="#i-check" /></svg>套用方案</button>
+                <button class="ghost-button" type="button" id="previewEffective"><svg class="icon"><use href="#i-eye" /></svg>预览最终权限</button>
+              </div>
+            </section>
+
+            <section class="simple-workspace" id="simpleWorkspace" aria-label="业务授权方案">
+              <div class="simple-intro">
+                <div><span class="tag blue">推荐授权方式</span><h2>按业务方案分配</h2><p id="simpleIntroDescription">管理员只需要选择业务域的工作方式，系统会自动准备菜单和模块权限。</p></div>
+                <button class="ghost-button" type="button" id="showAdvanced"><svg class="icon"><use href="#i-settings" /></svg>详细权限调整</button>
+              </div>
+              <section class="domain-overview" aria-label="业务域选择">
+                <div class="domain-overview-head"><div><h2>业务域</h2><p>先选择客户熟悉的业务域，再选择该业务域的工作方式。</p></div><span class="tag" id="domainModeHint">当前配置：海运</span></div>
+                <div class="domain-grid" id="domainCards"></div>
+              </section>
+              <div class="simple-grid">
+                <section class="business-card">
+                <div class="business-head"><div><h2 id="businessName">海运业务</h2><p id="businessDescription">包含主单、装箱信息和费用模块</p></div><span class="business-icon"><svg class="icon"><use href="#i-layers" /></svg></span></div>
+                  <div class="business-modules" id="businessModules"></div>
+                  <div class="preset-title"><h3>选择授权方案</h3><span>点击后可查看授权预览</span></div>
+                  <div class="preset-grid" id="presetGrid"></div>
+                </section>
+                <section class="simple-preview">
+                  <div class="simple-preview-head"><div><h2>授权预览</h2><p id="simplePreviewSubtitle">选择方案后，这里会显示实际授权内容</p></div><span class="tag amber">确认后一次保存</span></div>
+                  <div class="preview-list" id="simplePreview"></div>
+                  <div class="preview-actions"><button class="ghost-button" type="button" id="previewEffectiveInline"><svg class="icon"><use href="#i-eye" /></svg>查看最终生效权限</button></div>
+                </section>
+              </div>
+              <div class="simple-note"><svg class="icon"><use href="#i-info" /></svg><span>“只读 / 经办 / 主管”只是管理员的快捷入口。保存后仍按具体模块、动作、字段和数据范围校验，不会因为数据关联自动扩大权限。</span></div>
+            </section>
+
+            <div id="advancedWorkspace" hidden>
+              <div class="advanced-bar"><p>详细权限调整：适合需要单独调整主单、装箱或费用权限的管理员。</p><button class="ghost-button" type="button" id="showSimple"><svg class="icon"><use href="#i-arrow-right" /></svg>返回业务授权</button></div>
+              <nav class="tabs" aria-label="权限类型">
+                <button class="tab-button" type="button" data-view="menu"><svg class="icon"><use href="#i-menu" /></svg>菜单入口</button>
+                <button class="tab-button active" type="button" data-view="modules"><svg class="icon"><use href="#i-database" /></svg>模块能力</button>
+                <button class="tab-button" type="button" data-view="scope"><svg class="icon"><use href="#i-key" /></svg>字段与数据范围</button>
+              </nav>
+
+              <section class="view-panel active" id="panel-modules" aria-label="模块能力">
+                <div class="module-layout">
+                  <section class="card tree-card">
+                    <div class="card-header">
+                      <div><h2>业务模块</h2><p>父节点仅做分组和批量选择</p></div>
+                      <button class="small-button" type="button" id="openPageGrant"><svg class="icon"><use href="#i-arrow-right" /></svg>按页面授权</button>
+                    </div>
+                    <div class="tree-body" id="moduleTree"></div>
+                  </section>
+
+                  <section class="card detail-card">
+                    <div class="detail-body" id="moduleDetail"></div>
+                  </section>
+
+                  <aside class="card summary-card">
+                    <div class="card-header"><div><h2>授权概览</h2><p>当前用户的即时状态</p></div><svg class="icon" style="color:var(--blue)"><use href="#i-chart" /></svg></div>
+                    <div class="summary-body" id="summaryBody"></div>
+                  </aside>
+                </div>
+              </section>
+
+              <section class="view-panel" id="panel-menu" aria-label="菜单入口">
+                <div class="menu-layout">
+                  <section class="card">
+                    <div class="card-header"><div><h2>菜单入口</h2><p>只决定是否能进入页面</p></div></div>
+                    <div class="menu-list" id="menuList"></div>
+                  </section>
+                  <section class="card">
+                    <div class="menu-detail" id="menuDetail"></div>
+                  </section>
+                </div>
+              </section>
+
+              <section class="view-panel" id="panel-scope" aria-label="字段与数据范围">
+                <div class="scope-layout">
+                  <section class="card">
+                    <div class="card-header"><div><h2>选择模块</h2><p>字段权限和数据范围按模块分别配置</p></div></div>
+                    <div class="scope-list" id="scopeModuleList"></div>
+                  </section>
+                  <section class="card">
+                    <div class="menu-detail" id="scopeDetail"></div>
+                  </section>
+                </div>
+              </section>
+            </div>
+          </div>
+        </main>
+      </div>
+    </div>
+
+    <div class="modal-backdrop" id="pageGrantModal" role="presentation">
+      <div class="modal" role="dialog" aria-modal="true" aria-labelledby="modalTitle">
+        <div class="modal-head">
+          <div><h2 id="modalTitle">按页面补齐模块权限</h2><p>菜单绑定了哪些模块，管理员可以在这里一次性确认授权。</p></div>
+          <button class="close-button" type="button" id="closeModal" aria-label="关闭"><svg class="icon"><use href="#i-x" /></svg></button>
+        </div>
+        <div class="modal-body"><div class="modal-page-list" id="modalPageList"></div></div>
+        <div class="modal-actions"><button class="ghost-button" type="button" id="cancelModal">取消</button><button class="primary-button" type="button" id="confirmPageGrant"><svg class="icon"><use href="#i-check" /></svg>确认并授权</button></div>
+      </div>
+    </div>
+
+    <div class="modal-backdrop" id="effectiveModal" role="presentation">
+      <div class="modal effective-modal" role="dialog" aria-modal="true" aria-labelledby="effectiveModalTitle">
+        <div class="modal-head">
+          <div><h2 id="effectiveModalTitle">最终生效权限</h2><p id="effectiveModalSubtitle">按当前用户、业务域和角色方案汇总展示。</p></div>
+          <button class="close-button" type="button" id="closeEffective" aria-label="关闭"><svg class="icon"><use href="#i-x" /></svg></button>
+        </div>
+        <div class="modal-body" id="effectiveBody"></div>
+        <div class="modal-actions"><button class="ghost-button" type="button" id="cancelEffective">返回继续调整</button></div>
+      </div>
+    </div>
+
+    <div class="toast" id="toast" role="status" aria-live="polite"><svg class="icon"><use href="#i-check" /></svg><span id="toastText"></span></div>
+
+    <script>
+      const actionDefinitions = [
+        { key: 'view', label: '查看', desc: '进入模块并查询', icon: 'eye' },
+        { key: 'create', label: '新增', desc: '创建业务记录', icon: 'plus' },
+        { key: 'update', label: '编辑', desc: '修改已有记录', icon: 'edit' },
+        { key: 'delete', label: '删除', desc: '删除业务记录', icon: 'trash' },
+        { key: 'export', label: '导出', desc: '导出可见数据', icon: 'download' },
+        { key: 'audit', label: '审核', desc: '执行审核动作', icon: 'shield' },
+      ];
+
+      const moduleDefinitions = {
+        order: {
+          name: '海运主单', code: 'sea_order', type: '业务主表', relation: '核心单据',
+          description: '海运业务的主记录，承载客户、航次和单据状态。',
+          fields: ['单号', '客户', '船名航次', '业务状态', '业务员'],
+          related: ['装箱信息', '费用'],
+        },
+        container: {
+          name: '装箱信息', code: 'sea_container', type: '明细模块', relation: '引用海运主单',
+          description: '记录主单下的箱号、尺寸和装载状态。',
+          fields: ['箱号', '箱型', '封号', '装载状态'],
+          related: ['海运主单'],
+        },
+        fee: {
+          name: '费用', code: 'sea_fee', type: '业务模块', relation: '引用海运主单',
+          description: '记录海运业务的应收、应付和结算状态。',
+          fields: ['费用类型', '金额', '币种', '结算状态'],
+          related: ['海运主单'],
+        },
+      };
+
+      const menuDefinitions = {
+        seaDesk: { name: '海运工作台', type: '工作台', desc: '主单与配套明细的一体化处理页面', modules: ['order', 'container', 'fee'] },
+        seaList: { name: '海运单列表', type: '列表页', desc: '查询和维护海运主单', modules: ['order'] },
+        feeCenter: { name: '费用中心', type: '业务页', desc: '查看费用和结算进度', modules: ['fee'] },
+      };
+
+      const userDefinitions = {
+        zhang: { name: '张三', dept: '海运业务部 · 业务员', initials: '张', tone: '', menu: { seaDesk: true, seaList: true, feeCenter: false } },
+        li: { name: '李四', dept: '财务部 · 主管', initials: '李', tone: 'green', menu: { seaDesk: true, seaList: true, feeCenter: true } },
+        wang: { name: '王五', dept: '运营部 · 只读用户', initials: '王', tone: 'orange', menu: { seaDesk: true, seaList: false, feeCenter: false } },
+      };
+
+      const basePermissions = () => ({ view: false, create: false, update: false, delete: false, export: false, audit: false });
+
+      const makePermissions = (values = {}) => ({ ...basePermissions(), ...values });
+
+      const userStates = {
+        zhang: {
+          menu: { seaDesk: true, seaList: true, feeCenter: false },
+          modules: {
+            order: makePermissions({ view: true, create: true, update: true, export: true }),
+            container: makePermissions({ view: true, update: true }),
+            fee: makePermissions(),
+          },
+          scopes: { order: 'dept', container: 'all', fee: 'none' },
+          fields: { order: ['单号', '客户', '船名航次', '业务状态'], container: ['箱号', '箱型', '封号'], fee: [] },
+        },
+        li: {
+          menu: { seaDesk: true, seaList: true, feeCenter: true },
+          modules: {
+            order: makePermissions({ view: true, create: true, update: true, delete: true, export: true, audit: true }),
+            container: makePermissions({ view: true, create: true, update: true, delete: true, export: true }),
+            fee: makePermissions({ view: true, create: true, update: true, delete: true, export: true, audit: true }),
+          },
+          scopes: { order: 'all', container: 'all', fee: 'dept' },
+          fields: { order: ['单号', '客户', '船名航次', '业务状态', '业务员'], container: ['箱号', '箱型', '封号', '装载状态'], fee: ['费用类型', '金额', '币种', '结算状态'] },
+        },
+        wang: {
+          menu: { seaDesk: true, seaList: false, feeCenter: false },
+          modules: {
+            order: makePermissions({ view: true, export: true }),
+            container: makePermissions({ view: true }),
+            fee: makePermissions(),
+          },
+          scopes: { order: 'self', container: 'self', fee: 'none' },
+          fields: { order: ['单号', '客户', '业务状态'], container: ['箱号', '装载状态'], fee: [] },
+        },
+      };
+
+      const state = {
+        userId: 'zhang',
+        activeDomain: 'sea',
+        activeView: 'modules',
+        selectedModule: 'order',
+        selectedMenu: 'seaDesk',
+        selectedScopeModule: 'order',
+        modalPages: { seaDesk: false, seaList: false, feeCenter: false },
+        simplePreset: 'custom',
+        selectedRoleId: 'seaOperator',
+      };
+
+      const simplePresets = {
+        none: { label: '未授权', desc: '不开放海运业务', menu: [], modules: {} },
+        readonly: {
+          label: '只读', desc: '查看和导出业务数据', menu: ['seaDesk', 'seaList'],
+          modules: {
+            order: makePermissions({ view: true, export: true }),
+            container: makePermissions({ view: true }),
+            fee: makePermissions({ view: true }),
+          },
+        },
+        operate: {
+          label: '经办', desc: '处理主单和装箱业务', menu: ['seaDesk', 'seaList'],
+          modules: {
+            order: makePermissions({ view: true, create: true, update: true, export: true }),
+            container: makePermissions({ view: true, update: true }),
+            fee: makePermissions(),
+          },
+        },
+        manager: {
+          label: '主管', desc: '完整业务和审核权限', menu: ['seaDesk', 'seaList', 'feeCenter'],
+          modules: {
+            order: makePermissions({ view: true, create: true, update: true, delete: true, export: true, audit: true }),
+            container: makePermissions({ view: true, create: true, update: true, delete: true, export: true }),
+            fee: makePermissions({ view: true, create: true, update: true, delete: true, export: true, audit: true }),
+          },
+        },
+      };
+
+      /*
+       * 业务域是用户理解权限的第一层。海运进入高级配置，其余业务域用同一套
+       * “角色方案 -> 菜单入口 + 模块动作”的交互，方便后续按实际业务继续扩展。
+       */
+      const domainDefinitions = {
+        sea: {
+          name: '海运',
+          description: '主单、装箱信息和费用',
+          modules: moduleDefinitions,
+          menus: menuDefinitions,
+          advanced: true,
+        },
+        air: {
+          name: '空运',
+          description: '空运主单、运单和费用',
+          advanced: false,
+          modules: {
+            airOrder: { name: '空运主单', code: 'air_order', type: '业务主表', fields: ['主单号', '客户', '航班'], related: ['运单', '费用'] },
+            airShipment: { name: '空运运单', code: 'air_shipment', type: '明细模块', fields: ['运单号', '件数', '重量'], related: ['空运主单'] },
+            airFee: { name: '空运费用', code: 'air_fee', type: '业务模块', fields: ['费用类型', '金额', '币种'], related: ['空运主单'] },
+          },
+          menus: {
+            airDesk: { name: '空运工作台', type: '工作台', desc: '主单、运单和费用的一体化处理页面', modules: ['airOrder', 'airShipment', 'airFee'] },
+            airList: { name: '空运单列表', type: '列表页', desc: '查询和维护空运主单', modules: ['airOrder'] },
+          },
+        },
+        finance: {
+          name: '财务',
+          description: '应收、应付和结算报表',
+          advanced: false,
+          modules: {
+            receivable: { name: '应收管理', code: 'finance_receivable', type: '财务模块', fields: ['客户', '应收金额', '回款状态'], related: ['结算报表'] },
+            payable: { name: '应付管理', code: 'finance_payable', type: '财务模块', fields: ['供应商', '应付金额', '付款状态'], related: ['结算报表'] },
+            settlement: { name: '结算报表', code: 'finance_settlement', type: '报表模块', fields: ['业务域', '结算金额', '结算周期'], related: ['应收管理', '应付管理'] },
+          },
+          menus: {
+            financeDesk: { name: '财务工作台', type: '工作台', desc: '应收、应付和结算数据总览', modules: ['receivable', 'payable', 'settlement'] },
+            financeReport: { name: '结算报表', type: '报表页', desc: '按业务域查看结算报表', modules: ['settlement'] },
+          },
+        },
+      };
+
+      const domainPresets = {
+        sea: simplePresets,
+        air: {
+          none: { label: '未授权', desc: '不开放空运业务', menu: [], modules: {} },
+          readonly: {
+            label: '只读', desc: '查询空运业务数据', menu: ['airDesk', 'airList'],
+            modules: { airOrder: makePermissions({ view: true, export: true }), airShipment: makePermissions({ view: true }), airFee: makePermissions({ view: true }) },
+          },
+          operate: {
+            label: '经办', desc: '处理空运主单和运单', menu: ['airDesk', 'airList'],
+            modules: { airOrder: makePermissions({ view: true, create: true, update: true, export: true }), airShipment: makePermissions({ view: true, update: true }), airFee: makePermissions() },
+          },
+          manager: {
+            label: '主管', desc: '完整空运和费用权限', menu: ['airDesk', 'airList'],
+            modules: { airOrder: makePermissions({ view: true, create: true, update: true, delete: true, export: true, audit: true }), airShipment: makePermissions({ view: true, create: true, update: true, delete: true, export: true }), airFee: makePermissions({ view: true, create: true, update: true, delete: true, export: true, audit: true }) },
+          },
+        },
+        finance: {
+          none: { label: '未授权', desc: '不开放财务业务', menu: [], modules: {} },
+          readonly: {
+            label: '只读', desc: '查看财务数据和报表', menu: ['financeDesk', 'financeReport'],
+            modules: { receivable: makePermissions({ view: true, export: true }), payable: makePermissions({ view: true, export: true }), settlement: makePermissions({ view: true, export: true }) },
+          },
+          operate: {
+            label: '经办', desc: '处理应收应付数据', menu: ['financeDesk', 'financeReport'],
+            modules: { receivable: makePermissions({ view: true, create: true, update: true, export: true }), payable: makePermissions({ view: true, create: true, update: true, export: true }), settlement: makePermissions({ view: true, export: true }) },
+          },
+          manager: {
+            label: '主管', desc: '完整财务和审核权限', menu: ['financeDesk', 'financeReport'],
+            modules: { receivable: makePermissions({ view: true, create: true, update: true, delete: true, export: true, audit: true }), payable: makePermissions({ view: true, create: true, update: true, delete: true, export: true, audit: true }), settlement: makePermissions({ view: true, export: true, audit: true }) },
+          },
+        },
+      };
+
+      function buildDomainState(domainId, presetKey) {
+        const definition = domainDefinitions[domainId];
+        const preset = domainPresets[domainId][presetKey] || domainPresets[domainId].none;
+        return {
+          menu: Object.fromEntries(Object.keys(definition.menus).map((id) => [id, preset.menu.includes(id)])),
+          modules: Object.fromEntries(Object.keys(definition.modules).map((id) => [id, makePermissions(preset.modules[id] || {})])),
+        };
+      }
+
+      const domainStates = {
+        zhang: { air: buildDomainState('air', 'none'), finance: buildDomainState('finance', 'none') },
+        li: { air: buildDomainState('air', 'readonly'), finance: buildDomainState('finance', 'manager') },
+        wang: { air: buildDomainState('air', 'readonly'), finance: buildDomainState('finance', 'none') },
+      };
+
+      const roleDefinitions = {
+        seaOperator: { label: '海运·经办', domain: 'sea', preset: 'operate', desc: '主单新增编辑，装箱查看编辑，费用不可见。' },
+        seaManager: { label: '海运·主管', domain: 'sea', preset: 'manager', desc: '海运全模块操作、导出和审核。' },
+        seaViewer: { label: '海运·只读', domain: 'sea', preset: 'readonly', desc: '只查询海运主单、装箱和费用。' },
+        airOperator: { label: '空运·经办', domain: 'air', preset: 'operate', desc: '处理空运主单和运单，费用保持不可见。' },
+        financeViewer: { label: '财务·只读', domain: 'finance', preset: 'readonly', desc: '查看财务数据和结算报表。' },
+        custom: { label: '自定义权限', domain: 'custom', preset: 'custom', desc: '当前用户存在单独调整，按明细配置生效。' },
+      };
+
+      const roleAssignments = { zhang: 'seaOperator', li: 'seaManager', wang: 'seaViewer' };
+
+      const savedWorkspaces = Object.fromEntries(Object.keys(userDefinitions).map((id) => [id, {
+        sea: JSON.parse(JSON.stringify(userStates[id])),
+        domains: JSON.parse(JSON.stringify(domainStates[id])),
+        role: roleAssignments[id],
+      }]));
+
+      const $ = (selector) => document.querySelector(selector);
+      const all = (selector) => Array.from(document.querySelectorAll(selector));
+      const currentUser = () => userDefinitions[state.userId];
+      const currentData = () => userStates[state.userId];
+      const icon = (name, className = 'icon') => `<svg class="${className}"><use href="#i-${name}"></use></svg>`;
+
+      function clonePermissions(value) { return JSON.parse(JSON.stringify(value)); }
+
+      function showToast(message) {
+        $('#toastText').textContent = message;
+        $('#toast').classList.add('show');
+        window.clearTimeout(showToast.timer);
+        showToast.timer = window.setTimeout(() => $('#toast').classList.remove('show'), 2600);
+      }
+
+      function permissionsEqual(left, right) {
+        return Object.keys(basePermissions()).every((key) => Boolean(left?.[key]) === Boolean(right?.[key]));
+      }
+
+      function activeDomainDefinition() { return domainDefinitions[state.activeDomain]; }
+      function activeDomainData() {
+        return state.activeDomain === 'sea' ? currentData() : domainStates[state.userId][state.activeDomain];
+      }
+      function activeDomainPresets() { return domainPresets[state.activeDomain]; }
+      function activeModules() { return activeDomainDefinition().modules; }
+      function activeMenus() { return activeDomainDefinition().menus; }
+
+      function workspaceSnapshot(userId = state.userId) {
+        return JSON.stringify({ sea: userStates[userId], domains: domainStates[userId], role: roleAssignments[userId] });
+      }
+
+      function currentDiffs() {
+        const saved = savedWorkspaces[state.userId];
+        if (!saved) return [];
+        const diffs = [];
+        if (saved.role !== roleAssignments[state.userId]) diffs.push(`角色方案：${roleDefinitions[saved.role]?.label || '自定义'} → ${roleDefinitions[roleAssignments[state.userId]]?.label || '自定义'}`);
+
+        Object.entries(domainDefinitions).forEach(([domainId, definition]) => {
+          const before = domainId === 'sea' ? saved.sea : saved.domains[domainId];
+          const after = domainId === 'sea' ? userStates[state.userId] : domainStates[state.userId][domainId];
+          Object.keys(definition.menus).forEach((menuId) => {
+            if (Boolean(before?.menu?.[menuId]) !== Boolean(after?.menu?.[menuId])) diffs.push(`${definition.name}菜单：${definition.menus[menuId].name} ${after.menu[menuId] ? '已开放' : '已关闭'}`);
+          });
+          Object.entries(definition.modules).forEach(([moduleId, module]) => {
+            Object.keys(basePermissions()).forEach((action) => {
+              if (Boolean(before?.modules?.[moduleId]?.[action]) !== Boolean(after?.modules?.[moduleId]?.[action])) diffs.push(`${definition.name} / ${module.name}：${actionDefinitions.find((item) => item.key === action)?.label || action} ${after.modules[moduleId][action] ? '已授予' : '已取消'}`);
+            });
+          });
+        });
+        Object.keys(moduleDefinitions).forEach((moduleId) => {
+          const beforeFields = (saved.sea.fields?.[moduleId] || []).join('|');
+          const afterFields = (userStates[state.userId].fields?.[moduleId] || []).join('|');
+          if (beforeFields !== afterFields) diffs.push(`海运 / ${moduleDefinitions[moduleId].name}：字段可见性已调整`);
+          if (saved.sea.scopes?.[moduleId] !== userStates[state.userId].scopes?.[moduleId]) diffs.push(`海运 / ${moduleDefinitions[moduleId].name}：数据范围已调整`);
+        });
+        return diffs;
+      }
+
+      function hasUnsavedChanges() { return workspaceSnapshot() !== JSON.stringify(savedWorkspaces[state.userId]); }
+
+      function detectSimplePreset() {
+        const data = activeDomainData();
+        const presets = activeDomainPresets();
+        const menus = activeMenus();
+        const modules = activeModules();
+        for (const [presetKey, preset] of Object.entries(presets)) {
+          const menusMatch = Object.keys(menus).every((menuId) => Boolean(data.menu[menuId]) === preset.menu.includes(menuId));
+          const modulesMatch = Object.keys(modules).every((moduleId) => permissionsEqual(data.modules[moduleId], preset.modules[moduleId] || basePermissions()));
+          if (menusMatch && modulesMatch) return presetKey;
+        }
+        return 'custom';
+      }
+
+      function renderDomainCards() {
+        const html = Object.entries(domainDefinitions).map(([domainId, definition]) => {
+          const data = domainId === 'sea' ? currentData() : domainStates[state.userId][domainId];
+          const presetKey = (() => {
+            const previousDomain = state.activeDomain;
+            state.activeDomain = domainId;
+            const value = detectSimplePreset();
+            state.activeDomain = previousDomain;
+            return value;
+          })();
+          const granted = Object.values(data.modules).filter((item) => item.view).length;
+          const roleText = presetKey === 'custom' ? '自定义' : (domainPresets[domainId][presetKey]?.label || '未授权');
+          return `<button class="domain-card ${domainId === state.activeDomain ? 'active' : ''}" type="button" data-select-domain="${domainId}">
+            <span class="domain-card-icon">${icon(domainId === 'finance' ? 'chart' : 'layers')}</span>
+            <span class="domain-card-copy"><span class="domain-card-name">${definition.name}</span><span class="domain-card-desc">${definition.description} · ${granted}/${Object.keys(definition.modules).length} 个模块</span></span>
+            <span class="role-badge">${roleText}</span>
+          </button>`;
+        }).join('');
+        $('#domainCards').innerHTML = html;
+        $('#domainModeHint').textContent = `当前配置：${activeDomainDefinition().name}`;
+      }
+
+      function renderRoleToolbar() {
+        const currentRole = roleDefinitions[roleAssignments[state.userId]] || roleDefinitions.custom;
+        const roleEntries = Object.entries(roleDefinitions).filter(([id, role]) => id === 'custom' || role.domain === state.activeDomain);
+        const roleIds = roleEntries.map(([id]) => id);
+        if (!roleIds.includes(state.selectedRoleId)) state.selectedRoleId = roleIds[0] || 'custom';
+        const options = roleEntries.map(([id, role]) => `<option value="${id}" ${id === state.selectedRoleId ? 'selected' : ''}>${role.label}</option>`).join('');
+        $('#roleSelect').innerHTML = options;
+        const selectedRole = roleDefinitions[state.selectedRoleId] || currentRole;
+        const detected = detectSimplePreset();
+        const detectedRole = roleEntries.find(([, role]) => role.preset === detected)?.[1];
+        const isCustom = detected === 'custom';
+        const isNone = detected === 'none';
+        $('#roleSourceName').textContent = isCustom ? `${activeDomainDefinition().name} · 自定义权限` : (isNone ? `${activeDomainDefinition().name} · 未授权` : (detectedRole?.label || selectedRole.label));
+        $('#roleSourceTag').textContent = isCustom ? '单独调整' : '角色方案';
+        $('#roleSourceDesc').textContent = isCustom ? '当前用户存在单独调整，保存后只影响当前用户。' : (isNone ? `当前用户没有${activeDomainDefinition().name}权限，可直接套用右侧角色方案。` : (detectedRole?.desc || selectedRole.desc));
+      }
+
+      function renderSimpleWorkspace() {
+        const data = activeDomainData();
+        const definition = activeDomainDefinition();
+        const modules = activeModules();
+        const menus = activeMenus();
+        const presets = activeDomainPresets();
+        const detected = detectSimplePreset();
+        state.simplePreset = detected;
+        $('#businessName').textContent = `${definition.name}业务`;
+        $('#businessDescription').textContent = `包含${definition.description}`;
+        $('#simpleIntroDescription').textContent = `管理员只需要选择“${definition.name}”的工作方式，系统会自动准备菜单和模块权限。`;
+        $('#businessModules').innerHTML = Object.values(modules).map((module) => `<span class="business-module"><svg class="icon"><use href="#i-database" /></svg>${module.name}</span>`).join('');
+        $('#presetGrid').innerHTML = Object.entries(presets).map(([key, preset]) => `
+          <button class="preset-button ${key === detected ? 'active' : ''}" type="button" data-simple-preset="${key}"><strong>${preset.label}</strong><span>${preset.desc}</span></button>
+        `).join('');
+
+        const previewRows = detected === 'custom'
+          ? [
+              `<div class="preview-row"><span class="preview-row-main">${icon('menu')}<span class="preview-row-copy"><span class="preview-row-name">当前配置</span><span class="preview-row-desc">已做过单独模块调整</span></span></span><span class="tag amber">自定义</span></div>`,
+              `<div class="preview-row"><span class="preview-row-main">${icon('menu')}<span class="preview-row-copy"><span class="preview-row-name">菜单入口</span><span class="preview-row-desc">${Object.entries(data.menu).filter(([, enabled]) => enabled).map(([id]) => menus[id].name).join('、') || '没有开放页面'}</span></span></span><span class="tag ${Object.values(data.menu).some(Boolean) ? 'green' : 'red'}">${Object.values(data.menu).some(Boolean) ? '已开放' : '未开放'}</span></div>`,
+              ...Object.entries(modules).map(([id, module]) => {
+                const permissions = data.modules[id];
+                const actions = actionDefinitions.filter((action) => permissions[action.key]).map((action) => action.label).join('、') || '未授权';
+                return `<div class="preview-row"><span class="preview-row-main">${icon('database')}<span class="preview-row-copy"><span class="preview-row-name">${module.name}</span><span class="preview-row-desc">${actions}</span></span></span><span class="tag ${permissions.view ? 'green' : 'red'}">${permissions.view ? '可访问' : '未授权'}</span></div>`;
+              }),
+            ]
+          : [
+              `<div class="preview-row"><span class="preview-row-main">${icon('menu')}<span class="preview-row-copy"><span class="preview-row-name">菜单入口</span><span class="preview-row-desc">${(presets[detected]?.menu || []).map((id) => menus[id].name).join('、') || `不开放${definition.name}页面`}</span></span></span><span class="tag ${detected === 'none' ? 'red' : 'green'}">${detected === 'none' ? '未开放' : '已开放'}</span></div>`,
+              ...Object.entries(modules).map(([id, module]) => {
+                const permissions = presets[detected].modules[id] || basePermissions();
+                const actions = actionDefinitions.filter((action) => permissions[action.key]).map((action) => action.label).join('、') || '未授权';
+                return `<div class="preview-row"><span class="preview-row-main">${icon('database')}<span class="preview-row-copy"><span class="preview-row-name">${module.name}</span><span class="preview-row-desc">${actions}</span></span></span><span class="tag ${permissions.view ? 'green' : 'red'}">${permissions.view ? '可访问' : '未授权'}</span></div>`;
+              }),
+            ];
+
+        $('#simplePreviewSubtitle').textContent = detected === 'custom' ? '当前配置包含单独调整，可进入详细权限调整' : '确认后会同时准备菜单入口和模块能力';
+        $('#simplePreview').innerHTML = previewRows.join('');
+        $('#showAdvanced').hidden = !definition.advanced;
+        $('#showAdvanced').title = definition.advanced ? '打开海运的菜单、模块、字段和数据范围调整' : '该业务域先使用角色方案分配';
+      }
+
+      function applySimplePreset(presetKey) {
+        const presets = activeDomainPresets();
+        const preset = presets[presetKey];
+        const data = activeDomainData();
+        Object.keys(activeMenus()).forEach((menuId) => { data.menu[menuId] = preset.menu.includes(menuId); });
+        Object.keys(activeModules()).forEach((moduleId) => { data.modules[moduleId] = makePermissions(preset.modules[moduleId] || {}); });
+        const matchingRole = Object.entries(roleDefinitions).find(([, role]) => role.domain === state.activeDomain && role.preset === presetKey);
+        roleAssignments[state.userId] = matchingRole ? matchingRole[0] : 'custom';
+        state.selectedRoleId = matchingRole ? matchingRole[0] : 'custom';
+        state.simplePreset = presetKey;
+        renderAll();
+        showToast(`已选择“${activeDomainDefinition().name}·${preset.label}”，确认保存即可生效`);
+      }
+
+      function renderUsers() {
+        const keyword = ($('#userSearch').value || '').trim().toLowerCase();
+        const html = Object.entries(userDefinitions)
+          .filter(([, user]) => !keyword || `${user.name}${user.dept}`.toLowerCase().includes(keyword))
+          .map(([id, user]) => `
+            <button class="user-row ${id === state.userId ? 'active' : ''}" type="button" data-user="${id}">
+              <span class="avatar ${user.tone}">${user.initials}</span>
+              <span class="user-copy"><span class="user-name">${user.name}</span><span class="user-role">${user.dept}</span></span>
+            </button>
+          `).join('');
+        $('#userList').innerHTML = html || '<div style="padding:14px;color:var(--text-soft);font-size:12px">没有匹配用户</div>';
+        const user = currentUser();
+        $('#userSummary').innerHTML = `<span class="avatar ${user.tone}">${user.initials}</span><span class="summary-copy"><strong>${user.name}</strong><span>${user.dept}</span></span>`;
+      }
+
+      function moduleAccess(id) { return currentData().modules[id].view; }
+
+      function renderModuleTree() {
+        const data = currentData();
+        const allGranted = Object.keys(moduleDefinitions).every((id) => moduleAccess(id));
+        const someGranted = Object.keys(moduleDefinitions).some((id) => moduleAccess(id));
+        $('#moduleTree').innerHTML = `
+          <div class="tree-root">
+            <div class="tree-root-title">
+              <span class="node-main"><input class="check" type="checkbox" id="domainCheck" ${allGranted ? 'checked' : ''} ${!allGranted && someGranted ? 'data-indeterminate="true"' : ''} /><span>${icon('layers')}<strong style="margin-left:6px">海运</strong></span></span>
+              <span class="tag">业务域</span>
+            </div>
+            <div class="tree-indent">
+              ${Object.entries(moduleDefinitions).map(([id, module]) => `
+                <div class="node-row ${id === state.selectedModule ? 'selected' : ''}" data-select-module="${id}" role="button" tabindex="0">
+                  <span class="node-main">
+                    <input class="check module-check" type="checkbox" data-module-access="${id}" ${moduleAccess(id) ? 'checked' : ''} aria-label="${module.name}模块访问权限" />
+                    ${icon('database')}
+                    <span class="node-copy"><span class="node-name">${module.name}</span><span class="node-code">${module.code}</span></span>
+                  </span>
+                  <span class="node-meta"><span class="tag ${moduleAccess(id) ? 'green' : 'red'}">${moduleAccess(id) ? '已授权' : '未授权'}</span></span>
+                </div>
+              `).join('')}
+            </div>
+          </div>
+          <div class="tree-footer"><button class="ghost-button" type="button" id="clearDomain">清空海运权限</button><button class="small-button" type="button" id="grantDomain">全选模块</button></div>
+        `;
+        const domainCheck = $('#domainCheck');
+        if (domainCheck && !allGranted && someGranted) domainCheck.indeterminate = true;
+      }
+
+      function permissionCard(action, enabled) {
+        return `<label class="permission-card ${enabled ? 'enabled' : ''}"><input class="check action-check" type="checkbox" data-action-key="${action.key}" ${enabled ? 'checked' : ''} /><span class="icon-box">${icon(action.icon)}</span><span class="permission-copy"><span class="permission-name">${action.label}</span><span class="permission-desc">${action.desc}</span></span></label>`;
+      }
+
+      function renderModuleDetail() {
+        const module = moduleDefinitions[state.selectedModule];
+        const permissions = currentData().modules[state.selectedModule];
+        const access = permissions.view;
+        const dependencyText = module.related.join('、');
+        $('#moduleDetail').innerHTML = `
+          <div class="module-heading">
+            <div class="module-heading-main"><div class="inline" style="gap:8px;margin-bottom:5px"><span class="tag blue">${module.type}</span><span class="tag">${module.relation}</span></div><h2>${module.name}</h2><p>${module.description}</p></div>
+            <span class="module-icon">${icon('database')}</span>
+          </div>
+          <div class="section-title"><h3>模块访问</h3><span>${access ? '已允许进入和查询' : '未授予访问权限'}</span></div>
+          <label class="permission-card ${access ? 'enabled' : ''}" style="min-height:58px"><input class="check action-check" type="checkbox" data-action-key="view" ${access ? 'checked' : ''} /><span class="icon-box">${icon('eye')}</span><span class="permission-copy"><span class="permission-name">查看模块</span><span class="permission-desc">拥有后才能进入页面和查询数据</span></span></label>
+          <div class="section-title"><h3>标准操作</h3><span>按模块单独生效</span></div>
+          <div class="permission-grid">${actionDefinitions.filter((action) => action.key !== 'view').map((action) => permissionCard(action, permissions[action.key])).join('')}</div>
+          <div class="section-title"><h3>快速方案</h3><span>快捷操作仍会生成明确权限</span></div>
+          <div class="quick-actions"><button class="quick-action" type="button" data-preset="readonly">只读</button><button class="quick-action" type="button" data-preset="operate">日常操作</button><button class="quick-action" type="button" data-preset="full">全部权限</button><button class="quick-action" type="button" data-preset="clear">清空</button></div>
+          <div class="section-title"><h3>关联上下文</h3><span>仅用于理解，不自动授权</span></div>
+          <div class="dependency-box"><div class="dependency-row"><span>被页面使用</span><strong>${Object.values(menuDefinitions).filter((menu) => menu.modules.includes(state.selectedModule)).length} 个菜单页面</strong></div><div class="dependency-row"><span>数据关系</span><strong>${dependencyText}</strong></div><div class="dependency-row"><span>无权限时</span><strong>${access ? '按模块权限展示' : '隐藏模块面板'}</strong></div></div>
+          <div class="helper-text">${icon('info')}<span>数据关系只帮助管理员理解主单、明细和费用之间的业务联系，不会把主单权限自动传给其他模块。</span></div>
+        `;
+      }
+
+      function renderSummary() {
+        const data = currentData();
+        const moduleCount = Object.values(data.modules).filter((item) => item.view).length;
+        const actionCount = Object.values(data.modules).reduce((total, item) => total + Object.values(item).filter(Boolean).length, 0);
+        const menuCount = Object.values(data.menu).filter(Boolean).length;
+        $('#summaryBody').innerHTML = `
+          <div class="summary-stat"><div class="mini-stat"><strong>${moduleCount}/3</strong><span>模块可访问</span></div><div class="mini-stat"><strong>${menuCount}/3</strong><span>菜单入口</span></div></div>
+          <div class="summary-list"><div class="summary-item"><span class="summary-item-label">当前模块</span><span class="summary-item-value">${moduleDefinitions[state.selectedModule].name}</span></div><div class="summary-item"><span class="summary-item-label">已授予操作</span><span class="summary-item-value">${actionCount} 项</span></div><div class="summary-item"><span class="summary-item-label">数据范围</span><span class="summary-item-value">按模块设置</span></div></div>
+          <div class="summary-note">保存后，后端仍按模块、动作、字段和数据范围逐层校验。</div>
+        `;
+      }
+
+      function renderMenu() {
+        const data = currentData();
+        $('#menuList').innerHTML = Object.entries(menuDefinitions).map(([id, menu]) => `
+          <button class="menu-item ${id === state.selectedMenu ? 'selected' : ''}" type="button" data-select-menu="${id}">
+            <span class="menu-item-main">${icon('menu')}<span class="menu-copy"><span class="menu-name">${menu.name}</span><span class="menu-desc">${menu.desc}</span></span></span>
+            <span class="node-meta"><span class="tag ${data.menu[id] ? 'green' : 'red'}">${data.menu[id] ? '已授权' : '未授权'}</span></span>
+          </button>
+        `).join('');
+        const menu = menuDefinitions[state.selectedMenu];
+        $('#menuDetail').innerHTML = `
+          <div class="page-detail-head"><div><div class="inline" style="gap:8px;margin-bottom:5px"><span class="tag blue">${menu.type}</span><span class="tag">${data.menu[state.selectedMenu] ? '入口已开放' : '入口未开放'}</span></div><h2>${menu.name}</h2><p>${menu.desc}</p></div><button class="primary-button" type="button" id="syncSelectedPage"><svg class="icon"><use href="#i-check" /></svg>补齐页面模块权限</button></div>
+          <div class="section-title"><h3>页面使用的模块</h3><span>${menu.modules.length} 个模块</span></div>
+          <div class="bound-module-list">${menu.modules.map((id, index) => { const module = moduleDefinitions[id]; return `<div class="bound-module"><span class="bound-module-main">${icon('database')}<span class="bound-copy"><span class="bound-name">${module.name} ${index === 0 ? '<span class="tag amber" style="margin-left:5px">主模块</span>' : ''}</span><span class="bound-code">${module.code}</span></span></span><span class="tag ${moduleAccess(id) ? 'green' : 'red'}">${moduleAccess(id) ? '模块已授权' : '需补授权'}</span></div>`; }).join('')}</div>
+          <div class="helper-text">${icon('info')}<span>打开菜单只代表可以进入页面；主单、装箱、费用仍然分别检查模块权限。</span></div>
+        `;
+      }
+
+      function renderScope() {
+        const data = currentData();
+        $('#scopeModuleList').innerHTML = Object.entries(moduleDefinitions).map(([id, module]) => `
+          <button class="menu-item ${id === state.selectedScopeModule ? 'selected' : ''}" type="button" data-select-scope="${id}">
+            <span class="menu-item-main">${icon('database')}<span class="menu-copy"><span class="menu-name">${module.name}</span><span class="menu-desc">${module.code}</span></span></span>
+            <span class="tag ${moduleAccess(id) ? 'green' : 'red'}">${moduleAccess(id) ? '可访问' : '未授权'}</span>
+          </button>
+        `).join('');
+        const module = moduleDefinitions[state.selectedScopeModule];
+        const selectedFields = data.fields[state.selectedScopeModule];
+        const scope = data.scopes[state.selectedScopeModule];
+        const scopeOptions = [{ value: 'all', label: '全部数据' }, { value: 'dept', label: '本部门数据' }, { value: 'self', label: '本人数据' }, { value: 'none', label: '未设置' }];
+        $('#scopeDetail').innerHTML = `
+          <div class="page-detail-head"><div><div class="inline" style="gap:8px;margin-bottom:5px"><span class="tag blue">字段权限</span><span class="tag">${moduleAccess(state.selectedScopeModule) ? '模块可访问' : '模块未授权'}</span></div><h2>${module.name}</h2><p>字段可见性和数据行范围独立于菜单入口。</p></div></div>
+          <div class="section-title"><h3>字段可见性</h3><span>${selectedFields.length}/${module.fields.length} 个字段可见</span></div>
+          <div class="permission-grid">${module.fields.map((field) => `<label class="permission-card ${selectedFields.includes(field) ? 'enabled' : ''}" style="min-height:58px"><input class="check field-check" type="checkbox" data-field-name="${field}" ${selectedFields.includes(field) ? 'checked' : ''} /><span class="permission-copy"><span class="permission-name">${field}</span><span class="permission-desc">允许查看该字段</span></span></label>`).join('')}</div>
+          <div class="section-title"><h3>数据范围</h3><span>按模块保存</span></div>
+          <div class="dependency-box"><div class="dependency-row"><span>当前范围</span><select class="scope-select" id="scopeSelect">${scopeOptions.map((option) => `<option value="${option.value}" ${scope === option.value ? 'selected' : ''}>${option.label}</option>`).join('')}</select></div><div class="dependency-row"><span>执行位置</span><strong>后端 SQL 权限过滤</strong></div></div>
+          <div class="helper-text">${icon('lock')}<span>没有模块访问权限时，字段和数据范围配置不会让用户重新获得模块访问权限。</span></div>
+        `;
+      }
+
+      function renderSaveStatus() {
+        const dirty = hasUnsavedChanges();
+        const diffs = currentDiffs();
+        $('#saveStatus').textContent = dirty ? `${diffs.length} 项待保存` : '已保存';
+        $('#saveStatus').classList.toggle('pending', dirty);
+        $('#discardButton').classList.toggle('visible', dirty);
+        $('#saveLabel').textContent = dirty ? `保存${diffs.length}项修改` : '保存权限';
+      }
+
+      function renderEffectiveModal() {
+        const definition = activeDomainDefinition();
+        const data = activeDomainData();
+        const menus = activeMenus();
+        const modules = activeModules();
+        const visibleMenus = Object.entries(data.menu).filter(([, enabled]) => enabled);
+        const visibleModules = Object.entries(data.modules).filter(([, permissions]) => permissions.view);
+        const actionCount = visibleModules.reduce((total, [, permissions]) => total + Object.values(permissions).filter(Boolean).length, 0);
+        const diffs = currentDiffs();
+        $('#effectiveModalTitle').textContent = `${currentUser().name} · ${definition.name}最终生效权限`;
+        $('#effectiveModalSubtitle').textContent = '这是后端最终会收到的入口、模块和动作授权预览。';
+        $('#effectiveBody').innerHTML = `
+          <div class="effective-summary">
+            <div class="effective-stat"><strong>${visibleMenus.length}</strong><span>菜单入口</span></div>
+            <div class="effective-stat"><strong>${visibleModules.length}</strong><span>可访问模块</span></div>
+            <div class="effective-stat"><strong>${actionCount}</strong><span>动作权限</span></div>
+          </div>
+          <section class="effective-section"><h3>菜单入口</h3><div class="effective-list">${visibleMenus.length ? visibleMenus.map(([id]) => `<div class="effective-row"><span><strong>${menus[id].name}</strong><span>${menus[id].desc}</span></span><span class="tag green">可进入</span></div>`).join('') : '<div class="effective-empty">当前业务域没有开放菜单入口。</div>'}</div></section>
+          <section class="effective-section"><h3>模块能力</h3><div class="effective-list">${visibleModules.length ? visibleModules.map(([id, permissions]) => `<div class="effective-row"><span><strong>${modules[id].name}</strong><span>${actionDefinitions.filter((action) => permissions[action.key]).map((action) => action.label).join('、')}</span></span><span class="tag green">已授权</span></div>`).join('') : '<div class="effective-empty">当前业务域没有可访问模块。</div>'}</div></section>
+          ${state.activeDomain === 'sea' ? `<section class="effective-section"><h3>字段与数据范围</h3><div class="effective-list">${visibleModules.map(([id]) => `<div class="effective-row"><span><strong>${modules[id].name}</strong><span>${(data.fields[id] || []).length} 个字段 · ${({ all: '全部数据', dept: '本部门数据', self: '本人数据', none: '未设置' })[data.scopes[id]] || '未设置'}</span></span><span class="tag">后端过滤</span></div>`).join('') || '<div class="effective-empty">没有模块可配置字段和数据范围。</div>'}</div></section>` : ''}
+          <section class="effective-section"><h3>本次未保存变更</h3>${diffs.length ? `<div class="change-list">${diffs.slice(0, 8).map((item) => `<div class="change-item">${icon('edit')}<span>${item}</span></div>`).join('')}</div>${diffs.length > 8 ? `<div class="helper-text">还有 ${diffs.length - 8} 项变更未展开，请保存后生效。</div>` : ''}` : '<div class="effective-empty">没有未保存变更，当前展示的是已保存配置。</div>'}</section>
+        `;
+      }
+
+      function openEffectiveModal() {
+        renderEffectiveModal();
+        $('#effectiveModal').classList.add('open');
+      }
+
+      function closeEffectiveModal() { $('#effectiveModal').classList.remove('open'); }
+
+      function saveCurrentUser() {
+        savedWorkspaces[state.userId] = {
+          sea: clonePermissions(userStates[state.userId]),
+          domains: clonePermissions(domainStates[state.userId]),
+          role: roleAssignments[state.userId],
+        };
+        renderAll();
+        showToast(`已保存${currentUser().name}的权限配置`);
+      }
+
+      function discardCurrentUser() {
+        const saved = savedWorkspaces[state.userId];
+        if (!saved) return;
+        userStates[state.userId] = clonePermissions(saved.sea);
+        domainStates[state.userId] = clonePermissions(saved.domains);
+        roleAssignments[state.userId] = saved.role;
+        state.selectedRoleId = saved.role || 'custom';
+        renderAll();
+        showToast('已撤销本次未保存修改');
+      }
+
+      function renderAll() {
+        renderUsers();
+        renderRoleToolbar();
+        renderDomainCards();
+        renderSimpleWorkspace();
+        renderModuleTree();
+        renderModuleDetail();
+        renderSummary();
+        renderMenu();
+        renderScope();
+        all('.tab-button').forEach((button) => button.classList.toggle('active', button.dataset.view === state.activeView));
+        all('.view-panel').forEach((panel) => panel.classList.toggle('active', panel.id === `panel-${state.activeView}`));
+        renderSaveStatus();
+      }
+
+      function setModuleAccess(id, value) {
+        if (state.activeDomain === 'sea') roleAssignments[state.userId] = 'custom';
+        currentData().modules[id].view = value;
+        if (!value) {
+          ['create', 'update', 'delete', 'export', 'audit'].forEach((key) => { currentData().modules[id][key] = false; });
+        }
+      }
+
+      function setDomainAccess(value) {
+        if (state.activeDomain === 'sea') roleAssignments[state.userId] = 'custom';
+        Object.keys(moduleDefinitions).forEach((id) => setModuleAccess(id, value));
+      }
+
+      function applyPreset(preset) {
+        roleAssignments[state.userId] = 'custom';
+        const permissions = currentData().modules[state.selectedModule];
+        if (preset === 'readonly') Object.assign(permissions, makePermissions({ view: true, export: true }));
+        if (preset === 'operate') Object.assign(permissions, makePermissions({ view: true, create: true, update: true, export: true }));
+        if (preset === 'full') Object.assign(permissions, makePermissions({ view: true, create: true, update: true, delete: true, export: true, audit: true }));
+        if (preset === 'clear') Object.assign(permissions, makePermissions());
+        renderAll();
+        showToast(`已将${moduleDefinitions[state.selectedModule].name}设置为${preset === 'readonly' ? '只读' : preset === 'operate' ? '日常操作' : preset === 'full' ? '全部权限' : '无权限'}`);
+      }
+
+      function openPageModal() {
+        state.modalPages = { seaDesk: false, seaList: false, feeCenter: false };
+        $('#modalPageList').innerHTML = Object.entries(menuDefinitions).map(([id, menu]) => `
+          <label class="modal-page"><input class="check modal-page-check" type="checkbox" data-modal-page="${id}" /><span class="modal-page-copy"><strong>${menu.name}</strong><span>${menu.modules.map((moduleId) => moduleDefinitions[moduleId].name).join('、')}</span></span></label>
+        `).join('');
+        $('#pageGrantModal').classList.add('open');
+      }
+
+      function closePageModal() { $('#pageGrantModal').classList.remove('open'); }
+
+      document.addEventListener('click', (event) => {
+        const userButton = event.target.closest('[data-user]');
+        if (userButton) {
+          state.userId = userButton.dataset.user;
+          state.activeDomain = 'sea';
+          state.selectedRoleId = roleAssignments[state.userId] || 'custom';
+          renderAll();
+          showToast(`已切换到${currentUser().name}的权限配置`);
+          return;
+        }
+
+        const domainButton = event.target.closest('[data-select-domain]');
+        if (domainButton) {
+          state.activeDomain = domainButton.dataset.selectDomain;
+          const assignedRole = roleDefinitions[roleAssignments[state.userId]];
+          state.selectedRoleId = assignedRole?.domain === state.activeDomain ? roleAssignments[state.userId] : (Object.entries(roleDefinitions).find(([, role]) => role.domain === state.activeDomain)?.[0] || 'custom');
+          $('#advancedWorkspace').hidden = true;
+          $('#simpleWorkspace').hidden = false;
+          renderAll();
+          return;
+        }
+
+        const moduleNode = event.target.closest('[data-select-module]');
+        if (moduleNode && !event.target.closest('input')) {
+          state.selectedModule = moduleNode.dataset.selectModule;
+          renderAll();
+          return;
+        }
+
+        const menuNode = event.target.closest('[data-select-menu]');
+        if (menuNode) {
+          state.selectedMenu = menuNode.dataset.selectMenu;
+          renderMenu();
+          return;
+        }
+
+        const scopeNode = event.target.closest('[data-select-scope]');
+        if (scopeNode) {
+          state.selectedScopeModule = scopeNode.dataset.selectScope;
+          renderScope();
+          return;
+        }
+
+        const tab = event.target.closest('[data-view]');
+        if (tab) {
+          state.activeView = tab.dataset.view;
+          renderAll();
+          return;
+        }
+
+        const simplePreset = event.target.closest('[data-simple-preset]');
+        if (simplePreset) {
+          applySimplePreset(simplePreset.dataset.simplePreset);
+          return;
+        }
+
+        const preset = event.target.closest('[data-preset]');
+        if (preset) {
+          applyPreset(preset.dataset.preset);
+          return;
+        }
+
+        if (event.target.closest('#showAdvanced')) {
+          if (!domainDefinitions[state.activeDomain].advanced) {
+            showToast('该业务域先使用角色方案分配，详细模块调整可按需接入');
+            return;
+          }
+          $('#simpleWorkspace').hidden = true;
+          $('#advancedWorkspace').hidden = false;
+          return;
+        }
+        if (event.target.closest('#showSimple')) {
+          $('#advancedWorkspace').hidden = true;
+          $('#simpleWorkspace').hidden = false;
+          return;
+        }
+
+        if (event.target.closest('#grantDomain')) {
+          setDomainAccess(true); renderAll(); showToast('已授权海运下的全部模块'); return;
+        }
+        if (event.target.closest('#clearDomain')) {
+          setDomainAccess(false); renderAll(); showToast('已清空海运模块权限'); return;
+        }
+        if (event.target.closest('#openPageGrant')) { openPageModal(); return; }
+        if (event.target.closest('#closeModal') || event.target.closest('#cancelModal')) { closePageModal(); return; }
+        if (event.target.closest('#syncSelectedPage')) {
+          const menu = menuDefinitions[state.selectedMenu];
+          menu.modules.forEach((id) => setModuleAccess(id, true));
+          currentData().menu[state.selectedMenu] = true;
+          roleAssignments[state.userId] = 'custom';
+          renderAll();
+          showToast(`已补齐${menu.name}的模块访问权限`);
+          return;
+        }
+        if (event.target.closest('#confirmPageGrant')) {
+          const selected = all('.modal-page-check:checked').map((input) => input.dataset.modalPage);
+          selected.forEach((menuId) => {
+            currentData().menu[menuId] = true;
+            menuDefinitions[menuId].modules.forEach((id) => setModuleAccess(id, true));
+          });
+          if (selected.length) roleAssignments[state.userId] = 'custom';
+          closePageModal();
+          renderAll();
+          showToast(selected.length ? `已按 ${selected.length} 个页面补齐模块权限` : '没有选择页面');
+          return;
+        }
+        if (event.target.closest('#previewEffective') || event.target.closest('#previewEffectiveInline')) { openEffectiveModal(); return; }
+        if (event.target.closest('#closeEffective') || event.target.closest('#cancelEffective')) { closeEffectiveModal(); return; }
+        if (event.target.closest('#saveButton')) { saveCurrentUser(); return; }
+        if (event.target.closest('#discardButton')) { discardCurrentUser(); return; }
+        if (event.target.closest('#applyRole')) {
+          const roleId = $('#roleSelect').value;
+          const role = roleDefinitions[roleId];
+          if (!role || roleId === 'custom') {
+            roleAssignments[state.userId] = 'custom';
+            state.selectedRoleId = 'custom';
+            renderAll();
+            showToast('已切换为自定义权限，请在详细权限中调整');
+            return;
+          }
+          state.activeDomain = role.domain;
+          state.selectedRoleId = roleId;
+          applySimplePreset(role.preset);
+          return;
+        }
+        if (event.target.closest('#helpButton')) { showToast('菜单管入口，模块管能力；父节点只做批量选择'); return; }
+      });
+
+      document.addEventListener('change', (event) => {
+        if (event.target.matches('#roleSelect')) {
+          state.selectedRoleId = event.target.value;
+          renderRoleToolbar();
+          return;
+        }
+        if (event.target.matches('[data-module-access]')) {
+          setModuleAccess(event.target.dataset.moduleAccess, event.target.checked);
+          renderAll();
+          return;
+        }
+        if (event.target.matches('#domainCheck')) {
+          setDomainAccess(event.target.checked); renderAll(); return;
+        }
+        if (event.target.matches('.action-check')) {
+          const actionKey = event.target.dataset.actionKey;
+          roleAssignments[state.userId] = 'custom';
+          currentData().modules[state.selectedModule][actionKey] = event.target.checked;
+          if (actionKey === 'view' && !event.target.checked) {
+            ['create', 'update', 'delete', 'export', 'audit'].forEach((key) => { currentData().modules[state.selectedModule][key] = false; });
+          }
+          if (actionKey !== 'view' && event.target.checked) currentData().modules[state.selectedModule].view = true;
+          renderAll();
+          return;
+        }
+        if (event.target.matches('.field-check')) {
+          roleAssignments[state.userId] = 'custom';
+          const fields = currentData().fields[state.selectedScopeModule];
+          const field = event.target.dataset.fieldName;
+          if (event.target.checked && !fields.includes(field)) fields.push(field);
+          if (!event.target.checked) currentData().fields[state.selectedScopeModule] = fields.filter((item) => item !== field);
+          renderScope();
+          return;
+        }
+        if (event.target.matches('#scopeSelect')) {
+          roleAssignments[state.userId] = 'custom';
+          currentData().scopes[state.selectedScopeModule] = event.target.value;
+          showToast('数据范围已更新');
+          return;
+        }
+        if (event.target.matches('.modal-page-check')) {
+          state.modalPages[event.target.dataset.modalPage] = event.target.checked;
+        }
+      });
+
+      $('#userSearch').addEventListener('input', renderUsers);
+      $('#pageGrantModal').addEventListener('click', (event) => { if (event.target.id === 'pageGrantModal') closePageModal(); });
+      $('#effectiveModal').addEventListener('click', (event) => { if (event.target.id === 'effectiveModal') closeEffectiveModal(); });
+
+      renderAll();
+    </script>
+  </body>
+</html>