schema: 标准列扩展(主表7/从表8列) + 去外键改用纯语义判断(validate-ddl 降4维)

标准列：每表 7 列（新增 iOrder/sMemo；sId/sBrandsId/sSubsidiaryId 改 varchar(50) NOT NULL），从表额外 +sParentId 共 8 列。docs-03 模板 + A3 渲染规则 + A4 DDL 默认值翻译（CURRENT_TIMESTAMP / DEFAULT '1111111111' / iOrder app-assigned）。去外键：A3 不再推导 FK 约束（改语义引用关系，无 ON DELETE/ON UPDATE，应用层维护一致性）；A4 DDL 不生成 ALTER ADD FOREIGN KEY；validate-ddl 移除外键维度 5→4 维（表/列/类型/索引），单测 45 pass/0 fail；coding.mjs 种子/sentinel「FK 有序」→「按语义引用有序」（保留先被引用方后引用方/不可悬空）。注：db-design-gen 的 docs/06 读取清单/步骤B 两条 bullet 与本区域改动同处一个 diff hunk，随本提交落入（实属 docs/06 feature 的 A3 接入）。

schema: 标准列扩展(主表7/从表8列) + 去外键改用纯语义判断(validate-ddl 降4维)
标准列：每表 7 列（新增 iOrder/sMemo；sId/sBrandsId/sSubsidiaryId 改 varchar(50) NOT NULL），从表额外 +sParentId 共 8 列。docs-03 模板 + A3 渲染规则 + A4 DDL 默认值翻译（CURRENT_TIMESTAMP / DEFAULT '1111111111' / iOrder app-assigned）。去外键：A3 不再推导 FK 约束（改语义引用关系，无 ON DELETE/ON UPDATE，应用层维护一致性）；A4 DDL 不生成 ALTER ADD FOREIGN KEY；validate-ddl 移除外键维度 5→4 维（表/列/类型/索引），单测 45 pass/0 fail；coding.mjs 种子/sentinel「FK 有序」→「按语义引用有序」（保留先被引用方后引用方/不可悬空）。注：db-design-gen 的 docs/06 读取清单/步骤B 两条 bullet 与本区域改动同处一个 diff hunk，随本提交落入（实属 docs/06 feature 的 A3 接入）。
zichun
1 parent 12b0d6d4
Showing 9 changed files with 114 additions and 362 deletions
README.md
lib/validate-ddl.mjs
lib/validate-ddl.test.mjs
skills/plan/db-design-gen/SKILL.md
skills/plan/db-design-gen/templates/docs-03-header-template.md
skills/plan/db-design-gen/templates/docs-03-table-template.md
skills/plan/db-init/SKILL.md
skills/plan/project-init/templates/docs-08-initial-template.md
workflows/coding.mjs
@@ -77,7 +77,7 @@ Claude Code 插件：ERP / 后端管理系统全流程开发框架。
    ```
    Plan 阶段**两段式**执行，中间有一个人工审阅断点（docs/03 数据库 schema）：
  
-   - **第一段（首次运行）**：执行 **A0 → A1 → A2 → A3**（创建骨架 / 锁技术栈 / 填需求 / 生成 REQ 卡片 / 生成项目骨架 / 从 REQ 正向设计 `docs/03-数据库设计文档.md` 并回填 REQ 依赖表）后**停下**，等你审阅 docs/03 的表 / 字段 / 索引 / 外键（人工关口：数据库 schema —— A4 会基于它翻译 DDL 并 apply 到 MySQL）。A1 的 REQ 卡片由 CC 据 index.md 填 6 个占位、字段表按模板原样复制，**不再单独停下审阅**
+   - **第一段（首次运行）**：执行 **A0 → A1 → A2 → A3**（创建骨架 / 锁技术栈 / 填需求 / 生成 REQ 卡片 / 生成项目骨架 / 从 REQ 正向设计 `docs/03-数据库设计文档.md` 并回填 REQ 依赖表）后**停下**，等你审阅 docs/03 的表 / 字段 / 索引 / 语义引用关系（人工关口：数据库 schema —— A4 会基于它翻译 DDL 并 apply 到 MySQL）。A1 的 REQ 卡片由 CC 据 index.md 填 6 个占位、字段表按模板原样复制，**不再单独停下审阅**
    - **第二段（docs/03 审阅完重新运行）**：执行 **A4 → A5**（解析 docs/03 → 生成 V1 migration → 自动 `DROP+CREATE` 本地 schema 并 apply → 生成下游文档 → **docs/05 + docs/02 评审闸** → prototype/ 门禁 + 推导 FE 清单写 docs/08 § 三），通过 **Plan 终结硬闸** 后再次**停下**（前端布局/交互以 `prototype/` 为权威，不另设 UI 规范文档）
  
    Plan 完成后不会自动进入编码，需手动 /erp-workflow:coding-start。
@@ -100,7 +100,7 @@ erp-workflow-plugin/
 ├── workflows/
 │   └── coding.mjs                   # 阶段 B：整个编码阶段编排为单个静默 Workflow
 ├── lib/                             # 跨平台 Node 助手（ESM，node:test 单测）
-│   ├── validate-ddl.mjs             # docs/03 ↔ DDL 5 维校验（替代 validate.sh）
+│   ├── validate-ddl.mjs             # docs/03 ↔ DDL 4 维校验（替代 validate.sh）
 │   ├── yaml-config.mjs              # config-vars.yaml 极简 YAML 读取（2 层 map + 标量）
 │   ├── apply-ddl.mjs                # 解析 config-vars.yaml database: 段 + mysql2 apply
 │   └── *.test.mjs                   # 各助手的 node:test 单测
@@ -135,8 +135,8 @@ erp-workflow-plugin/
 | A0 | `project-init` | • **依赖检查**：检测 git / mysql / node 是否在 PATH，缺失则按 OS 自动安装，装不上再停下提示用户<br>• 空目录初始化：用 Read/Write/Glob 工具拷模板创建 CLAUDE.md / docs/01/index.md / docs/08<br>• `git init` | `plan-start` |
 | A1 | `scope-lock` | • 引导填项目概述 / 技术栈 / 需求索引<br>• 按 `docs/01-需求清单/<module>/{_module.md, <req_id>.md}` 子目录结构生成 REQ 卡片（req_id = `<模块代码>-<子模块代码>-<功能名>`，如 `USR-UserInfo-Login`；CC 据 index.md 填 `{{req_id/title/goal/rules/constraints/acceptance}}` 6 个占位，模板其余内容含输入/输出示例字段表原样复制）<br>• **A1 终结校验**：REQ 6 个占位均填真实数据、无 `{{` 残留、`config-vars.yaml` **全部配置**（包名 / 端口 / 初始账号 + DB 凭据 / 密钥占位）已锁、各 stack 的 build/lint/unit/e2e 命令写入 docs/04 § 零；缺失则在此（Plan 期）用 `AskUserQuestion` 问清（敏感凭据由用户自填，不进会话）<br>• 据模板直接 `Write` 生成 `_module.md` / `<req_id>.md`<br>• 终结校验通过后**自动**调用 `Skill(skeleton-gen)` 进入 A2（不停下） | A0 |
 | A2 | `skeleton-gen` | • 生成架构文档：docs/04 § 一+<br>• 生成跨平台工具脚本：`scripts/*.mjs`（**无 chmod**；凭据 / 配置统一在 A1 产出的 config-vars.yaml）<br>• 据 `gitignore-append-template` 用 Read/Write 并入项目 .gitignore | `plan-start` |
-| A3 | `db-design-gen` | • 套用固定 ERP 约定（列前缀 `i/s/t`、`iIncrement` 主键、`sBrandsId`/`sSubsidiaryId` 租户列）从 docs/01 REQ 卡片正向设计 `docs/03-数据库设计文档.md`（schema SSoT）<br>• 回填 REQ 卡片依赖表（`TBD(A3 自动补)` → 实际表名）<br>• **停下**等人工审阅 docs/03，审阅完毕用 `/plan-start` 续进 A4 | A2 |
-| A4 | `db-init` | • LLM 解析 docs/03 → `sql/migrations/V1__initial_schema.sql`（DDL only）<br>• `node ${CLAUDE_PLUGIN_ROOT}/lib/validate-ddl.mjs` 校验 DDL ↔ docs/03（5 维：表/列名/列类型/索引/FK），fail-closed<br>• `node ${CLAUDE_PLUGIN_ROOT}/lib/apply-ddl.mjs config-vars.yaml V1.sql`（读取 config-vars.yaml database: 段 + mysql2 apply） | A3 |
+| A3 | `db-design-gen` | • 套用固定 ERP 约定（列前缀 `i/s/t`、`iIncrement` 主键、`sBrandsId`/`sSubsidiaryId` 租户列）+ 每表自动补标准列（主表 7 列：`iIncrement`/`sId`/`sBrandsId`/`sSubsidiaryId`/`tCreateDate`/`iOrder`/`sMemo`，从表 8 列额外加 `sParentId` 紧随 `sId`；其中 `sId`/`sBrandsId`/`sSubsidiaryId` 为 varchar(50) NOT NULL）从 docs/01 REQ 卡片正向设计 `docs/03-数据库设计文档.md`（schema SSoT）<br>• 回填 REQ 卡片依赖表（`TBD(A3 自动补)` → 实际表名）<br>• **停下**等人工审阅 docs/03，审阅完毕用 `/plan-start` 续进 A4 | A2 |
+| A4 | `db-init` | • LLM 解析 docs/03 → `sql/migrations/V1__initial_schema.sql`（DDL only）<br>• `node ${CLAUDE_PLUGIN_ROOT}/lib/validate-ddl.mjs` 校验 DDL ↔ docs/03（4 维：表/列名/列类型/索引），fail-closed<br>• `node ${CLAUDE_PLUGIN_ROOT}/lib/apply-ddl.mjs config-vars.yaml V1.sql`（读取 config-vars.yaml database: 段 + mysql2 apply） | A3 |
 | A5 | `downstream-gen` | • 一次性生成 docs/02 / docs/05<br>• 回填 REQ 卡片依赖接口（`TBD(A5 自动补)` → 实际 endpoint）<br>• 追加模块清单到 docs/08 § 二<br>• **docs/05 + docs/02 评审闸**：用 `AskUserQuestion` 让用户确认 API 端点/字段无误 + 构建顺序可接受，未确认不勾 A5<br>• **prototype/ 门禁 + 推导 FE 清单写 docs/08 § 三**（原 A6 已并入；无 prototype 则问「无前端」→ § 三 留空）<br>• 最终占位符 + 结构残留扫描 | A4 |
  
 ### Coding 阶段（1 个 Workflow，非 skill）
-// lib/validate-ddl.mjs — docs/03 表格 ↔ DDL（V1.sql）一致性 5 维校验
+// lib/validate-ddl.mjs — docs/03 表格 ↔ DDL（V1.sql）一致性 4 维校验
 // 替换 db-init/scripts/validate.sh（跨平台、纯 Node、零外部依赖）。
 //
 // 用法（CLI）：node lib/validate-ddl.mjs <docs03Path> <ddlPath>
@@ -6,14 +6,13 @@
 // 程序内：import { parseDocsTables, parseDDL, diffSchema } from './validate-ddl.mjs'
 //
 // 数据结构（解析结果）：Map<tableName, {
-//   columns: Map<colName, type>, indexes: Set<string>, foreignKeys: Set<string> }>
+//   columns: Map<colName, type>, indexes: Set<string> }>
  
 // ── 解析 docs/03 markdown 表定义 ─────────────────────────────────
 // 约定：每张表一节，节标题形如  ## `表名`  或  ## `表名` — 业务含义
-// 节内分 ### 字段（markdown 表格，首列列名、次列类型）、### 索引、### 外键（项目符号列表）。
-// 索引/外键的 bullet 形态见 db-design-gen/templates/docs-03-table-template.md：
+// 节内分 ### 字段（markdown 表格，首列列名、次列类型）、### 索引（项目符号列表）。
+// 索引的 bullet 形态见 db-design-gen/templates/docs-03-table-template.md：
 //   ### 索引   →  - `name` (type): cols
-//   ### 外键   →  - `name`: from_col → to_table.to_col (on_delete)
 // 跳过表头行（列/字段/类型等标签）与分隔行（---）。
 // 形如「## 一、全局约定」这类非反引号标题不视为表。
 export function parseDocsTables(text) {
@@ -21,14 +20,14 @@ export function parseDocsTables(text) {
   const lines = String(text).split('\n')
   // 反引号包裹的表名：## `name` 或 ## `name` — purpose
   const headerRe = /^##\s+`([^`]+)`/
-  let current = null // { columns, indexes, foreignKeys }
-  let mode = 'col'   // 当前子区块：'col'（字段表格）/ 'idx'（索引）/ 'fk'（外键）
+  let current = null // { columns, indexes }
+  let mode = 'col'   // 当前子区块：'col'（字段表格）/ 'idx'（索引）
  
   for (const raw of lines) {
     const line = raw.replace(/\r$/, '')
     const h2 = line.match(headerRe)
     if (h2) {
-      current = { columns: new Map(), indexes: new Set(), foreignKeys: new Set() }
+      current = { columns: new Map(), indexes: new Set() }
       mode = 'col'
       tables.set(h2[1].trim(), current)
       continue
@@ -39,15 +38,14 @@ export function parseDocsTables(text) {
       continue
     }
     if (!current) continue
-    // ### 子区块切换（### 索引 / ### 外键 / 其它如 ### 字段、### 业务注记 → col）
+    // ### 子区块切换（### 索引 / 其它如 ### 字段、### 业务注记、### 引用关系 → col）
     const h3 = line.match(/^###\s+(.+)$/)
     if (h3) {
       const title = h3[1].trim()
-      mode = /索引|index/i.test(title) ? 'idx' : /外键|foreign/i.test(title) ? 'fk' : 'col'
+      mode = /索引|index/i.test(title) ? 'idx' : 'col'
       continue
     }
     if (mode === 'idx') { parseIndexBullet(line, current.indexes); continue }
-    if (mode === 'fk') { parseForeignKeyBullet(line, current.foreignKeys); continue }
     // mode === 'col'：markdown 表格行（以 | 开头）
     if (!/^\s*\|/.test(line)) continue
     const cells = splitMarkdownRow(line)
@@ -89,42 +87,6 @@ function parseIndexBullet(line, indexes) {
   indexes.add(`${name}:${kind}:${cols}`)
 }
  
-// 解析外键 bullet：  - `name`: from_col → to_table.to_col (on_delete)
-// 归一化为 parseDDL 同形的 `${fromCols}->${toTable}(${toCols})`（注意 docs 用 unicode → / DDL 用 ->）。
-function parseForeignKeyBullet(line, foreignKeys) {
-  // 1) 先把头部 `- `name`: ... → table` 抠出来，保留"目标表后剩余的尾段"用于解析目标列（可能是
-  //    `.idA`、`.idA, idB`、`.(idA, idB)` 或 `.`idA`,`idB``）。
-  // 目标表名用 [^`\s.]+（接受反引号包裹的中文表名，H3；以 `.` 与目标列分隔），与 docs headerRe 的非 ASCII 容许度对齐。
-  const head = line.match(/^\s*-\s+`?[^`:]+`?\s*:\s*([^→>\n]+?)\s*(?:→|->)\s*`?([^`\s.]+)`?\s*\.\s*(.+)$/)
-  if (!head) return
-  const fromRaw = head[1]
-  const toTable = head[2]
-  let toRaw = head[3]
-  if (!fromRaw || !toTable || !toRaw) return
-
-  const fromCols = fromRaw.replace(/`/g, '').replace(/\s+/g, '')
-
-  // 2) 目标列：剥掉一对外层圆括号（如果有），按逗号切分，去反引号 / 空白；遇到第一个非
-  //    `[A-Za-z0-9_]` 列分隔符以外的字符（如 `(CASCADE)`、` on delete ...`）就停止收集。
-  toRaw = toRaw.trim()
-  // 在分列前先尝试抓取尾部的 on-delete 标记：(CASCADE) / (RESTRICT) / (SET NULL) / (NO ACTION) /
-  // (SET DEFAULT)；docs 模板规约把 action 写在一对独立括号里，紧跟在目标列之后。
-  const onDeleteMatch = toRaw.match(/\((CASCADE|RESTRICT|SET\s+NULL|SET\s+DEFAULT|NO\s+ACTION)\)\s*$/i)
-  const onDelete = onDeleteMatch ? onDeleteMatch[1].toUpperCase().replace(/\s+/g, ' ') : 'RESTRICT'
-  // 剥外层括号：(idA, idB) → idA, idB
-  const paren = toRaw.match(/^\(([^)]*)\)/)
-  let toBody = paren ? paren[1] : toRaw
-  // 截断到第一个 `(`（如 `(CASCADE)`）或行尾。
-  toBody = toBody.split('(')[0]
-  const toCols = toBody
-    .split(',')
-    .map(s => s.replace(/`/g, '').trim())
-    .filter(s => /^[A-Za-z0-9_]+$/.test(s))
-    .join(',')
-  if (!fromCols || !toTable || !toCols) return
-  foreignKeys.add(`${fromCols}->${toTable}(${toCols}):${onDelete}`)
-}
-
 // ── 解析 CREATE TABLE DDL ────────────────────────────────────────
 // 标识符 token：反引号包裹（任意非反引号字符，支持中文）或裸 ASCII 标识符（含 `$`）。
 // docs 侧表名/索引名以 `[^`]+` 接受中文，DDL 侧此前仅 `[A-Za-z0-9_]+` → 中文名假阳性（H3）。
@@ -170,15 +132,12 @@ function blankStringLiterals(s) {
   return out
 }
  
-// 表体内联索引 / 外键的匹配器（与 IDENT 同语法，支持反引号包裹的非 ASCII 名，H3 全路径一致）。
+// 表体内联索引的匹配器（与 IDENT 同语法，支持反引号包裹的非 ASCII 名，H3 全路径一致）。
 const INLINE_KEY_RE = new RegExp(
   '^(?:UNIQUE\\s+(?:KEY|INDEX)|KEY|INDEX|FULLTEXT\\s+KEY|SPATIAL\\s+KEY)\\s+(' + IDENT + ')\\s*\\(', 'i')
-const INLINE_FK_RE = new RegExp(
-  'FOREIGN\\s+KEY\\s*\\(([^)]*)\\)\\s*REFERENCES\\s+(?:' + IDENT + '\\s*\\.\\s*)?(' + IDENT + ')\\s*\\(([^)]*)\\)' +
-  '(?:\\s+ON\\s+DELETE\\s+(CASCADE|RESTRICT|SET\\s+NULL|SET\\s+DEFAULT|NO\\s+ACTION))?', 'i')
  
-// 提取每个 CREATE TABLE 的：列名→类型、索引名集合、外键描述集合。
-// 第二遍并入 db-init A.1 强制的独立语句形态（CREATE INDEX / ALTER TABLE ADD FK，C1）。
+// 提取每个 CREATE TABLE 的：列名→类型、索引名集合。
+// 第二遍并入 db-init A.1 强制的独立语句形态（CREATE INDEX，C1）。
 export function parseDDL(text) {
   const tables = new Map()
   // 先剥离 SQL 注释，避免被注释掉的 CREATE TABLE 被当成真实表（幽灵表假阳性）。
@@ -194,19 +153,18 @@ export function parseDDL(text) {
     const bodyStart = createRe.lastIndex - 1 // 指向 '('
     const body = extractBalancedParens(src, bodyStart)
     if (body == null) continue
-    // 抹掉列体内字符串字面量再解析：避免 DEFAULT / COMMENT 里出现 "FOREIGN KEY …" / "KEY …" 文本被
+    // 抹掉列体内字符串字面量再解析：避免 DEFAULT / COMMENT 里出现 "KEY …" 文本被
     // 内联检测误当真实约束（REGEX-3）；反引号标识符整段保留，列名/类型解析不读字面量内容，故不受影响。
     tables.set(tableName, parseTableBody(blankStringLiterals(body)))
     // 继续从 body 之后扫描
     createRe.lastIndex = bodyStart + body.length + 2
   }
  
-  // 第二遍：db-init A.1/A.2 强制 DDL 形态为 CREATE TABLE → CREATE INDEX → ALTER TABLE ADD FK，
-  // 索引 / 外键写在表体之外。把这些独立语句并回对应表，否则含索引 / 外键的 schema 首轮校验必报假阳性（C1）。
-  // 扫描前先抹掉字符串字面量内部，避免 DEFAULT / COMMENT 里的 "CREATE INDEX …" / "ALTER TABLE …" 文本被误当语句（REGEX-3）。
+  // 第二遍：db-init A.1/A.2 强制 DDL 形态为 CREATE TABLE → CREATE INDEX，
+  // 索引写在表体之外。把这些独立语句并回对应表，否则含索引的 schema 首轮校验必报假阳性（C1）。
+  // 扫描前先抹掉字符串字面量内部，避免 DEFAULT / COMMENT 里的 "CREATE INDEX …" 文本被误当语句（REGEX-3）。
   const scanSrc = blankStringLiterals(src)
   mergeStandaloneIndexes(scanSrc, tables)
-  mergeStandaloneForeignKeys(scanSrc, tables)
   return tables
 }
  
@@ -229,57 +187,16 @@ function mergeStandaloneIndexes(src, tables) {
   }
 }
  
-// 独立 `ALTER TABLE <table> ADD [CONSTRAINT n] FOREIGN KEY (cols) REFERENCES [<db>.]<ref> (refcols) [ON DELETE x]`
-// → 并入 table.foreignKeys，归一化与 parseTableBody 内联 FK 同形（C1）。
-// 先框定每条 ALTER 语句（到 `;` 或结尾），再在其体内抓所有 ADD…FOREIGN KEY 子句，
-// 支持一条 ALTER 内逗号分隔的多个 ADD（REGEX-4）。src 已抹掉字符串字面量，故 `;` 边界与匹配都安全。
-function mergeStandaloneForeignKeys(src, tables) {
-  const stmtRe = new RegExp(
-    'ALTER\\s+TABLE\\s+(?:' + IDENT + '\\s*\\.\\s*)?(' + IDENT + ')([\\s\\S]*?)(?:;|$)', 'gi')
-  const clauseRe = new RegExp(
-    'ADD\\s+(?:CONSTRAINT\\s+' + IDENT + '\\s+)?FOREIGN\\s+KEY\\s*\\(([^)]*)\\)\\s*REFERENCES\\s+' +
-    '(?:' + IDENT + '\\s*\\.\\s*)?(' + IDENT + ')\\s*\\(([^)]*)\\)' +
-    '(?:\\s+ON\\s+DELETE\\s+(CASCADE|RESTRICT|SET\\s+NULL|SET\\s+DEFAULT|NO\\s+ACTION))?', 'gi')
-  let s
-  while ((s = stmtRe.exec(src)) !== null) {
-    const t = tables.get(stripTicks(s[1]))
-    if (!t) continue
-    const body = s[2]
-    clauseRe.lastIndex = 0
-    let c
-    while ((c = clauseRe.exec(body)) !== null) {
-      const fromCols = c[1].replace(/`/g, '').replace(/\s+/g, '')
-      const refTable = stripTicks(c[2])
-      const toCols = c[3].replace(/`/g, '').replace(/\s+/g, '')
-      const onDelete = (c[4] || 'RESTRICT').toUpperCase().replace(/\s+/g, ' ')
-      if (!fromCols || !refTable || !toCols) continue
-      t.foreignKeys.add(`${fromCols}->${refTable}(${toCols}):${onDelete}`)
-    }
-  }
-}
-
 function parseTableBody(body) {
   const columns = new Map()
   const indexes = new Set()
-  const foreignKeys = new Set()
   for (const itemRaw of splitTopLevelCommas(body)) {
     const item = itemRaw.trim()
     if (!item) continue
     const upper = item.toUpperCase()
  
-    // 外键约束（可带前缀 CONSTRAINT <name>）
+    // 外键约束（可带前缀 CONSTRAINT <name>）→ 已去掉外键维度，直接跳过（不进 indexes/约束）。
     if (/\bFOREIGN\s+KEY\b/i.test(item)) {
-      // REFERENCES 支持 schema 限定与反引号包裹的非 ASCII 目标表（IDENT，H3 全路径一致；取末段为表名）。
-      const fk = item.match(INLINE_FK_RE)
-      if (fk) {
-        const fromCols = fk[1].replace(/`/g, '').replace(/\s+/g, '')
-        const refTable = stripTicks(fk[2])
-        const toCols = fk[3].replace(/`/g, '').replace(/\s+/g, '')
-        const onDelete = (fk[4] || 'RESTRICT').toUpperCase().replace(/\s+/g, ' ')
-        foreignKeys.add(`${fromCols}->${refTable}(${toCols}):${onDelete}`)
-      } else {
-        foreignKeys.add(item)
-      }
       continue
     }
  
@@ -325,7 +242,7 @@ function parseTableBody(body) {
     const type = extractType(col[3])
     columns.set(name, type)
   }
-  return { columns, indexes, foreignKeys }
+  return { columns, indexes }
 }
  
 // 从列定义剩余部分提取类型（含括号内长度），到下一个属性关键字前停止。
@@ -350,7 +267,6 @@ export function diffSchema(docsTables, ddlTables) {
     columnMismatches: [],    // { table, column, side: 'docs'|'ddl' }
     typeMismatches: [],      // { table, column, docsType, ddlType }
     indexMismatches: [],     // { table, index, side: 'docs'|'ddl' }
-    foreignKeyMismatches: [],// { table, foreignKey, side: 'docs'|'ddl' }
     hasDiff: false,
   }
  
@@ -361,7 +277,7 @@ export function diffSchema(docsTables, ddlTables) {
   diff.missingTables.sort()
   diff.extraTables.sort()
  
-  // 仅对共有表做列/类型/索引/外键比对
+  // 仅对共有表做列/类型/索引比对
   for (const t of [...docNames].filter(n => ddlNames.has(n)).sort()) {
     const d = docsTables.get(t)
     const s = ddlTables.get(t)
@@ -388,16 +304,11 @@ export function diffSchema(docsTables, ddlTables) {
     symDiff(dIdx, sIdx,
       ix => diff.indexMismatches.push({ table: t, index: ix, side: 'docs' }),
       ix => diff.indexMismatches.push({ table: t, index: ix, side: 'ddl' }))
-
-    // 维度 5：外键
-    symDiff(d.foreignKeys || new Set(), s.foreignKeys || new Set(),
-      fk => diff.foreignKeyMismatches.push({ table: t, foreignKey: fk, side: 'docs' }),
-      fk => diff.foreignKeyMismatches.push({ table: t, foreignKey: fk, side: 'ddl' }))
   }
  
   diff.hasDiff = diff.missingTables.length > 0 || diff.extraTables.length > 0 ||
     diff.columnMismatches.length > 0 || diff.typeMismatches.length > 0 ||
-    diff.indexMismatches.length > 0 || diff.foreignKeyMismatches.length > 0
+    diff.indexMismatches.length > 0
   return diff
 }
  
@@ -568,12 +479,6 @@ export function formatDiff(diff) {
       out.push(`  - ${m.table} 索引 ${m.index} 仅在 ${m.side === 'docs' ? 'docs/03' : 'DDL'}`)
     }
   }
-  if (diff.foreignKeyMismatches.length) {
-    out.push('=== 维度5 外键 ===')
-    for (const m of diff.foreignKeyMismatches) {
-      out.push(`  - ${m.table} 外键 ${m.foreignKey} 仅在 ${m.side === 'docs' ? 'docs/03' : 'DDL'}`)
-    }
-  }
   return out.join('\n')
 }
  
@@ -597,6 +502,6 @@ if (isCliEntry) {
     console.error(formatDiff(diff))
     process.exit(1)
   }
-  console.log('validate-ddl: ✓ docs/03 与 DDL 在 5 维（表/列/类型/索引/外键）一致')
+  console.log('validate-ddl: ✓ docs/03 与 DDL 在 4 维（表/列/类型/索引）一致')
   process.exit(0)
 }
-// lib/validate-ddl.test.mjs â€” å•æµ‹ï¼šdocs/03 è¡¨æ ¼ â†” DDL 5 ç»´ diff
+// lib/validate-ddl.test.mjs â€” å•æµ‹ï¼šdocs/03 è¡¨æ ¼ â†” DDL 4 ç»´ diff
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 import { parseDocsTables, parseDDL, diffSchema } from './validate-ddl.mjs'
@@ -61,8 +61,8 @@ test(&#39;parseDocsTables: real docs/03 format â€” ## `t` â€” purpose + ### å—æ®µ +
   assert.equal(order.columns.has('---'), false)
 })
  
-// å…¨é“¾è·¯ï¼šæ¨¡æ¿æ ¼å¼ docs/03ï¼ˆ### å—æ®µ + ### ç´¢å¼• + ### å¤–é”® bulletï¼‰â†’ parseDocsTables å¿…é¡»
-// æŠŠç´¢å¼•/å¤–é”®è§£æžè¿› Setï¼ˆå›žå½’ C2ï¼šæ¤å‰ parseDocsTables ä»Žä¸å†™ indexes/foreignKeysï¼‰ã€‚
+// å…¨é“¾è·¯ï¼šæ¨¡æ¿æ ¼å¼ docs/03ï¼ˆ### å—æ®µ + ### ç´¢å¼• bulletï¼‰â†’ parseDocsTables å¿…é¡»
+// æŠŠç´¢å¼•è§£æžè¿› Setï¼ˆå›žå½’ C2ï¼šæ¤å‰ parseDocsTables ä»Žä¸å†™ indexesï¼‰ã€‚
 const DOCS_FULL = [
   '## `t_order` â€” è®¢å•ä¸»è¡¨',
   '',
@@ -76,51 +76,30 @@ const DOCS_FULL = [
   '- `pk` (PRIMARY): iId',
   '- `idx_user` (index): sUserId',
   '',
-  '### å¤–é”®',
-  '- `fk_user`: sUserId â†’ t_user.sId (CASCADE)',
-  '',
 ].join('\n')
 const DDL_FULL = [
   'CREATE TABLE `t_order` (',
   '  `iId` bigint NOT NULL AUTO_INCREMENT,',
   '  `sUserId` varchar(100) NOT NULL,',
   '  PRIMARY KEY (`iId`),',
-  '  KEY `idx_user` (`sUserId`),',
-  '  CONSTRAINT `fk_user` FOREIGN KEY (`sUserId`) REFERENCES `t_user` (`sId`) ON DELETE CASCADE',
+  '  KEY `idx_user` (`sUserId`)',
   ') ENGINE=InnoDB;',
 ].join('\n')
  
-test('parseDocsTables: parses ### ç´¢å¼• / ### å¤–é”® bullets into sets (C2 regression)', () => {
+test('parseDocsTables: parses ### ç´¢å¼• bullets into sets (C2 regression)', () => {
   const t = parseDocsTables(DOCS_FULL).get('t_order')
   assert.ok(t)
   assert.ok(t.indexes.has('PRIMARY'), 'PRIMARY index normalized')
   assert.ok(t.indexes.has('idx_user:INDEX:sUserId'),
     'named index normalized to name:kind:cols â€” got: ' + [...t.indexes])
-  assert.ok(t.foreignKeys.has('sUserId->t_user(sId):CASCADE'),
-    'FK normalized to parseDDL form with on-delete â€” got: ' + [...t.foreignKeys])
 })
  
-test('full chain: matching docs/03 (with indexes+FK) â†” DDL yields no diff (C2 regression)', () => {
+test('full chain: matching docs/03 (with indexes) â†” DDL yields no diff (C2 regression)', () => {
   const d = diffSchema(parseDocsTables(DOCS_FULL), parseDDL(DDL_FULL))
   assert.deepEqual(d.indexMismatches, [], 'index dimension clean')
-  assert.deepEqual(d.foreignKeyMismatches, [], 'FK dimension clean')
   assert.equal(d.hasDiff, false, 'no spurious diff on a faithful schema')
 })
  
-test('full chain: a real FK present in docs but missing from DDL is caught', () => {
-  const ddlNoFk = [
-    'CREATE TABLE `t_order` (',
-    '  `iId` bigint NOT NULL AUTO_INCREMENT,',
-    '  `sUserId` varchar(100) NOT NULL,',
-    '  PRIMARY KEY (`iId`),',
-    '  KEY `idx_user` (`sUserId`)',
-    ') ENGINE=InnoDB;',
-  ].join('\n')
-  const d = diffSchema(parseDocsTables(DOCS_FULL), parseDDL(ddlNoFk))
-  assert.ok(d.foreignKeyMismatches.some(m => m.side === 'docs' && m.foreignKey === 'sUserId->t_user(sId):CASCADE'))
-  assert.equal(d.hasDiff, true)
-})
-
 test('parseDDL: CREATE TABLE inside a comment is NOT counted as a table (L4)', () => {
   const ddl = [
     '-- CREATE TABLE ghost_line ( x int );',
@@ -148,7 +127,7 @@ test(&#39;parseDocsTables: top-level ## headers like &quot;## ä¸€ã€å…¨å±€çº¦å®š&quot; are NOT
 })
  
 // â”€â”€ parseDDL â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
-test('parseDDL: columns, types, indexes, foreign keys (backtick-quoted)', () => {
+test('parseDDL: columns, types, indexes (backtick-quoted); FOREIGN KEY é¡¹è¢«è·³è¿‡', () => {
   const ddl = [
     'CREATE TABLE `t_order` (',
     '  `iIncrement` int NOT NULL AUTO_INCREMENT,',
@@ -169,8 +148,9 @@ test(&#39;parseDDL: columns, types, indexes, foreign keys (backtick-quoted)&#39;, () =&gt; 
   assert.ok(t.indexes.has('uk_sid:UNIQUE:sId'), 'unique index normalized â€” got: ' + [...t.indexes])
   assert.ok(t.indexes.has('idx_user:INDEX:sUserId'), 'named index normalized â€” got: ' + [...t.indexes])
   assert.ok([...t.indexes].some(i => i.toUpperCase().includes('PRIMARY')))
-  // foreign key collected
-  assert.ok([...t.foreignKeys].some(fk => fk.includes('sUserId') && fk.includes('t_user')))
+  // FOREIGN KEY é¡¹ä¸å†è¢« trackï¼Œä¹Ÿä¸åº”æ··å…¥ indexes
+  assert.equal([...t.indexes].some(ix => /fk_user|t_user|FOREIGN/i.test(ix)), false,
+    'FK é¡¹ä¸åº”è½è¿› indexes â€” got: ' + [...t.indexes])
 })
  
 test('parseDDL: unquoted identifiers and inline PRIMARY KEY', () => {
@@ -187,7 +167,7 @@ test(&#39;parseDDL: multiple tables&#39;, () =&gt; {
   assert.deepEqual([...tables.keys()].sort(), ['a', 'b'])
 })
  
-// â”€â”€ diffSchema 5 dimensions â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+// â”€â”€ diffSchema 4 dimensions â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
 test('diffSchema: missing table (in docs, not in DDL) reported', () => {
   const docs = parseDocsTables('## `t_user`\n| åˆ— | ç±»åž‹ |\n|---|---|\n| iId | bigint |\n')
   const ddl = parseDDL('CREATE TABLE other ( z int );')
@@ -211,19 +191,12 @@ test(&#39;diffSchema: extra column in DDL reported as columnMismatch&#39;, () =&gt; {
 })
  
 test('diffSchema: index dimension diff reported', () => {
-  const docs = new Map([['t', { columns: new Map([['c', 'int']]), indexes: new Set(['idx_c:INDEX:c']), foreignKeys: new Set() }]])
+  const docs = new Map([['t', { columns: new Map([['c', 'int']]), indexes: new Set(['idx_c:INDEX:c']) }]])
   const ddl = parseDDL('CREATE TABLE t ( c int );') // no indexes
   const d = diffSchema(docs, ddl)
   assert.ok(d.indexMismatches.some(m => m.table === 't' && m.index === 'idx_c:INDEX:c'))
 })
  
-test('diffSchema: foreign-key dimension diff reported', () => {
-  const docs = new Map([['t', { columns: new Map([['c', 'int']]), indexes: new Set(), foreignKeys: new Set(['c->other']) }]])
-  const ddl = parseDDL('CREATE TABLE t ( c int );') // no FKs
-  const d = diffSchema(docs, ddl)
-  assert.ok(d.foreignKeyMismatches.some(m => m.table === 't' && m.foreignKey === 'c->other'))
-})
-
 test('diffSchema: hasDiff is false when everything matches, true otherwise', () => {
   const ok = diffSchema(parseDocsTables(DOCS), parseDDL(DDL))
   assert.equal(ok.hasDiff, false)
@@ -268,47 +241,6 @@ test(&#39;parseDDL: CREATE TABLE db.t ä¸Ž `db`.`t` éƒ½åº”è§£æžï¼ˆå–æœ«æ®µä¸ºè¡¨å
   assert.deepEqual([...tables2.keys()], ['t_user'])
 })
  
-// â”€â”€ å¤åˆå¤–é”® docsâ†”DDL å¯¹ç§°ï¼ˆå›žå½’ï¼‰â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
-test('parseDocsTables: å¤åˆå¤–é”® - colA, colB â†’ other.idA, idB åº”å¹³é“ºæˆ colA,colB->other(idA,idB)', () => {
-  const docs = [
-    '## `t_link`',
-    '### å—æ®µ',
-    '| åˆ— | ç±»åž‹ |',
-    '|---|---|',
-    '| `colA` | int |',
-    '| `colB` | int |',
-    '### å¤–é”®',
-    '- `fk_x`: colA, colB â†’ other.idA, idB (CASCADE)',
-  ].join('\n')
-  const t = parseDocsTables(docs).get('t_link')
-  assert.ok(t)
-  assert.ok(t.foreignKeys.has('colA,colB->other(idA,idB):CASCADE'),
-    'docs-side composite FK should normalize the same way as parseDDL â€” got: ' + [...t.foreignKeys])
-})
-
-test('full chain: å¤åˆå¤–é”® docs â†” DDL ä¸€è‡´æ—¶ä¸åº”è¯¯æŠ¥åŒå‘ mismatch', () => {
-  const docs = [
-    '## `t_link`',
-    '### å—æ®µ',
-    '| åˆ— | ç±»åž‹ |',
-    '|---|---|',
-    '| `colA` | int |',
-    '| `colB` | int |',
-    '### å¤–é”®',
-    '- `fk_x`: colA, colB â†’ other.(idA, idB)',
-  ].join('\n')
-  const ddl = [
-    'CREATE TABLE `t_link` (',
-    '  `colA` int NOT NULL,',
-    '  `colB` int NOT NULL,',
-    '  CONSTRAINT `fk_x` FOREIGN KEY (`colA`, `colB`) REFERENCES `other` (`idA`, `idB`)',
-    ') ENGINE=InnoDB;',
-  ].join('\n')
-  const d = diffSchema(parseDocsTables(docs), parseDDL(ddl))
-  assert.deepEqual(d.foreignKeyMismatches, [],
-    'å¤åˆ FK ä¸€è‡´æ—¶ä¸åº”è¯¯æŠ¥ â€” got: ' + JSON.stringify(d.foreignKeyMismatches))
-})
-
 // â”€â”€ æœªåŠ å¼•å·çš„ä¿ç•™å—åˆ—åï¼ˆå›žå½’ï¼‰â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
 test('parseDDL: æœªåŠ å¼•å·çš„ä¿ç•™å—åˆ—å `key varchar(...)` ä¸åº”è¢«è¯¯åˆ¤ä¸ºç´¢å¼•ä¹Ÿä¸åº”åˆ¶é€ å¹½çµåˆ—ï¼ˆfix #2ï¼‰', () => {
   // åˆ—å key æœªåŠ åå¼•å·ï¼Œä¸”åŽé¢è·Ÿçš„æ˜¯ `varchar(`ï¼ˆä¸€ä¸ªç±»åž‹è€Œéž `key <name> (`ï¼‰ã€‚
@@ -352,20 +284,6 @@ test(&#39;parseDDL: `KEY decimal (c)` ä¸åº”è¢«è§£æžä¸ºåˆ—ï¼ˆfix #2/#20ï¼‰&#39;, () =&gt; 
   assert.deepEqual([...t.columns.keys()], ['c'])
 })
  
-// â”€â”€ #3 REFERENCES schema-qualified table â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
-test('parseDDL: FK REFERENCES mydb.users(id) å½’ä¸€åŒ–ä¸º uid->users(id)ï¼ˆfix #3ï¼‰', () => {
-  const ddl = [
-    'CREATE TABLE t (',
-    '  uid int NOT NULL,',
-    '  FOREIGN KEY (uid) REFERENCES mydb.users(id)',
-    ');',
-  ].join('\n')
-  const t = parseDDL(ddl).get('t')
-  assert.ok(t)
-  assert.ok(t.foreignKeys.has('uid->users(id):RESTRICT'),
-    'FK è¡¨ååº”å–æœ«æ®µ users å¹¶é™„é»˜è®¤ on-delete â€” got: ' + [...t.foreignKeys])
-})
-
 // â”€â”€ #4 extractType ä¿ç•™ unsigned/signed ä¿®é¥° â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
 test('extractType: `int unsigned` vs `int unsigned` åŒ¹é…ï¼Œ`int` vs `int unsigned` æŠ¥ mismatchï¼ˆfix #4ï¼‰', () => {
   const docsOk = parseDocsTables('## `t`\n| åˆ— | ç±»åž‹ |\n|---|---|\n| id | int unsigned |\n')
@@ -380,14 +298,7 @@ test(&#39;extractType: `int unsigned` vs `int unsigned` åŒ¹é…ï¼Œ`int` vs `int unsig
     'ä¸€ä¾§å¸¦ unsigned ä¸€ä¾§ä¸å¸¦åº”æŠ¥ mismatch â€” got: ' + JSON.stringify(bad.typeMismatches))
 })
  
-// â”€â”€ #9 æ•£æ–‡ bullet ä¸åº”è¢«å½“ FK / ç´¢å¼• â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
-test('parseDocsTables: ### å¤–é”® ä¸‹çš„æ•£æ–‡ bullet (å« `>`) ä¸åº”è¢«å½“å¤–é”®ï¼ˆfix #9ï¼‰', () => {
-  const docs = '## `t`\n### å¤–é”®\n- note: a > users.id\n'
-  const t = parseDocsTables(docs).get('t')
-  assert.ok(t)
-  assert.equal(t.foreignKeys.size, 0, 'bare `>` ä¸å†ä½œä¸ºå¤–é”®ç®å¤´ â€” got: ' + [...t.foreignKeys])
-})
-
+// â”€â”€ #9 æ•£æ–‡ bullet ä¸åº”è¢«å½“ç´¢å¼• â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
 test('parseDocsTables: ### ç´¢å¼• ä¸‹çº¯æ•£æ–‡ bullet ä¸åº”è¢«å½“ç´¢å¼•ï¼ˆfix #9ï¼‰', () => {
   const docs = '## `t`\n### ç´¢å¼•\n- This bullet is not an index entry\n'
   const t = parseDocsTables(docs).get('t')
@@ -438,37 +349,16 @@ test(&#39;diffSchema: åŒåç´¢å¼• UNIQUE vs éž UNIQUE åº”æŠ¥ mismatchï¼ˆfix #10ï¼‰
   assert.ok(d.indexMismatches.length > 0, 'UNIQUE vs INDEX åº”æŠ¥ â€” got: ' + JSON.stringify(d.indexMismatches))
 })
  
-// â”€â”€ #11 ON DELETE actions differentiated â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
-test('diffSchema: FK ON DELETE CASCADE vs ç¼ºçœ RESTRICT åº”æŠ¥ mismatchï¼ˆfix #11ï¼‰', () => {
-  const docs = parseDocsTables([
-    '## `t`',
-    '### å—æ®µ',
-    '| åˆ— | ç±»åž‹ |',
-    '|---|---|',
-    '| `uid` | int |',
-    '### å¤–é”®',
-    '- `fk_uid`: uid â†’ users.id (CASCADE)',
-  ].join('\n'))
-  const ddl = parseDDL([
-    'CREATE TABLE `t` (',
-    '  `uid` int,',
-    '  FOREIGN KEY (`uid`) REFERENCES `users`(`id`)',
-    ') ENGINE=InnoDB;',
-  ].join('\n'))
-  const d = diffSchema(docs, ddl)
-  assert.ok(d.foreignKeyMismatches.length > 0, 'CASCADE vs RESTRICT åº”æŠ¥ â€” got: ' + JSON.stringify(d.foreignKeyMismatches))
-})
-
 // â”€â”€ #16 CREATE TEMPORARY TABLE ä¹Ÿåº”è¢«è¯†åˆ« â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
 test('parseDDL: CREATE TEMPORARY TABLE ä¹Ÿåº”è¢«è§£æžï¼ˆfix #16ï¼‰', () => {
   const tables = parseDDL('CREATE TEMPORARY TABLE t_tmp ( id int );')
   assert.deepEqual([...tables.keys()], ['t_tmp'], 'TEMPORARY è¡¨åº”å…¥ Map â€” got: ' + [...tables.keys()])
 })
  
-// â”€â”€ C1: ç‹¬ç«‹è¯å¥å½¢æ€çš„ç´¢å¼• / å¤–é”®ï¼ˆdb-init A.1 å¼ºåˆ¶çš„ DDL å½¢æ€ï¼‰â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
-// db-init A.1/A.2 å¼ºåˆ¶ DDL å½¢æ€ä¸ºï¼šCREATE TABLE â†’ CREATE INDEX â†’ ALTER TABLE ADD FK
-// ï¼ˆç´¢å¼• / å¤–é”®å†™åœ¨è¡¨ä½“ä¹‹å¤–çš„ç‹¬ç«‹è¯å¥ï¼‰ã€‚parseDDL å¿…é¡»æŠŠè¿™äº›ç‹¬ç«‹è¯å¥å¹¶å›žå¯¹åº”è¡¨çš„
-// indexes / foreignKeys é›†åˆï¼Œå¦åˆ™ä»»ä½•å«ç´¢å¼• / å¤–é”®çš„ schema é¦–è½®æ ¡éªŒå¿…æŠ¥å‡é˜³æ€§ã€‚
+// â”€â”€ C1: ç‹¬ç«‹è¯å¥å½¢æ€çš„ç´¢å¼•ï¼ˆdb-init A.1 å¼ºåˆ¶çš„ DDL å½¢æ€ï¼‰â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
+// db-init A.1/A.2 å¼ºåˆ¶ DDL å½¢æ€ä¸ºï¼šCREATE TABLE â†’ CREATE INDEXï¼ˆç´¢å¼•å†™åœ¨è¡¨ä½“ä¹‹å¤–çš„
+// ç‹¬ç«‹è¯å¥ï¼‰ã€‚parseDDL å¿…é¡»æŠŠè¿™äº›ç‹¬ç«‹è¯å¥å¹¶å›žå¯¹åº”è¡¨çš„ indexes é›†åˆï¼Œå¦åˆ™ä»»ä½•å«ç´¢å¼•çš„
+// schema é¦–è½®æ ¡éªŒå¿…æŠ¥å‡é˜³æ€§ã€‚
 test('parseDDL: ç‹¬ç«‹ CREATE INDEX å¹¶å…¥å¯¹åº”è¡¨çš„ indexesï¼ˆC1ï¼‰', () => {
   const ddl = [
     'CREATE TABLE `t_order` ( `iId` int NOT NULL, `iCustomerId` int NOT NULL, PRIMARY KEY (`iId`) );',
@@ -498,27 +388,7 @@ test(&#39;parseDDL: ç‹¬ç«‹ CREATE INDEX å¤šåˆ—å½’ä¸€åŒ–ï¼ˆC1ï¼‰&#39;, () =&gt; {
   assert.ok(t.indexes.has('idx_tenant:INDEX:sBrandsId,sSubsidiaryId'), 'got: ' + [...t.indexes])
 })
  
-test('parseDDL: ç‹¬ç«‹ ALTER TABLE ADD CONSTRAINT FOREIGN KEY å¹¶å…¥å¯¹åº”è¡¨çš„ foreignKeysï¼ˆC1ï¼‰', () => {
-  const ddl = [
-    'CREATE TABLE `t_order` ( `iId` int NOT NULL, `iCustomerId` int NOT NULL );',
-    'ALTER TABLE `t_order` ADD CONSTRAINT `fk_cust` FOREIGN KEY (`iCustomerId`) REFERENCES `t_customer` (`iIncrement`) ON DELETE RESTRICT;',
-  ].join('\n')
-  const t = parseDDL(ddl).get('t_order')
-  assert.ok(t)
-  assert.ok(t.foreignKeys.has('iCustomerId->t_customer(iIncrement):RESTRICT'),
-    'ç‹¬ç«‹ ALTER ADD FK åº”å¹¶å…¥è¡¨å¤–é”®é›† â€” got: ' + [...t.foreignKeys])
-})
-
-test('parseDDL: ç‹¬ç«‹ ALTER TABLE ADD FOREIGN KEYï¼ˆæ—  CONSTRAINT åï¼‰é»˜è®¤ RESTRICTï¼ˆC1ï¼‰', () => {
-  const ddl = [
-    'CREATE TABLE `t` ( `uid` int );',
-    'ALTER TABLE `t` ADD FOREIGN KEY (`uid`) REFERENCES `users` (`id`);',
-  ].join('\n')
-  const t = parseDDL(ddl).get('t')
-  assert.ok(t.foreignKeys.has('uid->users(id):RESTRICT'), 'got: ' + [...t.foreignKeys])
-})
-
-test('full chain: A.1 å½¢æ€ DDLï¼ˆCREATE TABLE â†’ CREATE INDEX â†’ ALTER ADD FKï¼‰â†” docs/03 ä¸åº”æœ‰ diffï¼ˆC1 å¤´å·å›žå½’ï¼‰', () => {
+test('full chain: A.1 å½¢æ€ DDLï¼ˆCREATE TABLE â†’ CREATE INDEXï¼‰â†” docs/03 ä¸åº”æœ‰ diffï¼ˆC1 å¤´å·å›žå½’ï¼‰', () => {
   const docs = [
     '## `t_customer` â€” å®¢æˆ·è¡¨',
     '### å—æ®µ',
@@ -534,38 +404,18 @@ test(&#39;full chain: A.1 å½¢æ€ DDLï¼ˆCREATE TABLE â†’ CREATE INDEX â†’ ALTER ADD F
     '| `iCustomerId` | int |',
     '### ç´¢å¼•',
     '- `idx_cust` (INDEX): iCustomerId',
-    '### å¤–é”®',
-    '- `fk_cust`: iCustomerId â†’ t_customer.iIncrement (RESTRICT)',
     '',
   ].join('\n')
   const ddl = [
     'CREATE TABLE `t_customer` ( `iIncrement` int NOT NULL, PRIMARY KEY (`iIncrement`) );',
     'CREATE TABLE `t_order` ( `iId` int NOT NULL, `iCustomerId` int NOT NULL, PRIMARY KEY (`iId`) );',
     'CREATE INDEX `idx_cust` ON `t_order` (`iCustomerId`);',
-    'ALTER TABLE `t_order` ADD CONSTRAINT `fk_cust` FOREIGN KEY (`iCustomerId`) REFERENCES `t_customer` (`iIncrement`) ON DELETE RESTRICT;',
   ].join('\n')
   const d = diffSchema(parseDocsTables(docs), parseDDL(ddl))
   assert.deepEqual(d.indexMismatches, [], 'ç´¢å¼•ç»´åº¦åº”å¹²å‡€ â€” got: ' + JSON.stringify(d.indexMismatches))
-  assert.deepEqual(d.foreignKeyMismatches, [], 'å¤–é”®ç»´åº¦åº”å¹²å‡€ â€” got: ' + JSON.stringify(d.foreignKeyMismatches))
   assert.equal(d.hasDiff, false, 'A.1 å½¢æ€çš„å¿ å®ž schema ä¸åº”æŠ¥ diff')
 })
  
-test('full chain: ç‹¬ç«‹ ALTER ADD FK åœ¨ docs æœ‰è€Œ DDL ç¼ºæ—¶ä»è¢«æ•èŽ·ï¼ˆC1 ä¸æŽ©ç›–çœŸå®žç¼ºå¤±ï¼‰', () => {
-  const docs = [
-    '## `t_order`',
-    '### å—æ®µ',
-    '| åˆ— | ç±»åž‹ |',
-    '|---|---|',
-    '| `iCustomerId` | int |',
-    '### å¤–é”®',
-    '- `fk_cust`: iCustomerId â†’ t_customer.iIncrement (RESTRICT)',
-  ].join('\n')
-  const ddl = 'CREATE TABLE `t_order` ( `iCustomerId` int NOT NULL );' // FK çœŸçš„ç¼ºå¤±
-  const d = diffSchema(parseDocsTables(docs), parseDDL(ddl))
-  assert.ok(d.foreignKeyMismatches.some(m => m.side === 'docs' && m.foreignKey === 'iCustomerId->t_customer(iIncrement):RESTRICT'),
-    'çœŸå®žç¼ºå¤±çš„ FK ä»åº”æŠ¥ â€” got: ' + JSON.stringify(d.foreignKeyMismatches))
-})
-
 // â”€â”€ H3: åå¼•å·åŒ…è£¹çš„éž ASCII è¡¨åï¼ˆdocs ä¾§ [^`]+ æŽ¥å—ï¼ŒDDL ä¾§éœ€å¯¹é½ï¼‰â”€â”€â”€â”€â”€â”€
 test('parseDDL: åå¼•å·åŒ…è£¹çš„ä¸æ–‡è¡¨ååº”è¢«è§£æžï¼ˆH3 æ ‡è¯†ç¬¦è¯æ³•å¯¹é½ï¼‰', () => {
   const t = parseDDL('CREATE TABLE `è®¢å•è¡¨` ( `iIncrement` int NOT NULL, PRIMARY KEY (`iIncrement`) );')
@@ -580,15 +430,6 @@ test(&#39;full chain: docs ä¸Ž DDL åŒä¸ºä¸æ–‡è¡¨åæ—¶ä¸åº”è¯¯æŠ¥ missingTablesï¼
   assert.deepEqual(d.extraTables, [])
 })
  
-test('parseDDL: åå¼•å·åŒ…è£¹çš„ FK ç›®æ ‡è¡¨ä¸ºä¸æ–‡æ—¶å½’ä¸€åŒ–ä¿ç•™ä¸æ–‡ï¼ˆH3ï¼‰', () => {
-  const ddl = [
-    'CREATE TABLE `t` ( `uid` int );',
-    'ALTER TABLE `t` ADD FOREIGN KEY (`uid`) REFERENCES `ç”¨æˆ·è¡¨` (`id`);',
-  ].join('\n')
-  const t = parseDDL(ddl).get('t')
-  assert.ok(t.foreignKeys.has('uid->ç”¨æˆ·è¡¨(id):RESTRICT'), 'got: ' + [...t.foreignKeys])
-})
-
 // â”€â”€ DDL-9: ç´¢å¼•åˆ—å½’ä¸€åŒ–ä¸¤ä¾§å¯¹é½ï¼ˆå‰ç¼€é•¿åº¦ / æŽ’åºæ–¹å‘ï¼‰â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
 test('full chain: å‰ç¼€é•¿åº¦ç´¢å¼•åˆ— sName(20) docsâ†”DDL ä¸€è‡´æ—¶ä¸åº”è¯¯æŠ¥ï¼ˆDDL-9ï¼‰', () => {
   const docs = [
@@ -641,12 +482,12 @@ test(&#39;full chain: ç´¢å¼•åˆ— `sName(20) DESC` åº”å®Œå…¨å½’ä¸€åŒ–ä¸ºè£¸åˆ—åï¼Œä¸
   }
 })
  
-// REGEX-1 / EFFICACY-4 / PROSE-1ï¼šinline KEY å + inline FK ç›®æ ‡è¡¨ä¸ºä¸æ–‡æ—¶ä¹Ÿåº”ä¸Ž docs å¯¹é½ã€‚
-test('full chain: inline ä¸æ–‡ç´¢å¼•å + inline ä¸æ–‡ FK ç›®æ ‡è¡¨åº”ä¸Ž docs å¯¹é½ï¼ˆREGEX-1 / H3 ä¸€è‡´ï¼‰', () => {
+// REGEX-1 / EFFICACY-4 / PROSE-1ï¼šinline KEY åä¸ºä¸æ–‡æ—¶ä¹Ÿåº”ä¸Ž docs å¯¹é½ï¼›
+// åŒæ—¶è¡¨ä½“å†…çš„ inline FOREIGN KEY é¡¹åº”è¢«è·³è¿‡ã€ä¸æ±¡æŸ“ç´¢å¼•é›†ã€‚
+test('full chain: inline ä¸æ–‡ç´¢å¼•ååº”ä¸Ž docs å¯¹é½ï¼Œinline FK é¡¹è¢«è·³è¿‡ï¼ˆREGEX-1 / H3 ä¸€è‡´ï¼‰', () => {
   const docs = [
     '## `è®¢å•`', '### å—æ®µ', '| åˆ— | ç±»åž‹ |', '|---|---|', '| `user_id` | int |',
     '### ç´¢å¼•', '- `ä¸æ–‡ç´¢å¼•` (INDEX): user_id',
-    '### å¤–é”®', '- `fk_u`: user_id â†’ ç”¨æˆ·.id (RESTRICT)',
   ].join('\n')
   const ddl = [
     'CREATE TABLE `è®¢å•` (', '  `user_id` int,',
@@ -654,12 +495,15 @@ test(&#39;full chain: inline ä¸æ–‡ç´¢å¼•å + inline ä¸æ–‡ FK ç›®æ ‡è¡¨åº”ä¸Ž docs
     '  CONSTRAINT `fk_u` FOREIGN KEY (`user_id`) REFERENCES `ç”¨æˆ·` (`id`)',
     ') ENGINE=InnoDB;',
   ].join('\n')
+  const t = parseDDL(ddl).get('è®¢å•')
+  assert.ok(t)
+  assert.equal([...t.indexes].some(ix => /fk_u|ç”¨æˆ·|FOREIGN/i.test(ix)), false,
+    'inline FK é¡¹ä¸åº”æ±¡æŸ“ç´¢å¼•é›† â€” got: ' + [...t.indexes])
   const d = diffSchema(parseDocsTables(docs), parseDDL(ddl))
   assert.deepEqual(d.indexMismatches, [], 'inline ä¸æ–‡ç´¢å¼•ååº”å¯¹é½ â€” got: ' + JSON.stringify(d.indexMismatches))
-  assert.deepEqual(d.foreignKeyMismatches, [], 'inline ä¸æ–‡ FK ç›®æ ‡è¡¨åº”å¯¹é½ â€” got: ' + JSON.stringify(d.foreignKeyMismatches))
 })
  
-// REGEX-3ï¼šå—ç¬¦ä¸²å—é¢é‡é‡Œçš„ CREATE INDEX / ALTER ADD FK ä¸åº”è¢«ç‹¬ç«‹è¯å¥æ‰«æè¯¯å½“çœŸå®žå®šä¹‰ã€‚
+// REGEX-3ï¼šå—ç¬¦ä¸²å—é¢é‡é‡Œçš„ CREATE INDEX ä¸åº”è¢«ç‹¬ç«‹è¯å¥æ‰«æè¯¯å½“çœŸå®žå®šä¹‰ã€‚
 test('parseDDL: å—ç¬¦ä¸²å—é¢é‡ä¸çš„ CREATE INDEX æ–‡æœ¬ä¸åº”æ³¨å…¥å¹½çµç´¢å¼•ï¼ˆREGEX-3ï¼‰', () => {
   const ddl = "CREATE TABLE `t_order` ( `iId` int NOT NULL, `note` varchar(200) DEFAULT 'CREATE INDEX `ghost` ON `t_order` (`iId`)', PRIMARY KEY (`iId`) );"
   const t = parseDDL(ddl).get('t_order')
@@ -667,26 +511,7 @@ test(&#39;parseDDL: å—ç¬¦ä¸²å—é¢é‡ä¸çš„ CREATE INDEX æ–‡æœ¬ä¸åº”æ³¨å…¥å¹½çµç´
   assert.equal([...t.indexes].some(ix => ix.includes('ghost')), false, 'å—é¢é‡å†…çš„ CREATE INDEX ä¸åº”æˆä¸ºçœŸå®žç´¢å¼• â€” got: ' + [...t.indexes])
 })
  
-test('parseDDL: å—ç¬¦ä¸²å—é¢é‡ä¸çš„ ALTER ADD FK æ–‡æœ¬ä¸åº”æ³¨å…¥å¹½çµå¤–é”®ï¼ˆREGEX-3ï¼‰', () => {
-  const ddl = "CREATE TABLE `t` ( `c` int, `doc` varchar(300) DEFAULT 'see ALTER TABLE `t` ADD FOREIGN KEY (`c`) REFERENCES `x` (`id`)' );"
-  const t = parseDDL(ddl).get('t')
-  assert.ok(t)
-  assert.equal(t.foreignKeys.size, 0, 'å—é¢é‡å†…çš„ ALTER ADD FK ä¸åº”æˆä¸ºçœŸå®žå¤–é”® â€” got: ' + [...t.foreignKeys])
-})
-
-// REGEX-4ï¼šä¸€æ¡ ALTER TABLE å†…å¤šä¸ªé€—å·åˆ†éš” ADD FK éƒ½åº”è¢«æ•èŽ·ï¼›CREATE INDEX çš„ USING åå¥åº”å®¹å¿ã€‚
-test('parseDDL: å•æ¡ ALTER å†…å¤šä¸ª ADD FOREIGN KEY éƒ½åº”è¢«æ•èŽ·ï¼ˆREGEX-4 multi-ADDï¼‰', () => {
-  const ddl = [
-    'CREATE TABLE `t_order` ( `a` int, `b` int );',
-    'CREATE TABLE `t_a` ( `id` int );',
-    'CREATE TABLE `t_b` ( `id` int );',
-    'ALTER TABLE `t_order` ADD CONSTRAINT `fk_a` FOREIGN KEY (`a`) REFERENCES `t_a` (`id`) ON DELETE CASCADE, ADD CONSTRAINT `fk_b` FOREIGN KEY (`b`) REFERENCES `t_b` (`id`);',
-  ].join('\n')
-  const t = parseDDL(ddl).get('t_order')
-  assert.ok(t.foreignKeys.has('a->t_a(id):CASCADE'), 'ç¬¬ä¸€ä¸ª FK â€” got: ' + [...t.foreignKeys])
-  assert.ok(t.foreignKeys.has('b->t_b(id):RESTRICT'), 'åŒæ¡ ALTER çš„ç¬¬äºŒä¸ª FK â€” got: ' + [...t.foreignKeys])
-})
-
+// REGEX-4ï¼šCREATE INDEX çš„ USING åå¥åº”å®¹å¿ã€‚
 test('parseDDL: CREATE INDEX ... USING BTREE ON ... åº”è¢«è§£æžï¼ˆREGEX-4 USINGï¼‰', () => {
   const ddl = ['CREATE TABLE `t` ( `c` int );', 'CREATE INDEX `idx_c` USING BTREE ON `t` (`c`);'].join('\n')
   const t = parseDDL(ddl).get('t')
@@ -18,26 +18,29 @@ allowed-tools: Read Write Edit Grep Glob
 读：
  
 - `docs/04-技术规范.md`
+- `docs/06-实现策略.md`（A2 人工填写的实现策略；若含影响数据模型的关键决策 / 对默认约定的偏离，步骤 B 据此调整）
 - `docs/01-需求清单/index.md` 模块索引
 - `docs/01-需求清单/*/*.md` 所有 REQ 卡片（跳过文件名为 `_module.md` 的模块头；卡片文件名 == req_id）
  
 ### B. 推导 schema
  
-基于步骤 A 读到的 REQ + 命名规范，**正向推导**业务实体 → 表 + 字段 + 索引 + 外键。要求：
+基于步骤 A 读到的 REQ + 命名规范，**正向推导**业务实体 → 表 + 字段 + 索引 + 语义引用关系。要求：
  
 1. 严格套用 `docs/04` 命名规范 + 匈牙利列前缀（`i`=int / `s`=varchar / `t`=datetime）
 2. **主键**：标准列 `iIncrement` int 主键。REQ 明确要求不同主键（复合主键 / UUID / 业务主键）时按 REQ，并在该表业务注记里注明偏离原因
-3. **外键**：依据 REQ 中的引用关系（如「订单引用客户」），明确列出 `ON DELETE` / `ON UPDATE` 策略；不能确定时默认 `RESTRICT`
-4. **索引**：根据 REQ 的查询模式推导业务索引；外键列默认建索引；租户隔离列 `sBrandsId` / `sSubsidiaryId`（标准列）按业务查询模式建组合索引。
+3. **语义引用关系**：依据 REQ 中的引用关系（如「订单引用客户」），列出 `from→to`（如 `sCustomerId → 客户表.sId`）；仅语义、不建 FK 约束、不写 `ON DELETE` / `ON UPDATE`，应用层维护一致性
+4. **索引**：根据 REQ 的查询模式推导业务索引；语义引用列默认建索引；租户隔离列 `sBrandsId` / `sSubsidiaryId`（标准列）按业务查询模式建组合索引。
    - 索引 bullet 的 `(类别)` 槽位**统一用 ASCII**：唯一索引写 `UNIQUE`、普通/组合索引写 `INDEX`（与 DDL 侧 `UNIQUE KEY` / `KEY` 对齐，validate-ddl 据此比对 UNIQUE\|INDEX 类别）；主键不在 `### 索引` 重复列（由标准列 `iIncrement` 治理）。
 5. **业务注记**：对每张表用一两句话说明业务用途、关键约束、与其他表的关系
  
+> 若 `docs/06-实现策略.md` 载有影响数据模型的关键决策 / 对默认约定的偏离（如软删除标志、乐观锁版本列、特殊主键策略、多租户隔离方式等），**优先遵循**，并在对应表「业务注记」注明依据。
+
 如果某 REQ 表述模糊以致无法推断关键 schema 细节（如：枚举值范围 / 字段长度上限 / 必填性），先按合理默认推导并在该字段「业务含义」列加 `【人工填写：需用户审阅】` 标注，待步骤 E 用户审阅时调整；**不打断本次推导**。
  
 ### C. 渲染 docs/03
  
-1. 读取 `${CLAUDE_SKILL_DIR}/templates/docs-03-header-template.md`，填充 `schema_name`（从 `config-vars.yaml` 读 `database.schema`，无则填 `【人工填写：database.schema】`）、`er_overview`（纯文本 ER 概览）。「项目标准列约定」是固定 5 列，无占位、原样保留。
-2. 渲染「表清单」：对每张表读取并填充 `${CLAUDE_SKILL_DIR}/templates/docs-03-table-template.md`——标准列 5 行已内置原样输出，只需填业务字段（`{{#each columns}}`）/ 索引 / 外键 / 业务注记。
+1. 读取 `${CLAUDE_SKILL_DIR}/templates/docs-03-header-template.md`，填充 `schema_name`（从 `config-vars.yaml` 读 `database.schema`，无则填 `【人工填写：database.schema】`）、`er_overview`（纯文本 ER 概览）。「项目标准列约定」是固定 7 列（主表）/ 8 列（从表，额外含 `sParentId`），无占位、原样保留。
+2. 渲染「表清单」：对每张表读取并填充 `${CLAUDE_SKILL_DIR}/templates/docs-03-table-template.md`——标准列已内置原样输出，只需填业务字段（`{{#each columns}}`）/ 索引 / 引用关系 / 业务注记。标准列按表位区分：**主表**（docs/03 表清单第一张表）输出 7 行标准列（`iIncrement` / `sId` / `sBrandsId` / `sSubsidiaryId` / `tCreateDate` / `iOrder` / `sMemo`）；**从表**（第二张起的其余表）输出 8 行，额外加入 `sParentId`（varchar(50) NOT NULL，业务父级ID）且**位置紧随 `sId` 之后**。其中 `sId` / `sBrandsId` / `sSubsidiaryId` / `sParentId` 均为 varchar(50) NOT NULL；`sBrandsId` / `sSubsidiaryId` 默认 `1111111111`；`tCreateDate` 默认当前时间；`iOrder`（int NOT NULL，排序号）默认为数据行条数+1，由应用在 insert 时算 count+1 赋值（非 SQL 默认）；`sMemo`（LONGTEXT，可空）备注。这些列的『当前时间 → CURRENT_TIMESTAMP』『1111111111 → DEFAULT '1111111111'』『iOrder 不写 SQL 默认』等 DDL 默认值翻译由下游 A.1 db-init 处理，docs/03 只记录业务语义。
 3. 写入 `docs/03-数据库设计文档.md`。
  
 勾选：`  - [ ] docs/03-数据库设计文档.md 已生成`
@@ -59,7 +62,7 @@ allowed-tools: Read Write Edit Grep Glob
    ```
    [db-design-gen] ✅ A3 DB 设计完成
    产出：docs/03-数据库设计文档.md + REQ 卡片依赖表/模块头涉及表已回填
-   ⏸ 请审阅 docs/03（业务实体覆盖、字段类型/默认值、索引、外键策略、`【人工填写：需用户审阅】` 标注）。
+   ⏸ 请审阅 docs/03（业务实体覆盖、字段类型/默认值、索引、语义引用关系、`【人工填写：需用户审阅】` 标注）。
    审阅完成后运行：/erp-workflow:plan-start
    ```
  
@@ -6,15 +6,25 @@
  
 ## 项目标准列约定
  
-下文每张业务表的字段清单都自动包含以下 5 个标准列（匈牙利前缀 `i` int / `s` varchar / `t` datetime）。渲染时由 `docs-03-table-template.md` 模板内置原样输出。
-
-| 列名 | 类型 | 可空 | 主键 | 说明 |
-|---|---|---|---|---|
-| `iIncrement` | int | 否 | 是 | 整数主键 ID（自增方式由实现决定：DB `AUTO_INCREMENT` 或应用 / 触发器分配） |
-| `sId` | varchar(100) | 是 | — | 业务 ID（对外暴露的字符串标识，如 UUID / 人类可读编号） |
-| `sBrandsId` | varchar(100) | 是 | — | 品牌 ID（多租户隔离） |
-| `sSubsidiaryId` | varchar(100) | 是 | — | 子公司 ID（组织层级隔离） |
-| `tCreateDate` | datetime | 否 | — | 记录创建时间 |
+下文每张业务表的字段清单都自动包含以下 7 个标准列（匈牙利前缀 `i` int / `s` varchar / `t` datetime）；**从表（本文档「表清单」里除第一张主表之外的所有表）额外再加 1 个标准列 `sParentId`，共 8 个标准列**。渲染时由 `docs-03-table-template.md` 模板内置原样输出。
+
+主表 = 「表清单」中的**第一张表**；从表 = 其余各表。
+
+| 列名 | 类型 | 可空 | 主键 | 默认 | 说明 |
+|---|---|---|---|---|---|
+| `iIncrement` | int | 否 | 是 | — | 整数主键 ID（标准列）；DDL 译为 `PRIMARY KEY` + `AUTO_INCREMENT` |
+| `sId` | varchar(50) | 否 | — | — | 业务 ID（标准列，对外暴露的字符串标识，如 UUID / 人类可读编号） |
+| `sBrandsId` | varchar(50) | 否 | — | `1111111111` | 品牌 ID（多租户隔离，标准列）；DDL 译为 `DEFAULT '1111111111'` |
+| `sSubsidiaryId` | varchar(50) | 否 | — | `1111111111` | 子公司 ID（组织层级隔离，标准列）；DDL 译为 `DEFAULT '1111111111'` |
+| `tCreateDate` | datetime | 否 | — | 当前时间 | 记录创建时间（标准列）；DDL 译为 `DEFAULT CURRENT_TIMESTAMP` |
+| `iOrder` | int | 否 | — | 数据行条数+1 | 排序号；**非 SQL 默认**——应用在 insert 时按 count+1 赋值，DDL 仅写 `int NOT NULL`（不写 DEFAULT 表达式，在该列 COMMENT / 表业务注记里注明 app-assigned） |
+| `sMemo` | LONGTEXT | 是 | — | — | 备注（标准列） |
+
+**从表专属标准列**（从「表清单」第二张表起，即除第一张主表外的所有表都加，插入位置紧随 `sId` 之后）：
+
+| 列名 | 类型 | 可空 | 主键 | 默认 | 说明 |
+|---|---|---|---|---|---|
+| `sParentId` | varchar(50) | 否 | — | — | 业务父级 ID（标准列）；仅从表有，紧随 `sId` 之后 |
  
 字典 / 辅助表如有豁免，在该表业务注记里注明豁免原因。
  
@@ -5,10 +5,12 @@
 | 字段 | 类型 | Nullable | 默认 | 业务含义 |
 |---|---|---|---|---|
 | `iIncrement` | int | 否 | — | 整数主键 ID（标准列） |
-| `sId` | varchar(100) | 是 | — | 业务 ID（标准列） |
-| `sBrandsId` | varchar(100) | 是 | `1111111111` | 品牌 ID，多租户隔离（标准列） |
-| `sSubsidiaryId` | varchar(100) | 是 | `1111111111` | 子公司 ID，组织层级隔离（标准列） |
+| `sId` | varchar(50) | 否 | — | 业务 ID（标准列） |
+| `sBrandsId` | varchar(50) | 否 | `1111111111` | 品牌 ID，多租户隔离（标准列） |
+| `sSubsidiaryId` | varchar(50) | 否 | `1111111111` | 子公司 ID，组织层级隔离（标准列） |
 | `tCreateDate` | datetime | 否 | 当前时间 | 创建时间（标准列） |
+| `iOrder` | int | 否 | 数据行条数+1 | 排序号（标准列） |
+| `sMemo` | LONGTEXT | 是 | — | 备注（标准列） |
 {{#each columns}}
 | {{name}} | {{type}} | {{nullable}} | {{default}} | {{business_meaning}} |
 {{/each}}
@@ -18,9 +20,9 @@
 - `{{name}}` ({{type}}): {{columns}}
 {{/each}}
  
-### 外键
-{{#each foreign_keys}}
-- `{{name}}`: {{from_col}} → {{to_table}}.{{to_col}} ({{on_delete}})
+### 引用关系（语义，无 FK 约束）
+{{#each references}}
+- {{from_col}} → {{to_table}}.{{to_col}}（语义引用，应用维护一致性）
 {{/each}}
  
 ### 业务注记
 ---
 name: db-init
-description: A4 DB 初始化——LLM 解析 docs/03-数据库设计文档.md → 生成 sql/migrations/V1__initial_schema.sql（DDL only，Flyway 初始 migration）→ 用 lib/validate-ddl.mjs 做 5 维校验（表/列/类型/索引/外键）DDL ↔ docs/03 一致性 → 调 scripts/setup-test-db.mjs DROP+CREATE 空库 → 用 lib/apply-ddl.mjs apply V1。
+description: A4 DB 初始化——LLM 解析 docs/03-数据库设计文档.md → 生成 sql/migrations/V1__initial_schema.sql（DDL only，Flyway 初始 migration）→ 用 lib/validate-ddl.mjs 做 4 维校验（表/列/类型/索引）DDL ↔ docs/03 一致性 → 调 scripts/setup-test-db.mjs DROP+CREATE 空库 → 用 lib/apply-ddl.mjs apply V1。
 user-invocable: false
 allowed-tools: Read Write Edit Skill Bash(node *) Bash(npm i mysql2) Bash(npm install mysql2)
 ---
@@ -17,11 +17,18 @@ allowed-tools: Read Write Edit Skill Bash(node *) Bash(npm i mysql2) Bash(npm in
  
 #### A.1 读 docs/03 并翻译为 DDL
  
-读取 `docs/03-数据库设计文档.md`，对每张表生成一段 `CREATE TABLE`（字段顺序/可空/默认/列注释严格对齐 docs/03 行序），随后按顺序追加 `CREATE INDEX` 与统一追加的 `ALTER TABLE ... ADD CONSTRAINT ... FOREIGN KEY`。**严禁臆造或省略** docs/03 中的任何表/字段/索引/外键/约束。字符集 `utf8mb4` + `utf8mb4_unicode_ci`、引擎 `InnoDB`，除非 docs/03 业务注记另有说明。
+读取 `docs/03-数据库设计文档.md`，对每张表生成一段 `CREATE TABLE`（字段顺序/可空/默认/列注释严格对齐 docs/03 行序），随后按顺序追加 `CREATE INDEX`（含语义引用列上的索引）。**不生成任何 `ALTER TABLE ... ADD FOREIGN KEY` 或内联 `FOREIGN KEY` 约束**——表间关系靠语义判断（列命名约定 + 应用层一致性）维护，docs/03 的引用关系仅作语义记录。**严禁臆造或省略** docs/03 中的任何表/字段/索引。字符集 `utf8mb4` + `utf8mb4_unicode_ci`、引擎 `InnoDB`，除非 docs/03 业务注记另有说明。
+
+> **标准列默认值的 DDL 翻译规则**（docs/03「默认」列是人话，翻进 DDL 时按下表落成 SQL，仍以 docs/03 行内容为准，不臆造）：
+> - `iIncrement`（整数主键）→ `PRIMARY KEY` + `AUTO_INCREMENT`。
+> - `tCreateDate`「当前时间」→ `DEFAULT CURRENT_TIMESTAMP`。
+> - `sBrandsId` / `sSubsidiaryId`「1111111111」→ `DEFAULT '1111111111'`。
+> - `iOrder`「数据行条数+1」→ **不可作为 SQL DEFAULT**（MySQL 无法 default 成 count+1），DDL 只写 `int NOT NULL`，count+1 由应用在 insert 时算好赋值（在该列 `COMMENT` 或表业务注记里注明 app-assigned）。
+> - `sId` / `sParentId`（从表才有，紧随 `sId`）/ `sMemo` → 无 `DEFAULT`（`sMemo` 可空 `LONGTEXT`，其余 `NOT NULL`）。
  
 #### A.2 落盘 V1 文件
  
-用 `Write` 写 `sql/migrations/V1__initial_schema.sql`（`Write` 自动创建父目录）。文件开头是以下 6 行注释，其后接 A.1 的 DDL 主体（`CREATE TABLE` → `CREATE INDEX` → `ALTER TABLE ... ADD FOREIGN KEY`）：
+用 `Write` 写 `sql/migrations/V1__initial_schema.sql`（`Write` 自动创建父目录）。文件开头是以下 6 行注释，其后接 A.1 的 DDL 主体（`CREATE TABLE` → `CREATE INDEX`）：
  
 ```sql
 -- Flyway migration V1 — initial schema for <project_name>   -- 从 CLAUDE.md § 🎯 项目概述 读
@@ -32,11 +39,11 @@ allowed-tools: Read Write Edit Skill Bash(node *) Bash(npm i mysql2) Bash(npm in
 -- Do not hand-edit this file after it is committed; write a new migration instead.
 ```
  
-#### A.3 校验 V1 ↔ docs/03 5 维一致性 + 自主修正
+#### A.3 校验 V1 ↔ docs/03 4 维一致性 + 自主修正
  
-调 `${CLAUDE_PLUGIN_ROOT}/lib/validate-ddl.mjs` 做跨平台、纯 Node 的 5 维校验（表集合 / 列名 / 列类型 / 索引 / 外键）。**注意参数顺序：docs/03 在前，V1.sql 在后。**
+调 `${CLAUDE_PLUGIN_ROOT}/lib/validate-ddl.mjs` 做跨平台、纯 Node 的 4 维校验（表集合 / 列名 / 列类型 / 索引）。**注意参数顺序：docs/03 在前，V1.sql 在后。**
  
-> **机检边界（勿误解）**：5 维 = 表集合 / 列名 / 列类型 / 索引（名 + UNIQUE\|INDEX 类别 + 列）/ 外键（列 → 表(列) + ON DELETE）；表体内联与独立 `CREATE INDEX` / `ALTER TABLE ... ADD FOREIGN KEY` 两种形态都识别。**A.1 要求的「字段顺序 / 可空 / 默认 / 列注释对齐」不在机检范围内**——这几项靠 A.1 翻译时忠实对齐 docs/03（docs/03 已在 A3 人工审阅过），validate-ddl 不会代为兜底，勿因校验通过就认定它们也一致。
+> **机检边界（勿误解）**：4 维 = 表集合 / 列名 / 列类型 / 索引（名 + UNIQUE\|INDEX 类别 + 列）；表体内联与独立 `CREATE INDEX` 两种形态都识别。**A.1 要求的「字段顺序 / 可空 / 默认 / 列注释对齐」不在机检范围内**——这几项靠 A.1 翻译时忠实对齐 docs/03（docs/03 已在 A3 人工审阅过），validate-ddl 不会代为兜底，勿因校验通过就认定它们也一致。
  
 ```bash
 node "${CLAUDE_PLUGIN_ROOT}/lib/validate-ddl.mjs" \
@@ -46,7 +53,7 @@ node &quot;${CLAUDE_PLUGIN_ROOT}/lib/validate-ddl.mjs&quot; \
  
 退出码与处理：
 - `0` → 通过，进入步骤 B
-- `1` → 存在差异（5 维 diff 明细打印到 stderr）。进入**自主修正循环**（最多 3 轮，docs/03 是 SSoT 不动）：
+- `1` → 存在差异（4 维 diff 明细打印到 stderr）。进入**自主修正循环**（最多 3 轮，docs/03 是 SSoT 不动）：
    1. 解析 stderr 差异清单，修正 V1.sql
    2. 重跑 `validate-ddl.mjs`
    3. 退出 0 → 进入 B；退出 1 且本轮 < 3 → 回步骤 1；本轮 ≥ 3 仍失败 → 停下，打印最终残留差异 + 已尝试的 3 轮修正摘要，让用户介入
@@ -54,7 +61,7 @@ node &quot;${CLAUDE_PLUGIN_ROOT}/lib/validate-ddl.mjs&quot; \
  
 完成后（V1 写入并通过 `validate-ddl.mjs` 校验），勾选：
 - `  - [ ] sql/migrations/V1__initial_schema.sql 已生成`
-- `  - [ ] DDL ↔ docs/03 5 维一致（validate-ddl.mjs）`
+- `  - [ ] DDL ↔ docs/03 4 维一致（validate-ddl.mjs）`
  
 ### B. 自动导入 MySQL
  
@@ -95,14 +102,14 @@ node scripts/setup-test-db.mjs
  
 ### C. 勾选 docs/08 进度 + 进入 A5
  
-1. 勾选 A4 顶层（5 维一致已由 A.3 的 `validate-ddl.mjs` 校验过，apply 不改 V1，无需复校）：
+1. 勾选 A4 顶层（4 维一致已由 A.3 的 `validate-ddl.mjs` 校验过，apply 不改 V1，无需复校）：
    - `- [ ] A4 DB 初始化 — db-init`
  
 2. 立即调用 `Skill(downstream-gen)` 进入 A5，不等用户手动输入。
  
 ## 参考
  
-- `${CLAUDE_PLUGIN_ROOT}/lib/validate-ddl.mjs`（A.3 docs/03 ↔ V1.sql 5 维一致性校验，跨平台纯 Node）
+- `${CLAUDE_PLUGIN_ROOT}/lib/validate-ddl.mjs`（A.3 docs/03 ↔ V1.sql 4 维一致性校验，跨平台纯 Node）
 - `${CLAUDE_PLUGIN_ROOT}/lib/apply-ddl.mjs`（B.2 读取 config-vars.yaml 的 database: 段 + mysql2 灌入 DDL）
 - `${CLAUDE_PLUGIN_ROOT}/lib/yaml-config.mjs`（apply-ddl 依赖的极简 YAML 读取）
 - `docs/03-数据库设计文档.md`（DDL 翻译输入，SSoT）
@@ -27,7 +27,7 @@
  
 - [ ] A4 DB 初始化 — db-init
   - [ ] sql/migrations/V1__initial_schema.sql 已生成
-  - [ ] DDL ↔ docs/03 5 维一致（validate-ddl.mjs）
+  - [ ] DDL ↔ docs/03 4 维一致（validate-ddl.mjs）
   - [ ] setup-test-db.mjs DROP+CREATE + apply V1 已执行
  
 - [ ] A5 下游文档生成 — downstream-gen
@@ -590,7 +590,7 @@ function seedStageContract() {
     '## 硬约束（非交互演示种子子代理）',
     '- 你是 Workflow 派生的**非交互子代理**，物理上无法弹出 AskUserQuestion / 等待人类输入。**绝不要尝试问人**。',
     '- 你的职责 = **为本模块生成演示种子（demo seed）并冷起栈真跑验证**——**不是**实现功能、**不是**改源码、**不是**改 schema。',
-    '- 缺值查找顺序：`config-vars.yaml` → `docs/03-数据库设计文档.md` → `docs/01-需求清单/` 各 REQ 卡（业务语义）→ 既有 `sql/seed/*`（跨模块 FK 引用前序模块种子的已知主键）→ 现有代码。仍查不到时**优先自主决策继续**，把决策写进证据报告显著位置并登记到返回 `decisions[]`（`{question,choice,rationale,confidence}`）。',
+    '- 缺值查找顺序：`config-vars.yaml` → `docs/03-数据库设计文档.md` → `docs/01-需求清单/` 各 REQ 卡（业务语义）→ 既有 `sql/seed/*`（跨模块语义引用前序模块种子的已知主键）→ 现有代码。仍查不到时**优先自主决策继续**，把决策写进证据报告显著位置并登记到返回 `decisions[]`（`{question,choice,rationale,confidence}`）。',
     `- **作用域例外（关键）**：本门为跨栈验证，明确允许**运行**（不修改）以下——\`node ${ROOT}/scripts/setup-test-db.mjs\`（DROP+CREATE 空库）、起后端服务（gradle bootRun 等，Flyway 在此建 schema）、\`node ${ROOT}/scripts/seed-demo-data.mjs\`（注入种子）、mysql **只读** COUNT/查询；唯一允许**写入**的路径是 \`${ROOT}/sql/seed/\`（种子文件，随 git 提交）+ \`${ROOT}/.tmp/seed-gen/<module_id>/\`（一次性 runner，跑完即弃）+ 证据报告 \`${ROOT}/docs/superpowers/module-reports/<module_id>-seed-verify.md\`。`,
     `- **越界硬停**：**绝不**编辑 \`backend/\` / \`frontend/\` / \`scripts/\` 下的任何源码文件（只许**运行** scripts/setup-test-db.mjs 与 scripts/seed-demo-data.mjs，不许改它们）。区分「运行 backend 服务 / 运行脚本」（允许）与「写 backend 实现 / 改脚本」（越界）。命中越界即以 \`status:halt\` 写清阻塞点结束。`,
     '- **确定性红线（关键）**：种子值一律**显式主键**（1000–9999 区间）+ **固定历史日期**（写死字面量，如 `2024-03-15`），**绝不**依赖时间戳 / `NOW()` / 随机数 / 自增主键的隐式取值。',
@@ -616,9 +616,9 @@ function seedGenPrompt(module) {
     '种子产物随 git 提交（不保证「存活」，保证「随时可复现」——三处 DROP+CREATE 各在自己时序里固定重注入）。',
     '',
     '## 输入',
-    `- \`${ROOT}/docs/03-数据库设计文档.md\`：本模块各表结构（列 / 类型 / enum 值域 / FK / NOT NULL / UNIQUE 约束）。`,
+    `- \`${ROOT}/docs/03-数据库设计文档.md\`：本模块各表结构（列 / 类型 / enum 值域 / 语义引用关系 / NOT NULL / UNIQUE 约束）。`,
     `- \`${ROOT}/docs/01-需求清单/<module>/\` 本模块 REQ 卡：业务语义（让假数据有真实感、符合业务取值）。`,
-    `- 既有 \`${ROOT}/sql/seed/*.sql\`：跨模块 FK 引用前序模块种子的**已知确定性主键**（你的 FK 列必须引用这些已存在的主键，不可悬空）。`,
+    `- 既有 \`${ROOT}/sql/seed/*.sql\`：跨模块语义引用前序模块种子的**已知确定性主键**（你的语义引用列必须指向这些已存在的主键，不可悬空）。`,
     `- \`${ROOT}/config-vars.yaml\`：database 段凭据（seed-demo-data.mjs / setup-test-db.mjs 自行读取，你只需确保起栈参数一致）。`,
     '',
     '## 幂等（resume 安全）',
@@ -626,12 +626,12 @@ function seedGenPrompt(module) {
     `- **不存在** → 新建 \`sql/seed/<NN>__${id}.sql\`，其中 \`NN\` = 既有 \`sql/seed/*.sql\` 文件名最大序号 + 1（两位补零，如既有最大为 \`03\` → 本文件用 \`04\`；无任何既有文件 → \`01\`）。`,
     '',
     '## 生成规则',
-    '- **FK 有序**：同一文件内 INSERT 先父后子；跨模块 FK 列引用既有 `sql/seed/*` 中前序模块种子的已知主键。',
+    '- **按语义引用有序（先被引用方后引用方）**：同一文件内 INSERT 先被引用方后引用方；跨模块语义引用列指向既有 `sql/seed/*` 中前序模块种子的已知主键。',
     '- **显式主键**：本模块种子行主键固定落 **1000–9999** 区间（避开 1–999 初始数据 / ≥100000 sentinel）；同表内主键唯一、确定性。',
     '- **真实感中文业务数据**：依 REQ 卡业务语义取值（人名 / 机构 / 金额 / 状态等），不要 `测试1`/`aaa` 占位；但**绝不含 `_S<数字>` 样式编码**（预留 sentinel）。',
     '- **enum 取值域**：enum 列只从 `docs/03` 声明的值域取值（越界即数据类失败）。',
     '- **固定历史日期**：日期/时间列写死固定历史字面量（如 `2024-03-15 10:00:00`），绝不 `NOW()` / 时间戳。',
-    '- **行数**：主业务列表表（页面会分页展示的）给 **15–30 行**（够触发分页 + 行级操作）；字典/配置类小表按需少量（够 FK 引用 + 下拉非空）。',
+    '- **行数**：主业务列表表（页面会分页展示的）给 **15–30 行**（够触发分页 + 行级操作）；字典/配置类小表按需少量（够语义引用 + 下拉非空）。',
     `- **头部注释（机器可读，验证对账依赖）**：文件头第一行 \`-- demo-seed: ${id}\`；随后**每张被本文件 INSERT 的表各一行** \`-- expect: <table>=<rows>\`（rows = 本文件向该表插入的行数）。`,
     `- **本模块无可种表**（纯计算/无表模块）→ **不建文件**，直接 \`status:ok\` + summary 说明「模块 ${id} 无可种表，跳过」（跳过下面的验证与 commit）。`,
     '',
@@ -645,7 +645,7 @@ function seedGenPrompt(module) {
     '  - `finally` **硬要求 kill 本 stage 起的全部子进程**（绝不让 gradle bootRun 挂死会话）。',
     '- **失败归类（reason 里必须分清）**：',
     '  - **环境类**（端口占用 / 起栈超时 / setup-test-db 失败 / 健康端点不就绪）→ reason 标 `env-error` + 端口/pid。',
-    '  - **数据类**（撞主键/唯一键 / FK 错序或悬空 / enum 越界 / 类型截断 / COUNT 不符）→ reason 标 `data-error` + 具体表与根因（这是种子本身的 bug，必须修种子文件后重验）。',
+    '  - **数据类**（撞主键/唯一键 / 引用错序或悬空 / enum 越界 / 类型截断 / COUNT 不符）→ reason 标 `data-error` + 具体表与根因（这是种子本身的 bug，必须修种子文件后重验）。',
     '',
     '## 证据落盘',
     `- 写 \`${evidence}\`（中文）：逐表「期望行数 / 实际行数 / 结论（match/mismatch）」表格 + 本模块种子文件路径 + 起栈端口 + 关键决策。`,
@@ -734,8 +734,8 @@ function behaviorGatePrompt(feItems, behaviorRound, attempt) {
     '## step2 起栈五段严格时序（schema 由 Flyway 在后端启动时才建）',
     `1) \`node ${ROOT}/scripts/setup-test-db.mjs\`（DROP+CREATE 空库）。DROP 前按 \`${tmpDir}/*.pid\` / 既知端口优雅回收残留进程；脚本失败按普通 \`stack-not-ready\` 处理。`,
     '2) **起后端**：spawn 到后台 + 轮询 `/actuator/health` 或登录端点 200（Flyway 在此 apply 建 schema）；端口取 config-vars，先探测占用，占用则回收残留或退到动态空闲端口 + 把 baseURL 注入下游。',
-    `3) **注入演示种子**：\`node ${ROOT}/scripts/seed-demo-data.mjs\`（幂等账本 \`_demo_seed_history\` 自动跳过已应用文件，把 \`sql/seed/*.sql\` 演示数据注入空库）。失败 → \`envError.kind="seed-error"\` + 结构化根因（缺列 / 撞唯一键 / enum 越界 / FK 序错 / 类型截断 / schema 未初始化），**不**混进交互 RED。`,
-    '4) **此时才跑 sentinel 种子**：按 `docs/03-数据库设计文档.md` 派生 **FK 有序 INSERT** sentinel 种子（先父后子；专司绑定断言——「保列表非空触发行级操作」已由本 step2 子项 3) 注入的演示种子承担）。失败 → `envError.kind="seed-error"` + 结构化根因，**不**混进交互 RED。',
+    `3) **注入演示种子**：\`node ${ROOT}/scripts/seed-demo-data.mjs\`（幂等账本 \`_demo_seed_history\` 自动跳过已应用文件，把 \`sql/seed/*.sql\` 演示数据注入空库）。失败 → \`envError.kind="seed-error"\` + 结构化根因（缺列 / 撞唯一键 / enum 越界 / 引用序错 / 类型截断 / schema 未初始化），**不**混进交互 RED。`,
+    '4) **此时才跑 sentinel 种子**：按 `docs/03-数据库设计文档.md` 派生 **按语义引用有序的 INSERT** sentinel 种子（先被引用方后引用方；专司绑定断言——「保列表非空触发行级操作」已由本 step2 子项 3) 注入的演示种子承担）。失败 → `envError.kind="seed-error"` + 结构化根因，**不**混进交互 RED。',
     '   - **sentinel 规则**：按列类型派生类型合法且可辨识的值——数值主键**一律 ≥100000**（固定区间，不再动态扫描既有键：初始数据 1–999 / 演示种子 1000–9999 已由区间约定隔离，sentinel 落 ≥100000 天然不冲突）；字符串列**仍逐字段唯一编码**（`_S<NNN>` 样式，如 `CUST_NAME_S001`，抓绑错字段——演示数据已被禁用该样式，故 sentinel 独占）+ 行序号保 UNIQUE；enum 列从 docs/03 值域取并标注。断言按 sentinel 行已知主键定位。所有 SQL 值参数化 / 白名单转义，sentinel 用受控 `[A-Za-z0-9_]` 格式。',
     '5) **起前端 headless**：spawn + 轮询 ready；端口同样探测 + 动态回退。',
     '- `finally` **硬要求 kill 本门起的全部子进程**；端口 + pid 写入 `envError.ports` / `envError.pids`（即便成功也回填，便于审计）。反复 port-conflict 设独立硬上限直接 halt 提示人工清理（不连环 retry 烧时间）。',