@stalfh233/omc-cli 0.4.36 → 0.4.38

package/dist/recipes/businessrule.js

@@ -0,0 +1,269 @@
+import { environment, model, commonRecovery } from "./shared.js";
+const ruleGraph = Object.freeze({
+    id: "standard-business-rule-graph",
+    title: "保存并启用最小数据事件规则图",
+    status: "requires-prior-readback",
+    tool: "rule.save",
+    args: {
+        environment,
+        schemaCode: model,
+        ruleCode: "Create",
+        name: "创建时写入状态",
+        nodeGraph: {
+            nodes: [
+                { nodeCode: "Start", nodeType: "START" },
+                { nodeCode: "UPDATE_1", nodeType: "UPDATE", targetObjectCode: model, inputParam: "_input", filterCondition: { mainConditions: [[{ targetSchemaDataItem: "id", ruleConditionType: "EQ", ruleValueType: "DYNAMIC", currentSchemaDataItem: "id" }]], sheetConditions: [] }, dataActions: [{ targetDataItem: "status", ruleValueType: "FIXED", value: "待处理", ruleActionType: "EQUALS" }] },
+                { nodeCode: "Create", nodeName: "新增数据", nodeType: "SYSTEM_CREATE", isSystemNode: true },
+                { nodeCode: "End", nodeType: "END" },
+            ],
+            routes: [
+                { preNode: "Start", postNode: "UPDATE_1" },
+                { preNode: "UPDATE_1", postNode: "Create" },
+                { preNode: "Create", postNode: "End" },
+            ],
+        },
+        publish: true,
+    },
+    preconditions: ["模型和 target field 已发布；Create 是平台预置触发规则；目标字段可由规则动作写入"],
+    conditionalRequirements: ["BIZ_ACTION 的 outputMappings 必须在 SYSTEM_CREATE/SYSTEM_UPDATE 前被消费；自定义 ruleCode 不会被数据事件自动分发"],
+    priorToolReferences: [
+        { tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认 status 已发布" },
+    ],
+    dryRun: { supported: true, command: `omc call rule.save --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 执行 rule graph dry lint；不会保存/发布规则" },
+    expectedReadback: { performed: { published: true, enabled: false }, readback: { published: true, next: "rule.enable", inputParam: "_input", systemNodeOrder: "UPDATE_1 → SYSTEM_CREATE" } },
+    refusalRecovery: [
+        { code: "rule-graph-validation-failed", action: "按 validation 修正 nodeType、路线、_input 和系统节点顺序后重新 dry-run" },
+        { code: "rule-schema-unresolved", action: "先确认模型存在，不要让 list/save 为幻影 schema 补建预置规则" },
+        { code: "rule-graph-bizmethod-unresolved", action: "先读取真实 BizMethod 及参数面；不要绑定 registration shell" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: false,
+    prerequisiteData: { source: "field.list(published:true)", note: "ruleCode=Create 为平台预置代码；自定义代码需 workflow/button 触发" },
+});
+const ruleBranchGraph = Object.freeze({
+    id: "business-rule-branch-conditional",
+    title: "金额分级：BRANCH 判断 + 两条 UPDATE 分支（真机验证）",
+    status: "requires-prior-readback",
+    tool: "rule.save",
+    args: {
+        environment,
+        schemaCode: model,
+        ruleCode: "Create",
+        name: "金额分级",
+        nodeGraph: {
+            nodes: [
+                { nodeCode: "Start", nodeType: "START" },
+                { nodeCode: "Create", nodeName: "新增数据", nodeType: "SYSTEM_CREATE", isSystemNode: true },
+                { nodeCode: "Branch_1", nodeType: "BRANCH", sourceInputMethod: "PRE_OUT", exitConditionGroups: [[{ currentSchemaDataItem: "amount", ruleDataConditionType: "GT", ruleValueType: "FIXED", value: 10000 }]] },
+                { nodeCode: "UPDATE_BIG", nodeType: "UPDATE", targetObjectCode: model, dataActions: [{ targetDataItem: "level", ruleValueType: "FIXED", value: "大额", ruleActionType: "EQUALS" }] },
+                { nodeCode: "UPDATE_NORMAL", nodeType: "UPDATE", targetObjectCode: model, dataActions: [{ targetDataItem: "level", ruleValueType: "FIXED", value: "普通", ruleActionType: "EQUALS" }] },
+                { nodeCode: "End", nodeType: "END" },
+            ],
+            routes: [
+                { preNode: "Start", postNode: "Create" },
+                { preNode: "Create", postNode: "Branch_1" },
+                { preNode: "Branch_1", postNode: "UPDATE_BIG" },
+                { preNode: "Branch_1", postNode: "UPDATE_NORMAL", routeCondition: false },
+                { preNode: "UPDATE_BIG", postNode: "End" },
+                { preNode: "UPDATE_NORMAL", postNode: "End" },
+            ],
+        },
+        publish: true,
+    },
+    preconditions: ["模型和 target field（level/amount）已发布；Create 是平台预置触发规则；目标字段可由规则动作写入"],
+    conditionalRequirements: [
+        "**系统节点顺序：BRANCH 必须排在 `SYSTEM_CREATE` 之后**——BRANCH 直接接在 START 后会运行时静默不生效、动作不回写（工具 fail closed）。注意这与 BIZ_ACTION 回写场景相反（那里系统节点要在动作之后）——本 recipe 是分支场景。**`SYSTEM_CREATE` 必须显式写**（工具对分支图的自动注入不可靠）。",
+        "**出口条件叶只 4 个键** `{currentSchemaDataItem(左值字段),ruleDataConditionType(操作符),ruleValueType,value}`；用 UI 键 `targetSchemaDataItem`+`ruleConditionType` 会 save+publish 过但运行时 50000（工具 fail closed `rule-graph-branch-condition-keys`）。",
+        "**下列键可省、工具自动补**（省 token；真机验证极简图 1170B vs 全显式 1690B，−31%）：每个节点的 `nodeName`；BRANCH 的 `inputParam:\"_input\"`/`judgeMethod:\"DEFAULT\"`；自更新 UPDATE（`targetObjectCode`=本模型）的 `inputParam:\"_input\"`/`filterCondition`（身份匹配）；非兜底路由的 `routeCondition:true`/`matchType`。仅 BRANCH 的 `sourceInputMethod` 与兜底 else 的 `routeCondition:false` 需显式。**跨模型写（UPDATE/CREATE/DELETE 的 `targetObjectCode`≠规则模型）运行时未验证：lint 给非阻断 warning `rule-graph-cross-model-unverified`（2026-09-27 真机 data.submit 探测只有同模型 UPDATE 生效），交付前必须实测；稳妥用同模型回写或 BIZ_ACTION/二开。**",
+        "预置规则的系统节点类型必须与 ruleCode 匹配（Create→SYSTEM_CREATE）；放 SYSTEM_UPDATE 会 data.submit 50000（工具 fail closed）。",
+    ],
+    priorToolReferences: [
+        { tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认 amount/level 已发布" },
+    ],
+    dryRun: { supported: true, command: `omc call rule.save --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 执行 rule graph dry lint；不写不发布" },
+    expectedReadback: { performed: { published: true, enabled: false }, readback: { nodes: "Start,SYSTEM_CREATE,Branch_1,UPDATE_BIG,UPDATE_NORMAL,End", next: "rule.enable 后用 data.submit 两条（命中/不命中）验 level" } },
+    refusalRecovery: [
+        { code: "rule-graph-branch-before-system-node", action: "把 SYSTEM_CREATE 挪到 BRANCH 之前（本 recipe 顺序）" },
+        { code: "rule-graph-branch-condition-keys", action: "出口叶改用 currentSchemaDataItem + ruleDataConditionType（见 conditionalRequirements）" },
+        { code: "rule-graph-branch-input-param", action: "给 BRANCH 补 inputParam:\"_input\"" },
+        { code: "rule-graph-branch-judge-method", action: "给 BRANCH 补 judgeMethod:\"DEFAULT\"" },
+        { code: "rule-graph-preset-system-node-mismatch", action: "把 SYSTEM_* 改成与 ruleCode 匹配的类型（Create→SYSTEM_CREATE）" },
+        { code: "rule-graph-validation-failed", action: "按 validation 逐项修正后重新 dry-run" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: false,
+    prerequisiteData: { source: "field.list(published:true)", note: "ruleCode=Create 为平台预置代码" },
+});
+const ruleTimingTask = Object.freeze({
+    id: "rule-timing-task",
+    title: "定时任务：每天/周期触发规则（TIMING_TASK，SCHEDULER 节点，配置能力）",
+    status: "offline-valid",
+    tool: "rule.save",
+    args: {
+        environment,
+        schemaCode: model,
+        ruleCode: "<customRuleCode e.g. daily_scan>",
+        name: "每日定时作业",
+        nodeGraph: {
+            bizRuleType: 2,
+            nodes: [
+                { nodeCode: "Start", nodeName: "开始", nodeType: "START" },
+                { nodeCode: "SCHEDULER", nodeName: "定时作业", nodeType: "SCHEDULER", isSystemNode: true, nodeCategory: "systemNode" },
+                { nodeCode: "UPDATE_1", nodeName: "执行动作", nodeType: "UPDATE", targetObjectCode: model, dataActions: [{ targetDataItem: "<field>", ruleValueType: "FIXED", value: "<值>", ruleActionType: "EQUALS" }] },
+                { nodeCode: "End", nodeName: "结束", nodeType: "END" },
+            ],
+            routes: [
+                { preNode: "Start", postNode: "SCHEDULER", routeCondition: true },
+                { preNode: "SCHEDULER", postNode: "UPDATE_1", routeCondition: true },
+                { preNode: "UPDATE_1", postNode: "End", routeCondition: true },
+            ],
+            schedulerSetting: {
+                triggerTimeType: "SELECTED_TIME",
+                cycleType: "DAY",
+                executeType: "CYCLE",
+                execCycle: 1,
+                hour: 1,
+                minute: 0,
+                second: 0,
+                startTime: "<yyyy-MM-dd HH:mm:ss，未来时刻>",
+                endType: "NEVER",
+                // 扫描本表：以本模型为触发数据源，filterConditionGroups 是扫描过滤条件；
+                // 输入数据 = 被过滤出的行，下游以 inputParam:"_input" 消费其字段。
+                dataSourceType: "GET_LIST",
+                filterConditionGroups: [[{ targetSchemaDataItem: "<field>", ruleConditionType: "EQ", ruleValueType: "FIXED", value: "<值>" }]],
+                latestVersion: true,
+                consolidation: false,
+            },
+        },
+        publish: true,
+    },
+    preconditions: [
+        "模型和动作目标字段已发布；本环境需 `cloudpivot.task.enabled=true`（否则平台不建调度任务）",
+        "**「每天定时执行」= 定时任务 TIMING_TASK，是平台原生配置能力，不是外部定时器、不是在线 JS、无需二开**",
+    ],
+    conditionalRequirements: [
+        "`bizRuleType:2` 写在 **`nodeGraph.bizRuleType`**（顶层参数被忽略）——平台只对 bizRuleType=2 的行建调度任务（BizRuleScheduling.java:202-205）；nodeGraph 内未传时工具推断并 warning。",
+        "调度参数在 `nodeGraph.schedulerSetting`，**不在 SCHEDULER 节点上**（ScheduleNode 无时机字段）；缺它则规则能存能启用但**永不触发**。`latestVersion` **必须 true**（false 走旧 builder 读 null startDate → publish 50000）。",
+        "**「定时扫描某表按条件执行」用 `schedulerSetting.dataSourceType:\"GET_LIST\"` + `filterConditionGroups`（扫描过滤条件，二维数组，与 filterCondition 同构）——本模型即触发数据源，被过滤出的行作输入，下游节点以 `inputParam:\"_input\"` 消费其字段**。不要用 `NONE`（无输入数据集：整图无输入，下游 MESSAGE 字段解析不到、设计器映射框选不出字段），也不要为此额外加 QUERY 节点。`BIZ_SERVICE`=以业务方法返回集合为源（配 methodMapping）。真机 2026-10-08 SCM 沙盒：agent 用 NONE+QUERY，站内通知节点字段选不出。**日期过滤叶用 `ruleValueType:\"today\"` + `currentSchemaDataItem:\"<offset>\"`**（\"0\"=今天、\"-7\"=7天前、\"30\"=30天后、可带单位 \"-1-week\"；DateFieldFilter 按 Integer.parseInt(source) 解析，**缺 source 会抛 NumberFormatException → 扫描 0 行 → 规则「永不触发」**，真机 2026-10-08）；\"yesterday\"/\"tomorrow\" 无需 source。",
+        "`startTime` 用未来时刻；`cycleType`∈NEVER/HOUR/DAY/WEEK/MONTH/YEAR/LAST_DAY_OF_MONTH/CUSTOM。**先分清两类语义**：①时刻型——『每天/每周/每月的某个时刻』（每天 09:00、每周三、每月 1 日 02:00）是平台**原生**（cycleType DAY/WEEK/MONTH/CUSTOM + 触发时刻，真机先例 r3-wms：每日 07:00/07:30、每月 1 日），**别误读成定不了任意时刻**；②间隔型——『每 N 小时/分钟/秒』**也是平台原生**（前台+源码双证 2026-10-09）：`cycleType:CUSTOM` + `cycleValue:{unit:HOUR, value, minute, second}`，间隔秒数=value*3600+minute*60+second（设计器 Custom+Hour 单位下有 [0-59]分/[0-59]秒 下拉；JobModelBuilder buildExecuteRule L195-197）。『每 5 分钟』=value:0+minute:5；『每 30 秒』=value:0+minute:0+second:30；『每 2 小时 15 分』=value:2+minute:15。**旧结论『cycleType 最小 HOUR→分钟级无门』是误读**（MES 轮试了不存在的 cycleType=MINUTE 枚举值，漏了 CUSTOM+HOUR 的分/秒槽，源码+设计器复核推翻）；扩展内 ScheduledThreadPoolExecutor 仅在需要请求上下文/非规则语义时用。`executeType`∈POLLING/CYCLE 是后端从上述形状推导的内部表示，写面不用直接给；`triggerTimeType`∈SELECTED_TIME/DATE_FIELD（后者须带 triggerDataItem）。保存后需 `rule.enable`。",
+    ],
+    priorToolReferences: [
+        { tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认动作目标字段已发布" },
+    ],
+    dryRun: { supported: true, command: `omc call rule.save --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 跑图校验（含 schedulerSetting 形状/枚举），不写不发布" },
+    expectedReadback: { performed: { published: true, enabled: false }, readback: { bizRuleType: 2, nodes: "Start,SCHEDULER,UPDATE_1,End", next: "rule.enable；平台到 startTime 建 cron 并触发" } },
+    refusalRecovery: [
+        { code: "rule-graph-scheduler-setting-shape", action: "`nodeGraph.schedulerSetting` 必须是对象/JSON 串（不是写在 SCHEDULER 节点上）" },
+        { code: "rule-graph-scheduler-setting-enum", action: "按 8.6.26 枚举修正 schedulerSetting 字段值（见 conditionalRequirements）" },
+        { code: "rule-graph-bizruletype-inferred-timing-task", action: "已自动推断 bizRuleType=2；如非定时目的请去掉 SCHEDULER 节点" },
+        { code: "rule-graph-validation-failed", action: "按 validation 逐项修正后重新 dry-run" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: false,
+});
+const dataDuplicateFlag = Object.freeze({
+    id: "data-duplicate-flag",
+    title: "字段唯一性防重打标（8.6.26 实证唯一可靠路径）：预置 Create 规则挂 BIZ_ACTION 自调二开 markDuplicates（规则图内 QUERY→UPDATE 打标会静默空转）",
+    status: "offline-valid",
+    tool: "rule.save",
+    args: {
+        environment,
+        schemaCode: "wms_material",
+        ruleCode: "Create",
+        name: "数据新增",
+        nodeGraph: {
+            nodes: [
+                { nodeCode: "Start", nodeName: "开始", nodeType: "START" },
+                { nodeCode: "A1", nodeName: "防重打标", nodeType: "BIZ_ACTION", inputParam: "_input", methodMapping: { schemaCode: "wms_material", serviceCode: "wms_material_service", serviceMethodCode: "markDuplicates", inputMappings: [{ serviceMethodParameterCode: "id", codeType: 1, bizCode: "id", required: true }, { serviceMethodParameterCode: "code", codeType: 1, bizCode: "mat_code" }], outputMappings: [] } },
+                { nodeCode: "Create", nodeName: "新增数据", nodeType: "SYSTEM_CREATE", isSystemNode: true },
+                { nodeCode: "End", nodeName: "结束", nodeType: "END" },
+            ],
+            routes: [
+                { preNode: "Start", postNode: "A1", routeCondition: true },
+                { preNode: "A1", postNode: "Create", routeCondition: true },
+                { preNode: "Create", postNode: "End", routeCondition: true },
+            ],
+        },
+        publish: true,
+    },
+    preconditions: [
+        "目标模型已有「重复标记」字段（如 `mat_dup_flag` 短文本，表单+列表可见）。",
+        "需求方已接受**打标降级**（平台无硬拦原语；BRANCH 不能按 QUERY 空结果分支）。",
+        "二开侧已有 markDuplicates 接口：查同键既有行（代码+号码一级、仅键二级覆盖无代码场景）→ UPDATE 给**既有那条**打标（宁可误报原则）。注册为 RESTFUL 服务并自调（oauth_password + 方法参数 X-LowCode-Corpid CONST——见 bizservice-self-call-corp）。",
+        "**改写的是预置 Create 规则**（不是自定义 ruleCode）：数据事件只分发预置行；自定义 code 落库即 GET_LIST、且其 QUERY→UPDATE 同样空转（r4-fin 双证 2026-10-09）。**节点顺序**：BIZ_ACTION 在 SYSTEM_CREATE 前可用 _input 值操作既有行（打标场景=此形）；要 getBizObject 读/改触发行自己的动作必须排 SYSTEM_CREATE 之后（否则行未落库 null 空转——r4-fin review F1）。",
+    ],
+    conditionalRequirements: [
+        "**为什么不是规则图内 QUERY→UPDATE**：8.6.26 UPDATE 节点 inputParam 只认 `_input`（触发行），`_QN_output` 引用被静默空转、UPDATE 始终命中新建那条——与打标既有行的需求相反（r4-fin 两次真机复现 2026-10-09）。规则图内打标不可靠，必须走二开。",
+        "预置规则改写要点：SYSTEM_CREATE 身份节点必须保留（nodeCode/nodeName/isSystemNode 平台预置身份，错配会让触发行写错）；BIZ_ACTION 插在 START 之后、SYSTEM_CREATE 之前。",
+        "写完 `rule.enable`；**验证**：data.save 同键两条 → 既有那条带标记、新提交那条干净；无代码场景用仅键匹配覆盖。",
+        "掩码/占位值（RELEVANCE-全 0、全 0 id、整值 <…>、未替换 ${var}）会被 rule-graph-masked-or-placeholder-value 出门拦截——从回读复制常量时取真实值。",
+    ],
+    priorToolReferences: [
+        { tool: "model.inspect", args: { environment, schemaCode: "<model>" }, purpose: "确认标记字段已存在且已发布" },
+        { tool: "rule.get", args: { environment, schemaCode: "<model>", ruleCode: "Create", full: true }, purpose: "改写预置规则前先取现图，整图带回（保留 SYSTEM_CREATE 身份）" },
+    ],
+    dryRun: { supported: true, command: `omc call rule.save --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验预置身份/BIZ_ACTION 映射/掩码值，零 wire" },
+    expectedReadback: { performed: { errcode: 0 }, readback: { rulePresent: true, enabled: true, bizRuleType: "DATA_OP" }, next: ["同键双跑：既有行打标、新行干净；唯一键不触发"] },
+    refusalRecovery: [
+        { code: "rule-graph-preset-system-node-mismatch", action: "预置 Create 必须保留 SYSTEM_CREATE 身份节点（不能换成别的系统节点类型）" },
+        { code: "rule-graph-masked-or-placeholder-value", action: "常量值是掩码/占位（全 0 corpId、<…>、${var}）——用真实值（corpId 取环境事实/方法参数 position:2 方案）" },
+        { code: "runtime-50000-corpId-blank", action: "补方法参数 X-LowCode-Corpid（见 bizservice-self-call-corp）；HTTP 200 不代表成功，看响应体 errcode" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: false,
+});
+const ruleCrossModelCreate = Object.freeze({
+    id: "rule-cross-model-create",
+    title: "跨模型新增：查/取源后向另一模型 CREATE（含 QUERY 扇出，真机验证）",
+    status: "offline-valid",
+    tool: "rule.save",
+    args: {
+        environment,
+        schemaCode: model,
+        ruleCode: "<Create|Update|或 TIMING ruleCode>",
+        name: "跨模型生成",
+        nodeGraph: {
+            nodes: [
+                { nodeCode: "Start", nodeName: "开始", nodeType: "START" },
+                { nodeCode: "SYSTEM_CREATE_OR_UPDATE", nodeName: "触发", nodeType: "<SYSTEM_CREATE 或 SYSTEM_UPDATE>", isSystemNode: true },
+                { nodeCode: "C1", nodeName: "新增到目标", nodeType: "CREATE", targetObjectCode: "<targetModel 且 ≠ 承载本规则的模型>", inputParam: "_input", originatorValueType: "DYNAMIC", originatorValue: "<触发字段>", dataActions: [{ targetDataItem: "<目标字段>", ruleValueType: "DYNAMIC", value: "", ruleActionType: "EQUALS", currentDataItemValue: "<来源字段>" }] },
+                { nodeCode: "End", nodeName: "结束", nodeType: "END" },
+            ],
+            routes: [
+                { preNode: "Start", postNode: "SYSTEM_CREATE_OR_UPDATE", routeCondition: true },
+                { preNode: "SYSTEM_CREATE_OR_UPDATE", postNode: "C1", routeCondition: true },
+                { preNode: "C1", postNode: "End", routeCondition: true },
+            ],
+        },
+        publish: true,
+    },
+    preconditions: [
+        "目标模型与目标字段已存在并发布；触发字段存在",
+        "**`targetObjectCode` 不能等于承载该 Create 触发规则的同一模型**（否则自触发死循环 → 运行时 550009「业务规则执行异常」；平台有时 publish 直接 550018）",
+    ],
+    conditionalRequirements: [
+        "`originatorValueType` **必填**（DYNAMIC=触发字段 code / FIXED=完整用户对象 JSON 串）+ `originatorValue`；`dataActions` **必填**（目标字段映射）；缺任一 → rule.save 真机 50000。",
+        "**`dataActions` 要把下游记录所需的业务字段逐条映射**（编号/日期/金额/状态/备注…），**别只挂一个关联 id**——否则下游记录其余字段全 null（真机 2026-10-08）。",
+        "**`originatorValueType:\"DYNAMIC\"` 的 `originatorValue` 必须指向人员字段**（STAFF_SELECTOR 等）；指向文本/编号字段会致发起人错误或为空。",
+        "「当前时间」不是规则的 value 类型：`ruleValueType:\"SYSTEM\"` 不会填 now（真机 2026-10-08 落 null）。要让下游日期=生成时刻，把该**日期字段的默认值**设为「当前时间」（平台 `{value:\"current\"}`），或走二开；纯规则映射填不出 now。",
+        "上游是 QUERY 时 `inputParam=\"_<QUERY节点code>_output\"`（QUERY 查 N 行→CREATE 逐条生成即 N→N 扇出，真机验证支持，同/跨模型均可）；否则 `\"_input\"`。",
+        "`QUERY` 节点只能查**主模型行**：查子表 schema（`parent.child` 或子 schema 名）空条件返回 0 行、带条件 550018（真机 2026-10-08）——逐子表明细扇出才需要二开。",
+        "跨模型 CREATE/UPDATE 真机验证支持（2026-09-28 / 2026-10-08）；承载规则的触发时机要对（Create 在提交时触发、Update 只在 data.update 触发、TIMING 定时触发）。",
+    ],
+    priorToolReferences: [
+        { tool: "field.list", args: { environment, schemaCode: "<targetModel>", published: true }, purpose: "确认目标模型/字段已发布" },
+    ],
+    dryRun: { supported: true, command: `omc call rule.save --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 跑图 lint（不会暴露跨模型 CREATE 的 50000，需真机 save 复核）" },
+    expectedReadback: { readback: { published: true, next: "rule.enable；构造数据触发后回读目标模型行数" } },
+    refusalRecovery: [
+        { code: "wire-business", action: "rule.save 真机 50000：多为 CREATE 缺 originatorValueType/dataActions，或 QUERY 查了子表 schema；按 conditionalRequirements 修正" },
+        { code: "rule-graph-self-trigger-create-loop", action: "CREATE 目标不能是承载本 Create 规则的同一模型；改为写别的模型或换触发载体" },
+        { code: "rule-graph-validation-failed", action: "按 validation 修正节点/路线/inputParam 后重新 dry-run" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: false,
+});
+export const BUSINESSRULE_METADATA = Object.freeze({
+    "rule.save": Object.freeze({ recipes: [ruleGraph, ruleBranchGraph, ruleTimingTask, dataDuplicateFlag, ruleCrossModelCreate], relatedTools: ["field.list", "rule.get", "rule.enable"] }),
+});
+//# sourceMappingURL=businessrule.js.map

package/dist/recipes/datarule.js

@@ -0,0 +1,215 @@
+import { environment, model, commonRecovery } from "./shared.js";
+const submitCrossFieldCheck = Object.freeze({
+    id: "submit-cross-field-check",
+    title: "表单提交校验（跨字段比较）：datarule type1 + checkType:2 + conditions（右值结构值）+ prompt——在线 JS onValidate 之前的配置正解",
+    status: "offline-valid",
+    tool: "datarule.create",
+    args: {
+        environment,
+        schemaCode: "svc_repair",
+        propertyCode: "rep_plan_finish_time",
+        dataRuleType: 1,
+        checkType: 2,
+        name: "完成时间不早于报告时间",
+        options: {
+            conditions: `{rep_plan_finish_time} 大于等于 {"valueType":"currentModel","value":"rep_report_time"}`,
+            prompt: "预计完成时间不能早于报告时间",
+        },
+    },
+    preconditions: [
+        "需求是**提交时跨字段校验并弹提示拦截**（A 字段与 B 字段的比较）——这有**配置正解**，先于在线 JS onValidate 考虑（在线 JS 只在该协议确实表达不了时用）。",
+        "比较符支持：等于/不等于/大于/大于等于/小于/小于等于/包含/属于/介于 等（中文或符号）。",
+    ],
+    conditionalRequirements: [
+        `**右值必须用结构值** {"valueType":"currentModel","value":"<字段code>"}——裸 {字段code} 右值平台存储成功但**永不解析、规则静默不生效**（2026-09-24 真机；工具 fail-closed 拦截 + 读回 shapeWarning 标记存量雷）。`,
+        "**prompt 存纯文本**：门户对顶层 options.prompt 原样显示，URL 编码会弹 %E5.. 乱码（真机 equipmaint_workorder 案）。",
+        "单字段正则/长度类校验用 checkType:1/4/5（REGEX/MAX_LENGTH/EMPTY_ROW）+ 对应 options 键。",
+    ],
+    priorToolReferences: [{ tool: "field.list", args: { environment, schemaCode: "<模型>" }, purpose: "确认两个比较字段已发布" }],
+    dryRun: { supported: true, command: `omc call datarule.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 过协议校验（裸右值/prompt 编码当场拒），零 wire" },
+    expectedReadback: { performed: { errcode: 0 }, readback: { rulePresent: true, shapeWarning: null }, next: ["门户提交错误日期 → 弹 prompt 文案并拦截（前台点验）"] },
+    refusalRecovery: [
+        { code: "datarule-submit-cross-field-bare", action: `右值换成结构值 {"valueType":"currentModel","value":"字段code"}` },
+        { code: "datarule-submit-prompt-encoded", action: "prompt 存纯文本，别 URL 编码" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: false,
+});
+const dataruleCalcRule = Object.freeze({
+    id: "field-compute-rule",
+    title: "字段计算规则：普通字段 + 计算规则（type2，勿用「计算公式」字段类型）",
+    status: "offline-valid",
+    tool: "datarule.create",
+    args: {
+        environment,
+        schemaCode: model,
+        propertyCode: "c",
+        dataRuleType: 2,
+        options: {
+            shortTextStitch: JSON.stringify({
+                formula: "{a}+{b}",
+                editorText: "<field-omc0001>a</field-omc0001>+<field-omc0001>b</field-omc0001>",
+                editorMark: "field-omc0001",
+            }),
+        },
+        name: "c=a+b",
+    },
+    preconditions: [
+        "**计算类需求：建普通业务字段（数值优先，文本亦可）+ 本计算规则；不要用「计算公式」字段类型（FORMULA）**——平台约定是普通字段顺带配计算规则（真机 2026-10-08 复核：普通数值字段 + type2 计算规则，门户算出 7.00，设计器「计算规则」弹窗显示公式）。",
+        "参与计算的字段已发布",
+    ],
+    conditionalRequirements: [
+        "`options.shortTextStitch` 的值必须是 JSON 对象字符串，**三个键都要给全**：`{\"formula\":\"{a}+{b}\",\"editorText\":\"<field-omc0001>a</field-omc0001>+<field-omc0001>b</field-omc0001>\",\"editorMark\":\"field-omc0001\"}`。",
+        "**`editorText`/`editorMark` 不是可选**（真机 2026-10-08）：设计器「计算规则」弹窗按 `editorText` 里的 `<field-{editorMark}>…</field-{editorMark}>` 标记解析；`editorMark:\"\"` 或 `editorText` 不带标记 → 弹窗**标红/判非法**。约定：`editorMark` = `field-<任意一致 id>`（如 `field-omc0001`），`editorText` 里**每个字段引用**都包成 `<field-omc0001>ref</field-omc0001>`——**标签内只放裸 token，不要带花括号**（前端 `parseFormulaFromEditorText` 会自己给标签内容套上 `{}`：写 `<field-omc0001>{a}</field-omc0001>` 会被反解成 `{{a}}` ≠ `formula`，该规则显示「已失效」；真机 2026-10-08 SCM 沙盒已复现，OMC 现已 fail closed `datarule-stitch-editor-mismatch`）。",
+        "**`formula` 引用语法**（真机 production + 设计器核验）：同类字段裸 `{字段code}`（`{a}+{b}`）；**子表列用 `{子表字段code.子列code}` 点号全限定**（`{prop_repair_detail.qty}*{prop_repair_detail.unit_price}`）；子表聚合 `SUM({子表.子列})`；支持 `IF/CASE/VALUE/AND/=、字符串字面量、运算符空格`。",
+        "**计算由门户前端执行、API 不回填**：写测试数据带预算值；正确性由门户表单填表确认。设计器「计算规则」弹窗读取 `bizdatarule/list`（本规则即写入该表）。",
+    ],
+    priorToolReferences: [
+        { tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认目标字段与来源字段已发布、且目标字段是普通字段" },
+    ],
+    dryRun: { supported: true, command: `omc call datarule.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验类型/公式协议，不写入" },
+    expectedReadback: { readback: { dataRuleType: 2, options: { shortTextStitch: "<含 formula 的 JSON 串>" } } },
+    refusalRecovery: [
+        { code: "datarule-options-invalid", action: "shortTextStitch 必须是含 formula 的 JSON 对象串；同类字段用裸 {字段}，子表列用 {子表.子列}" },
+        { code: "wire-business", action: "305003 假死循环常见于未发布应用或坏 formula 形状；确认应用已发布、formula 为合法引用" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: false,
+});
+const dataruleSubtableSum = Object.freeze({
+    id: "field-compute-subtable-sum",
+    title: "字段计算规则：子表列求和回主表（普通字段 + type2，SUM({子表.子列})）",
+    status: "offline-valid",
+    tool: "datarule.create",
+    args: {
+        environment,
+        schemaCode: model,
+        propertyCode: "total",
+        dataRuleType: 2,
+        options: {
+            shortTextStitch: JSON.stringify({
+                formula: "SUM({<childSchemaCode>.amount})",
+                editorText: "SUM(<field-omc0001><childSchemaCode>.amount</field-omc0001>)",
+                editorMark: "field-omc0001",
+            }),
+        },
+        name: "合计=明细金额之和",
+    },
+    preconditions: [
+        "**目标 `total` 是普通数值字段（不是「计算公式」字段）**；`<childSchemaCode>` 是子表字段的 code（如 `prop_repair_detail` / `Sub_item_information_table`），`amount` 是其子列 code",
+        "子表与其列已发布",
+    ],
+    conditionalRequirements: [
+        "子表列引用用 `{子表字段code.子列code}` 点号全限定；求和 `SUM({子表.子列})`（真机核验：`SUM({prop_repair_detail.amount})`）。",
+        "**给全 `editorText`/`editorMark`**：`editorMark=\"field-omc0001\"`，`editorText=\"SUM(<field-omc0001>prop_repair_detail.amount</field-omc0001>)\"`；缺则设计器标红。",
+        "计算由门户前端执行、API 不回填（写测试数据带预算值；门户填表确认）。",
+    ],
+    priorToolReferences: [
+        { tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认主表 total、子表字段及其子列已发布" },
+    ],
+    dryRun: { supported: true, command: `omc call datarule.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验类型/公式协议，不写入" },
+    expectedReadback: { readback: { dataRuleType: 2, options: { shortTextStitch: "<含 SUM({子表.子列}) 的 JSON 串>" } } },
+    refusalRecovery: [{ code: "datarule-options-invalid", action: "子表列引用必须是 {子表字段code.子列code}；SUM 包裹其外" }, ...commonRecovery],
+    requiresEnvironmentDerivedIds: false,
+});
+const dataruleChildColumn = Object.freeze({
+    id: "field-compute-child-column",
+    title: "字段计算规则：子表列同行运算（普通字段 + type2，如 金额=数量×单价）",
+    status: "offline-valid",
+    tool: "datarule.create",
+    args: {
+        environment,
+        schemaCode: "<childSchemaCode e.g. <model>_items>",
+        propertyCode: "amount",
+        dataRuleType: 2,
+        options: {
+            shortTextStitch: JSON.stringify({
+                formula: "{<childSchemaCode>.qty}*{<childSchemaCode>.price}",
+                editorText: "<field-omc0001><childSchemaCode>.qty</field-omc0001>*<field-omc0001><childSchemaCode>.price</field-omc0001>",
+                editorMark: "field-omc0001",
+            }),
+        },
+        name: "金额=数量×单价",
+    },
+    preconditions: ["**子表列 `amount` 是普通数值字段（不是「计算公式」字段）**，且是子表内的列（schemaCode=子表字段 code）"],
+    conditionalRequirements: [
+        "**子表内列引用用 `{子表schemaCode.子列code}` 点号全限定**（真机 2026-10-08 设计器产出：`{prop_repair_detail.qty}*{prop_repair_detail.unit_price}`）；不要写裸 `{qty}`。",
+        "**给全 `editorText`/`editorMark`**：`editorMark=\"field-omc0001\"`，每个引用包成 `<field-omc0001>子表.子列</field-omc0001>`（**标签内裸 token，不带花括号**——编辑器会自己套 `{}`）；缺或带括号则设计器标红/已失效。",
+        "计算由门户前端执行、API 不回填（门户填表确认）。",
+    ],
+    priorToolReferences: [{ tool: "field.list", args: { environment, schemaCode: "<childSchemaCode>" }, purpose: "确认子表及其列已发布" }],
+    dryRun: { supported: true, command: `omc call datarule.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验类型/公式协议，不写入" },
+    expectedReadback: { readback: { dataRuleType: 2, options: { shortTextStitch: "<含 {子表.子列} 点号引用的 JSON 串>" } } },
+    refusalRecovery: [{ code: "datarule-options-invalid", action: "子表内列用 {子表schemaCode.子列code} 点号；不要裸 {子列code}" }, ...commonRecovery],
+    requiresEnvironmentDerivedIds: false,
+});
+const dataruleRequired = Object.freeze({
+    id: "datarule-conditional-required",
+    title: "金额超过阈值时说明必填（字段级 type4）",
+    status: "offline-valid",
+    tool: "datarule.create",
+    args: {
+        environment,
+        schemaCode: model,
+        propertyCode: "leaveReason",
+        dataRuleType: 4,
+        options: { requiredFormula: '{leave_amount} 大于 {"valueType":"custom","value":5000}' },
+        name: "金额超过阈值说明必填",
+        sortKey: 1,
+    },
+    preconditions: ["目标字段已发布；amount 字段 code 已确认"],
+    conditionalRequirements: ["条件串必须是 {field} OP {JSON valueType} 三段单空格；多条件用 &&/||"],
+    priorToolReferences: [{ tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认 leave_amount 与 leave_reason 已发布" }],
+    dryRun: { supported: true, command: `omc call datarule.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验类型/条件协议，不写入" },
+    expectedReadback: { readback: { dataRuleType: 4, options: { requiredFormula: "<protocol>" } } },
+    refusalRecovery: [{ code: "datarule-options-invalid", action: "不要写 `{field}>5000` 或裸 true；复制 recipe 的三段协议" }, ...commonRecovery],
+    requiresEnvironmentDerivedIds: false,
+});
+const dataruleReadonly = Object.freeze({
+    id: "datarule-conditional-readonly",
+    title: "字段级条件只读（type5，恒真条件式）",
+    status: "offline-valid",
+    tool: "datarule.create",
+    args: {
+        environment,
+        schemaCode: model,
+        propertyCode: "approvalLevel",
+        dataRuleType: 5,
+        options: { readonlyCondition: '{approvalLevel} 大于等于 {"valueType":"custom","value":0}' },
+        name: "审批级别只读",
+        sortKey: 1,
+    },
+    preconditions: ["目标字段已发布"],
+    conditionalRequirements: ["无条件 readonly 的 functionType 形状尚未被 live 复现；使用已验证恒真条件式"],
+    priorToolReferences: [{ tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认 approvalLevel 已发布" }],
+    dryRun: { supported: true, command: `omc call datarule.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验条件协议，不写入" },
+    expectedReadback: { readback: { dataRuleType: 5, options: { readonlyCondition: "<protocol>" } } },
+    refusalRecovery: [{ code: "datarule-options-invalid", action: "readonlyCondition 必须是三段条件式；`readonlyCondition:true` 会破坏门户渲染" }, ...commonRecovery],
+    requiresEnvironmentDerivedIds: false,
+});
+const dataruleDisplay = Object.freeze({
+    id: "datarule-conditional-display",
+    title: "字段级显示条件（type3）",
+    status: "offline-valid",
+    tool: "datarule.create",
+    args: {
+        environment,
+        schemaCode: model,
+        propertyCode: "approvalLevel",
+        dataRuleType: 3,
+        options: { displayFormula: '{isUrgent} == {"valueType":"custom","value":true}' },
+        name: "加急时显示审批级别",
+        sortKey: 1,
+    },
+    preconditions: ["目标字段已发布"],
+    conditionalRequirements: ["displayFormula 与 requiredFormula/readonlyCondition 共用三段条件协议"],
+    priorToolReferences: [{ tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认字段 codes" }],
+    dryRun: { supported: true, command: `omc call datarule.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验条件协议，不写入" },
+    expectedReadback: { readback: { dataRuleType: 3, options: { displayFormula: "<protocol>" } } },
+    refusalRecovery: [{ code: "datarule-options-invalid", action: "复制三段条件协议；不要传裸公式字符串" }, ...commonRecovery],
+    requiresEnvironmentDerivedIds: false,
+});
+export const DATARULE_METADATA = Object.freeze({
+    "datarule.create": Object.freeze({ recipes: [submitCrossFieldCheck, dataruleCalcRule, dataruleSubtableSum, dataruleChildColumn, dataruleRequired, dataruleReadonly, dataruleDisplay], relatedTools: ["field.list", "datarule.list"] }),
+});
+//# sourceMappingURL=datarule.js.map

package/dist/recipes/dictionary.js

@@ -0,0 +1,42 @@
+import { environment, commonRecovery } from "./shared.js";
+const dictionaryKeyValue = Object.freeze({
+    id: "dictionary-key-value",
+    title: "建一个键值字典并用其 id 作字段下拉来源",
+    status: "offline-valid",
+    tool: "dictionary.save",
+    args: {
+        environment,
+        code: "visitType",
+        name: "回访方式",
+        dictionaryType: 0,
+        records: [
+            { code: "phone", name: "电话" },
+            { code: "visit", name: "上门" },
+            { code: "online", name: "线上" },
+        ],
+    },
+    preconditions: ["字典 code 尚未存在（存在须改传 id 更新）；dictionaryType 0=KEY_VALUE / 1=TREE"],
+    conditionalRequirements: [
+        "**字段下拉绑定字典时 `checkedDictionary` 必须填字典 id（不是 name）**——前端 a-select 的 option value 就是 id；填 name 运行时会返回『字典已被禁用，无数据』、下拉空白（真机 ticket 02/34）。拿到 id：`dictionary.get`/`dictionary.names` 读回。",
+        "TREE 字典的 record 可带 `parentId`；给既有字典加记录也走 `dictionary.save`（带 id + 完整 records）。",
+        "字段侧用 `field.create` 的 `options.optionsSet = {optionsType:'dictionary',dictionary:{checkedDictionary:'<id>',checkedDictionaryCode:'<code>',useDictionariesData:[{code,name,id}]}}`；`choices` 是「手写选项」的另一条路，不要与字典混用。",
+    ],
+    priorToolReferences: [
+        { tool: "dictionary.names", args: { environment }, purpose: "查 code/name 冲突并读回既有 id（字典多时结果会溢成 artifact；只需 code/name，用 `artifact get <id> --keys` 或 --jq，别整份取）" },
+        { tool: "dictionary.get", args: { environment, code: "visitType" }, purpose: "按 code 精确查存在性（小结果，优于 dictionary.names 全量）" },
+    ],
+    dryRun: { supported: true, command: `omc call dictionary.save --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 预检 code 冲突/形状，不写" },
+    expectedReadback: { performed: { errcode: 0 }, readback: { present: true, dictionary: { id: "<dictionary.id>", code: "visitType", records: ["phone", "visit", "online"] } }, next: ["field.create --example dictionary-backed-single-select（用回读的 id）"] },
+    refusalRecovery: [
+        { code: "dictionary-create-duplicate", action: "code 已存在：从 dictionary.names 取 id 后改传 id 做更新" },
+        { code: "wire-business", action: "平台 `errcode -1 系统中已经存在相同名称的字典` = **字典名称全局唯一**（code 唯一还不够）——换一个 name（真机 2026-09-25：新 code + 旧 name 仍被拒）" },
+        { code: "capability-out-of-coverage", action: "确认 dictionaryType 0/1 与 records[{code,name}] 形状" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: true,
+    prerequisiteData: { source: "dictionary.get / dictionary.names", fields: ["dictionary.id"] },
+});
+export const DICTIONARY_METADATA = Object.freeze({
+    "dictionary.save": Object.freeze({ recipes: [dictionaryKeyValue], relatedTools: ["dictionary.names", "dictionary.records", "field.create"] }),
+});
+//# sourceMappingURL=dictionary.js.map