@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/execution-metadata.js

@@ -0,0 +1,1092 @@
+const commonRecovery = Object.freeze([
+    Object.freeze({ code: "tool-input-invalid", action: "修正 recipe.args 后重新 dry-run；inputSchema 是参数权威" }),
+    Object.freeze({ code: "write-lock-held", action: "等待当前写锁释放后重试；不要并行重放写入" }),
+]);
+const environment = "<environment>";
+const model = "omc_recipe_model";
+const dictionarySelection = Object.freeze({
+    id: "dictionary-backed-single-select",
+    title: "先读字典，再创建字典-backed 单选字段",
+    status: "requires-prior-readback",
+    tool: "field.create",
+    args: {
+        environment,
+        schemaCode: model,
+        code: "status",
+        name: "状态",
+        propertyType: "DROPDOWN_BOX",
+        options: {
+            optionsSet: {
+                optionsType: "dictionary",
+                dictionary: {
+                    checkedDictionary: "<dictionary.id>",
+                    checkedDictionaryCode: "<dictionary.code>",
+                    useDictionariesData: [{ code: "<record.code>", name: "<record.name>", id: "<record.id>" }],
+                },
+            },
+        },
+    },
+    preconditions: ["目标模型已存在；字段 code 尚未存在；字典及其至少一个启用记录可由只读发现取得"],
+    conditionalRequirements: ["若字典树有 parentId，dictionary.records 必须带 parentId；否则用 dictionary.records 的 id 或 code"],
+    priorToolReferences: [
+        { tool: "dictionary.names", args: { environment }, purpose: "选择环境中的 dictionary id/name/code；checkedDictionary 必须填 **id**（前端 a-select 的 option value 就是 a.id；填 name 运行时 getEnableRecordsByDictionaryId 会返回『字典已被禁用，无数据』，下拉空白）" },
+        { tool: "dictionary.records", args: { environment, code: "<dictionary.code>", enabledOnly: true }, purpose: "取得 useDictionariesData；替换 recipe 中的环境 ID" },
+    ],
+    dryRun: { supported: true, command: `omc call field.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 只做 schema/语义/治理预检，不创建字段" },
+    expectedReadback: { performed: { dryRun: true }, readback: { draftFieldPresent: false, next: "field.publish" } },
+    refusalRecovery: [
+        { code: "field-family-options-invalid", action: "确保 options.optionsSet.dictionary 的 checkedDictionary、checkedDictionaryCode 和 useDictionariesData 来自同一字典" },
+        { code: "duplicate-field", action: "先 field.list 读取草稿/发布面；已有字段改用 field.update" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: true,
+    prerequisiteData: { source: "dictionary.names → dictionary.records(enabledOnly:true)", fields: ["dictionary.code", "record.code", "record.id"] },
+});
+const childTable = Object.freeze({
+    id: "minimal-child-table",
+    title: "创建带两个标量列的子表字段",
+    status: "offline-valid",
+    tool: "field.create",
+    args: {
+        environment,
+        schemaCode: model,
+        code: "<model>_items",
+        name: "明细",
+        propertyType: "CHILD_TABLE",
+        subFields: [
+            { code: "item_name", name: "名称", propertyType: "SHORT_TEXT" },
+            { code: "item_qty", name: "数量", propertyType: "NUMERICAL", options: { scale: 1 } },
+        ],
+    },
+    preconditions: ["目标模型已存在；父字段 code 和子列 codes 尚未存在；父模型字段发布后再配置表单"],
+    conditionalRequirements: [
+        "**子表 `code` 会成为全局子 schema code——必须模型作用域唯一（如 `<model>_items`），不要用通用名如 `items`/`purchase_items`，否则撞名时平台只回 errcode 40000「调用数据库发生异常」（实测）**；",
+        "子表列不得是 CHILD_TABLE、OCR、ELECTRONIC_SIGN、RELEVANCE_DATA 或 FORMULA；关系列必须另带 relativeCode 与 options；子列 NUMERICAL 同样必须带 options.scale",
+    ],
+    priorToolReferences: [],
+    dryRun: { supported: true, command: `omc call field.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 验证 subFields 并跳过环境写入" },
+    expectedReadback: { readback: { field: { code: "items", propertyType: "CHILD_TABLE", subSchema: { properties: ["item_name", "item_qty"] } } }, next: ["field.publish", "form.draft", "form.publish"] },
+    refusalRecovery: [
+        { code: "capability-out-of-coverage", action: "补齐 subFields，并移除不支持的嵌套/高级子列族" },
+        { code: "child-table-update-unsupported", action: "子列用 schemaCode=items 的 field.create/update；不要向父字段 update 传 options/choices/subFields" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: false,
+});
+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 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,
+});
+const workflowTemplateUpdate = Object.freeze({
+    id: "workflow-approval-template-update",
+    title: "改流程草稿模板（开始→审批→结束，可多级）并发布",
+    status: "requires-prior-readback",
+    tool: "workflow.update",
+    args: {
+        environment,
+        schemaCode: model,
+        code: "apply_workflow",
+        template: {
+            workflowCode: "apply_workflow",
+            activities: [
+                { activityCode: "Activity1", activityType: "START", activityName: "开始", i18nMessage: "开始" },
+                { activityCode: "Activity2", activityType: "PARTICIPANT", activityName: "填写申请单", i18nMessage: "填写申请单", participant: "{Originator}" },
+                { activityCode: "Activity3", activityType: "PARTICIPANT", activityName: "部门负责人审批", i18nMessage: "部门负责人审批", participant: "FindUserByRole({Originator.OU},\"<部门负责人角色code>\",\"random\")" },
+                { activityCode: "Activity4", activityType: "PARTICIPANT", activityName: "财务负责人审批", i18nMessage: "财务负责人审批", participant: "FindUserByRole({Originator.OU},\"<财务负责人角色code>\",\"random\")" },
+                { activityCode: "Activity5", activityType: "END", activityName: "结束", i18nMessage: "结束" },
+            ],
+        },
+    },
+    preconditions: ["workflow.create 已完成；先用 workflow.get_draft 取草稿基线——**默认（紧凑）面已含 activities 的 activityCode/type/name 与 edges，够改流程，不要 --full（30–75KB）**"],
+    conditionalRequirements: [
+        "**activities 用数组**（也接受 {0:…,1:…} 索引对象）；每个活动必须带 activityCode（Activity1..N）与 activityType，缺了会被拒——以 get_draft 的值为基线改，不要凭记忆拼；",
+        "**一个模型只能有一个流程**：workflow.create 对已有流程的模型会拒（一个模型只能有一个流程）；要改现有流程直接 workflow.update，不要另建新 code；",
+        "多级审批：为每个审批节点各写一个 PARTICIPANT 活动（activityCode 唯一），END 放最后；数组里按顺序就是审批链顺序；新增的审批节点由工具自动接入链路（补全到 END 的连线），无需自己写 routes；",
+        "**participant 必须是平台可解析的三种形态之一（真实生产 2026-09-23 观察）**：(a) 关键字 `{Originator}`；(b) 参与者对象数组 JSON `[{\"code\":\"<角色code>\",\"corpId\":\"<corpId|other>\",\"id\":\"<roleId>\",\"name\":\"<角色名>\",\"type\":2}]`（type 2=角色，3=用户；多个用 `+` 连接）；(c) 函数 `FindUserByRole({Originator.OU},\"<roleCode>\",\"random\")`。**自由文本角色名（如 `部门负责人`）能 publish 但解析不到人、不生成待办**——先用 `org.role.list` / `org.department.list` 拿 code/id 再构造。工具会在 readback 里以 `participantWarnings` 标出自由文本。",
+        "**审批节点必须带 sheetCode（=模型默认表单槽位，通常等于 schemaCode）——S29 契约：participant sheetCode 为空 publish 会 401026 WORKFLOW_ACTIVITY_NO_SHEET。工具已自动回填，正常无需手填**；",
+        "节点类型 START / PARTICIPANT / END；省略的既有节点由 merge 保留；",
+        "**平台 workflow.create 会自动生成含「填写申请单」发起节点的草稿（START → 填写申请单 → 审批 → END）；workflow.update 是 merge，不删除既有节点——要严格三节点需在设计器删该节点，或如实接受该发起节点**",
+        "**读回 participant 为空是平台模板更新面的已知残留，不要反复 update 试图修正（实测 6 次 update 仍为空）；记录该差异并留待设计器核对，一次读回确认即可**",
+    ],
+    priorToolReferences: [{ tool: "workflow.get_draft", args: { environment, workflowCode: "apply_workflow" }, purpose: "取草稿基线作为 merge 基线（默认面即含 activityCode/name/edges；不要 --full）" }],
+    dryRun: { supported: true, command: `omc call workflow.update --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验模板形状，不写入" },
+    expectedReadback: { readback: { draftUpdated: true, activities: "<节点数=你数组长度>", edges: "<链路>" }, next: ["用默认 workflow.get_draft 复核 activities/edges（不要 --full）", "workflow.publish", "workflow.bindRule"] },
+    refusalRecovery: [
+        { code: "tool-input-invalid", action: "每个 activity 补 activityCode（从 get_draft 抄）；templateType 省略" },
+        { code: "workflow-publish-invalid", action: "publish 被 ValidateMessage[] 拒（401026/401027/401017）时，多为审批节点 sheetCode 为空或新增节点未接入链路——工具已自动回填 sheetCode 并补全链，改完模板再 update 一次；不要反复 publish" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: true,
+    prerequisiteData: { source: "workflow.get_draft", fields: ["activities[].activityCode"] },
+});
+const workflowConditionalBranch = Object.freeze({
+    id: "workflow-conditional-branch",
+    title: "按字段条件分流（urgent 走主管审批，否则直接结束）",
+    status: "requires-prior-readback",
+    tool: "workflow.update",
+    args: {
+        environment,
+        schemaCode: model,
+        code: "apply_workflow",
+        template: {
+            workflowCode: "apply_workflow",
+            activities: [
+                { activityCode: "A1", activityType: "START", activityName: "开始", i18nMessage: "开始" },
+                { activityCode: "A2", activityType: "PARTICIPANT", activityName: "填写申请单", i18nMessage: "填写申请单", participant: "{Originator}" },
+                { activityCode: "A3", activityType: "PARTICIPANT", activityName: "主管审批", i18nMessage: "主管审批", participant: "FindUserByRole({Originator.OU},\"SYS_1000000\",\"random\")" },
+                { activityCode: "A4", activityType: "END", activityName: "结束", i18nMessage: "结束" },
+            ],
+            routes: [
+                { preNode: "A1", postNode: "A2" },
+                { preNode: "A2", postNode: "A3", ruleConditionGroup: [[{ currentDataItem: "r16_level", bizPropertyType: 12, conditionType: "EQ", value: "urgent" }]] },
+                { preNode: "A2", postNode: "A4", utilizeElse: true },
+                { preNode: "A3", postNode: "A4" },
+            ],
+        },
+    },
+    preconditions: ["workflow.create 已完成；路由的活动 code（preNode/postNode）必须命中 activities 里的 activityCode；先用 workflow.get_draft 取基线"],
+    conditionalRequirements: [
+        "**条件连线 = routes[] 里的 ruleConditionGroup**（外层 OR、内层 AND）；叶只能有 4 个键 `{currentDataItem, bizPropertyType, conditionType, value}`——**多一个键（如照抄业务规则的 ruleValueType/targetDataItem）会让平台回 workflow/update 误导性的 `401001 流程不存在！`，工具已写前拒绝**。",
+        "`currentDataItem` = 当前模型字段 code（子表列用 `childSchemaCode.fieldCode`）；`bizPropertyType` **用数字索引**（SHORT_TEXT=0 / NUMERICAL=2 / DATE=3 / LOGICAL=4 / RADIO=12 / DROPDOWN_BOX=14 / STAFF_SELECTOR=50…；工具也接受枚举名并转索引）；`conditionType` ∈ EQ/NEQ/GT/LT/GTEQ/LTEQ/CT/NCT/EP/NEP/BETWEEN/...；`value` 为字面量。",
+        "**else/兜底连线用 `utilizeElse:true`**（其余条件不满足时走）；工具会自动把条件连线置 `popupType:EXPRESSION`（否则平台静默跳过）。",
+        "分支可只写 activities + routes：工具按数组顺序补全到 END 的连线（`con` 兜底线仍需你显式给，除非它就是主链）。",
+    ],
+    priorToolReferences: [
+        { tool: "workflow.get_draft", args: { environment, workflowCode: "apply_workflow" }, purpose: "取草稿基线（apply_workflow 换成真实 workflowCode；默认面即含 activityCode/name/edges，不要 --full）" },
+        { tool: "org.role.list", args: { environment }, purpose: "取真实参与人/角色 code，避免自由文本名解析不到人" },
+    ],
+    dryRun: { supported: true, command: `omc call workflow.update --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验 activities/routes/条件叶，不写入" },
+    expectedReadback: { readback: { draftUpdated: true, rules: [{ postActivityCode: "A3", ruleConditionGroup: [[{ currentDataItem: "r16_level", bizPropertyType: 12, conditionType: "EQ", value: "urgent" }]], popupType: "EXPRESSION" }, { postActivityCode: "A4", utilizeElse: true }] }, next: ["workflow.publish", "data.submit 两条（命中/不命中）验 workitem.list"] },
+    refusalRecovery: [
+        { code: "workflow-route-condition-invalid", action: "条件叶只留 currentDataItem/bizPropertyType/conditionType/value；补 currentDataItem 与 conditionType；bizPropertyType 用数字索引或已知枚举名" },
+        { code: "workflow-not-found", action: "先 workflow.create，再 workflow.get_draft 取基线——不要把 workflow 模板 id 当 workflowCode" },
+        { code: "workflow-route-not-found", action: "preNode/postNode 必须是 activities 里真实存在的 activityCode（从 get_draft 抄）" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: true,
+    prerequisiteData: { source: "workflow.get_draft", fields: ["activities[].activityCode", "org.role code"] },
+});
+const workflowBinding = Object.freeze({
+    id: "workflow-handler-binding",
+    title: "将规则合并绑定到 workflow handler 并发布",
+    status: "requires-prior-readback",
+    tool: "workflow.bindRule",
+    args: { environment, schemaCode: model, workflowCode: "<workflow.code>", ruleCode: "Create", handler: "end", publish: true },
+    preconditions: ["模型只有一个目标 workflow；workflow.create 已完成且 draft 存在；规则已保存"],
+    conditionalRequirements: ["handler 只能是 start、cancel、activate、end；workflow.bindRule 是 merge，不会删除既有 bizActions"],
+    priorToolReferences: [
+        { tool: "workflow.get_draft", args: { environment, workflowCode: "<workflow.code>" }, purpose: "取得完整 draft，并确认目标 handler 字段" },
+        { tool: "rule.list", args: { environment, schemaCode: model }, purpose: "确认 Create 规则存在" },
+    ],
+    dryRun: { supported: true, command: `omc call workflow.bindRule --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 验证 handler/code 互斥和写治理，不更新 workflow" },
+    expectedReadback: { readback: { handler: "end", handlerField: "endEventHandler", bound: true, published: true, publishedBound: true, semantics: "merge" } },
+    refusalRecovery: [
+        { code: "workflow-not-found", action: "先 workflow.create，再用 workflow.get_draft 取得完整模板" },
+        { code: "workflow-bindrule-codes-invalid", action: "只传 ruleCode 或只传 ruleCodes；不要同时传两者" },
+        { code: "workflow-publish-not-applied", action: "先 workflow.get_draft/validate 修复完整模板，再重新 bindRule；以 published-face marker 为准" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: true,
+    prerequisiteData: { source: "workflow.get_draft + rule.list", fields: ["workflow.code", "rule.code"] },
+});
+const workflowSave = Object.freeze({
+    id: "workflow-backed-data-save",
+    title: "用 data.save 创建 DRAFT workflow row",
+    status: "requires-prior-readback",
+    tool: "data.save",
+    args: { environment, schemaCode: model, workflowCode: "<workflow.code>", formData: { name: "recipe draft" } },
+    preconditions: ["模型默认表单/字段和 workflow 已发布；应用可用；formData 不带已存在 id"],
+    conditionalRequirements: ["workflow draft-save 总是 INSERT；不要把已存在记录 id 放进 formData"],
+    priorToolReferences: [
+        { tool: "workflow.get_published", args: { environment, workflowCode: "<workflow.code>" }, purpose: "确认 published-face marker" },
+    ],
+    dryRun: { supported: true, command: `omc call data.save --env ${environment} --dry-run --args '<recipe.args>'`, notes: "save dry-run 只校验输入与治理；真实两段式身份只能由执行后的 readback 提供" },
+    expectedReadback: { performed: { formType: "save-draft-workflow", captures: ["bizObjectId", "workflowInstanceId", "workItemId"] }, readback: { sequenceStatus: "DRAFT", next: "data.submit" } },
+    refusalRecovery: [
+        { code: "save-workflow-draft-with-id-unsupported", action: "移除已存在 id；workflow draft-save 只支持 INSERT" },
+        { code: "app-not-published", action: "只读确认应用发布状态后修复发布边界；不要盲目重试 runtime 写入" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: true,
+    prerequisiteData: { source: "workflow.get_published; data.save authoritative readback", fields: ["workflow.code", "bizObjectId", "workflowInstanceId", "workItemId"] },
+});
+const workflowSubmit = Object.freeze({
+    id: "workflow-backed-data-submit",
+    title: "消费 data.save 读回身份并提交 workflow work item",
+    status: "requires-prior-readback",
+    tool: "data.submit",
+    args: { environment, schemaCode: model, workflowCode: "<workflow.code>", bizObjectId: "<data.save.performed.bizObjectId>", workflowInstanceId: "<data.save.performed.workflowInstanceId>", workItemId: "<data.save.performed.workItemId>", formData: { name: "recipe draft" } },
+    preconditions: ["同一 recipe 的 data.save 已成功并读回 DRAFT；workflowInstanceId/workItemId/bizObjectId 均非空"],
+    conditionalRequirements: ["workItemId 或 workflowInstanceId 出现时必须传 bizObjectId；身份只能复制 data.save 的 authoritative readback"],
+    priorToolReferences: [
+        { tool: "data.save", args: { environment, schemaCode: model, workflowCode: "<workflow.code>", formData: { name: "recipe draft" } }, purpose: "提供三个环境生成的提交身份" },
+        { tool: "workitem.list", args: { environment }, purpose: "当 data.save 未直接返回 workItemId 时按 workflowInstanceId 解析待办" },
+    ],
+    dryRun: { supported: true, command: `omc call data.submit --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 验证两段式参数关系，不推进 workflow" },
+    expectedReadback: { performed: { formType: "1" }, readback: { sequenceStatus: "COMPLETED", workflowInstanceId: "<same-as-data.save>", workItemId: "<same-as-data.save>" } },
+    refusalRecovery: [
+        { code: "submit-biz-object-id-required", action: "把 data.save 的 bizObjectId 原样传给 data.submit" },
+        { code: "submit-existing-workflow-unsupported", action: "不要用旧行 + workflowCode 启动；先 data.save 新建 DRAFT，再用返回 workItemId 提交" },
+        { code: "submit-target-absent", action: "用 data.load 确认 bizObjectId 属于 schemaCode 后停止盲重试" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: true,
+    prerequisiteData: { source: "data.save authoritative readback; workitem.list fallback", fields: ["bizObjectId", "workflowInstanceId", "workItemId"] },
+});
+const businessModelDropdown = Object.freeze({
+    id: "business-model-dropdown",
+    title: "用另一个模型的数据作下拉来源（businessModel）",
+    status: "requires-prior-readback",
+    tool: "field.create",
+    args: {
+        environment,
+        schemaCode: model,
+        code: "category",
+        name: "类别",
+        propertyType: "DROPDOWN_BOX",
+        options: {
+            optionsSet: {
+                optionsType: "businessModel",
+                businessModel: {
+                    schemaCode: "<source.model>",
+                    sheetDataItem: "<source.businessField>",
+                    appCode: "<app.code>",
+                },
+            },
+        },
+    },
+    preconditions: [
+        "目标模型与来源模型都已存在",
+        "来源模型的显示字段已 field.publish 并已 form.publish（未发布字段不可作为下拉来源）",
+    ],
+    conditionalRequirements: [
+        "sheetDataItem 指向来源模型上真正承载业务值的字段；**不要用系统字段 name** —— 它是平台自动生成的数据标题（人名+模型名+时间），下拉项会显示这串标题而不是业务值",
+        "orderByFields/orderType 可选，用于下拉项排序；conditions 可选，用于过滤来源行",
+    ],
+    priorToolReferences: [
+        { tool: "discover_environment", args: { environment, full: true }, purpose: "取得来源模型 schemaCode 与 app.code" },
+        { tool: "field.list", args: { environment, schemaCode: "<source.model>", published: true, fields: ["<source.businessField>"] }, purpose: "确认显示字段已发布并取其 code" },
+    ],
+    dryRun: { supported: true, command: `omc call field.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验 optionsSet.businessModel 的形状，不创建字段" },
+    expectedReadback: { readback: { field: { code: "category", propertyType: "DROPDOWN_BOX", options: { optionsSet: { optionsType: "businessModel" } } } }, next: ["field.publish", "form.draft", "form.publish"] },
+    refusalRecovery: [
+        { code: "field-family-options-invalid", action: "确保 optionsSet.businessModel 带 schemaCode 与 sheetDataItem，且 schemaCode 是已存在的模型" },
+        { code: "duplicate-field", action: "先 field.list 读取草稿/发布面；已有字段改用 field.update" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: true,
+    prerequisiteData: { source: "discover_environment → field.list(published:true)", fields: ["source.model", "source.businessField", "app.code"] },
+});
+const configureModelRecipe = Object.freeze({
+    id: "model-with-fields-form",
+    title: "一次建模型 + 多字段 + 发布默认表单（高层编排）",
+    status: "offline-valid",
+    tool: "configure_model",
+    args: {
+        environment,
+        name: "采购申请",
+        code: "purchase_apply",
+        applicationCode: "<applicationCode>",
+        fields: [
+            { code: "apply_no", name: "申请编号", propertyType: "SHORT_TEXT" },
+            { code: "apply_amount", name: "申请金额", propertyType: "NUMERICAL", options: { scale: 2 } },
+            { code: "apply_note", name: "申请说明", propertyType: "LONG_TEXT" },
+        ],
+        publishForm: true,
+    },
+    preconditions: ["应用 code 已确认（discover_environment）"],
+    conditionalRequirements: [
+        "fields[].propertyType 用族名；NUMERICAL 必须 options.scale（scale = 小数位数：金额两位小数用 scale:2，整数用 scale:0）",
+        "子表/单选/人员等复杂族建议改用低层 field.create（configure_model 的 fields[] 只覆盖标量族最稳）",
+    ],
+    priorToolReferences: [{ tool: "discover_environment", args: { environment }, purpose: "取 applicationCode 与已有模型" }],
+    dryRun: { supported: true, command: `omc call configure_model --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 走 schema/语义/治理预检，不创建" },
+    expectedReadback: { readback: { modelPresent: true, publishedFields: ["apply_no", "apply_amount", "apply_note"] }, next: ["field.update（表单层条件）", "listview.configure（默认视图已自动存在，直接配置，勿 create）"] },
+    refusalRecovery: [{ code: "capability-out-of-coverage", action: "标量族之外改用低层 field.create；NUMERICAL 补 options.scale" }, ...commonRecovery],
+    requiresEnvironmentDerivedIds: true,
+    prerequisiteData: { source: "discover_environment", fields: ["applicationCode"] },
+});
+const configureFormRecipe = Object.freeze({
+    id: "publish-default-form",
+    title: "把已发布字段绑进默认表单并发布（高层编排）",
+    status: "offline-valid",
+    tool: "configure_form",
+    args: { environment, schemaCode: model, publish: true },
+    preconditions: ["字段已 field.publish"],
+    conditionalRequirements: ["表单层条件必填/只读请用 field.update 的 options（form-conditional-required / form-always-readonly recipe），不是本编排器"],
+    priorToolReferences: [{ tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认字段已发布" }],
+    dryRun: { supported: true, command: `omc call configure_form --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 预检，不写" },
+    expectedReadback: { readback: { formPublished: true }, next: ["listview.configure（默认视图已存在，勿 listview.create）", "field.update（表单层条件）"] },
+    refusalRecovery: [{ code: "capability-out-of-coverage", action: "先发布字段再发表单" }, ...commonRecovery],
+    requiresEnvironmentDerivedIds: false,
+});
+const numericTwoDecimals = Object.freeze({
+    id: "numeric-two-decimals",
+    title: "数值字段（金额，两位小数 / 整数）— scale 必填",
+    status: "offline-valid",
+    tool: "field.create",
+    args: { environment, schemaCode: model, code: "apply_amount", name: "申请金额", propertyType: "NUMERICAL", options: { scale: 3 } },
+    preconditions: ["模型已存在"],
+    conditionalRequirements: ["NUMERICAL 必须显式 options.scale：scale = 小数位数（0=整数, 1=1位, 2=2位 … 8=8位）；缺 scale 门户显示裸 decimal 且工具会拒绝。"],
+    priorToolReferences: [{ tool: "discover_environment", args: { environment }, purpose: "确认目标模型已存在" }],
+    dryRun: { supported: true, command: `omc call field.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验 propertyType/scale/治理，不创建" },
+    expectedReadback: { readback: { draftFieldPresent: true }, next: ["field.publish"] },
+    refusalRecovery: [{ code: "capability-out-of-coverage", action: "NUMERICAL 必须带 options.scale；金额两位小数用 scale:2，整数用 scale:0" }, ...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: "leave_reason",
+        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,
+});
+// --- Form-interaction conditions (FIELD options) --------------------------
+// Reproduced live 2026-09-22 (Playwright, dogfood `local`): a datarule row did
+// NOT block the portal form; setting these field options did (red required
+// marker + "Please input ..." + submit blocked + 0 rows). The condition string
+// uses the SERIALIZED Chinese operators (等于/大于/不为空/…); symbols also work.
+const formConditionalRequired = Object.freeze({
+    id: "form-conditional-required",
+    title: "表单层条件必填：金额大于阈值时说明必填（字段 options）",
+    status: "requires-prior-readback",
+    tool: "field.update",
+    args: {
+        environment,
+        schemaCode: model,
+        code: "leave_reason",
+        name: "请假事由",
+        options: { requiredFormula: '{leave_amount} 大于 {"valueType":"custom","value":5000}' },
+    },
+    preconditions: ["目标字段与作为条件的字段都已发布", "这是门户表单交互层（真实门户打开表单、改条件字段值来验证控件是否变必填）；**不要用 datarule.create**——实测 type4 不会让门户控件变必填，且符号式经 historyOpt 会让表单渲染崩溃"],
+    conditionalRequirements: ["条件串：`{字段} 操作符 [值]`（操作符两侧留空格）。操作符用**中文**（真实设计器产出）：等于/不等于/大于/小于/大于等于/小于等于/包含/不包含/包含全部/包含任意一个/等于任意一个/为空/不为空；也接受符号 == != > >= <= Contains IsEmpty。为空/不为空**不带值**（`{reason} 不为空`），其余带 JSON 值 {\"valueType\":...,\"value\":...}。多条件用 ` && `、多组用 ` || `。**不是** eq/gt/isnull——会让门户渲染 SyntaxError"],
+    priorToolReferences: [{ tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认条件字段与目标字段都已发布" }],
+    dryRun: { supported: true, command: `omc call field.update --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验字段 options 形状，不写入" },
+    expectedReadback: { readback: { field: { code: "leave_reason", options: { requiredFormula: "<protocol>" } } }, next: ["field.publish", "form.draft(rebuild)", "form.publish"] },
+    refusalRecovery: [
+        { code: "capability-out-of-coverage", action: "条件串用中文或符号操作符（等于/大于/不为空 或 == />/IsEmpty）；恒必填用字面量 \"true\"" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: false,
+});
+const formAlwaysReadonly = Object.freeze({
+    id: "form-always-readonly",
+    title: "表单层恒只读字段（字段 options.readonlyFormula:true）",
+    status: "offline-valid",
+    tool: "field.update",
+    args: { environment, schemaCode: model, code: "approval_level", name: "审批级别", options: { readonlyFormula: true } },
+    preconditions: ["目标字段已发布"],
+    conditionalRequirements: ["恒只读用布尔 readonlyFormula:true；条件只读用 readonlyCondition 条件串"],
+    priorToolReferences: [{ tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认字段已发布" }],
+    dryRun: { supported: true, command: `omc call field.update --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验 readonlyFormula 是布尔", },
+    expectedReadback: { readback: { field: { code: "approval_level", options: { readonlyFormula: true } } }, next: ["field.publish", "form.draft(rebuild)", "form.publish"] },
+    refusalRecovery: [{ code: "capability-out-of-coverage", action: "readonlyFormula 必须是布尔 true；条件只读才用 readonlyCondition" }, ...commonRecovery],
+    requiresEnvironmentDerivedIds: false,
+});
+const formConditionalReadonly = Object.freeze({
+    id: "form-conditional-readonly",
+    title: "表单层条件只读（字段 options.readonlyCondition）",
+    status: "offline-valid",
+    tool: "field.update",
+    args: {
+        environment,
+        schemaCode: model,
+        code: "approval_level",
+        name: "审批级别",
+        options: { readonlyCondition: '{status} 等于 {"valueType":"specifyOption","value":"已通过"}' },
+    },
+    preconditions: ["目标字段与条件字段已发布"],
+    conditionalRequirements: ["条件串协议同必填；恒只读改用 readonlyFormula:true"],
+    priorToolReferences: [{ tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认字段已发布" }],
+    dryRun: { supported: true, command: `omc call field.update --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验条件串协议" },
+    expectedReadback: { readback: { field: { code: "approval_level", options: { readonlyCondition: "<protocol>" } } }, next: ["field.publish", "form.draft(rebuild)", "form.publish"] },
+    refusalRecovery: [{ code: "capability-out-of-coverage", action: "使用中文或符号操作符与三段条件串" }, ...commonRecovery],
+    requiresEnvironmentDerivedIds: false,
+});
+const restfulQueryService = Object.freeze({
+    id: "restful-query-service",
+    title: "注册 RESTFUL 查询服务 + 一个方法（含参数面）",
+    status: "requires-prior-readback",
+    tool: "service.register",
+    args: {
+        environment,
+        serviceCode: "<service_code>",
+        name: "供应商查询服务",
+        adapterCode: "RESTFUL",
+        serviceCategoryId: "<category.id>",
+        serviceConfig: {
+            auth: { code: "customer", parameterlist: [] },
+            commonlist: [{ code: "url", value: "http://<host>/api" }],
+        },
+        methodName: "querySupplier",
+        methodConfig: { httpType: "Post", requestBodyType: "JSON", url: "/supplier/query", frontEndExtensionEnable: true },
+        methodInputParameters: [{ code: "keyword", name: "关键字", required: true, configJson: { position: "REQUEST_BODY" } }],
+        methodOutputParameters: [{ code: "name", name: "供应商名称", configJson: { position: "REQUEST_BODY" } }],
+    },
+    preconditions: ["serviceCategoryId 由 service.category.list 解析（「全部」是空 id 虚拟项不可用）；RESTFUL 服务 configJson 需要 auth 与 commonlist[url]；带 methodName 时必须有 methodConfig"],
+    conditionalRequirements: [
+        "RESTFUL auth.code ∈ customer(parameterlist=[]) / basic(client… username/password) / oauth_password / oauth_client；parameterlist 每项 {code,value} 且必须与 auth.code 期望参数完全一致",
+        "RESTFUL 方法 configJson 必需键：httpType(Post/Get/Put/Patch/Delete)、requestBodyType(Form-urlencoded/JSON/Text)、url、frontEndExtensionEnable(布尔)",
+        "RESTFUL 每个输入/输出参数必须带 configJson.position ∈ QUERY_PARAMS/REQUEST_HEADER/REQUEST_BODY/PATH_PARAMS（URL_VARIABLE 被运行时拒 501007）",
+        "一次写只建一个方法；给既有服务加方法走 method.create（escape hatch）",
+    ],
+    priorToolReferences: [
+        { tool: "service.category.list", args: { environment }, purpose: "取服务分类 id（所属目录必填）" },
+        { tool: "service.adapter_config", args: { environment }, purpose: "确认 RESTFUL 适配器的 commonList/authList 必需键与当前实例一致" },
+    ],
+    dryRun: { supported: true, command: `omc call service.register --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 做 adapter/serviceConfig/methodConfig/参数面本地预检，零 wire；用它一次性看清缺哪个键" },
+    expectedReadback: { performed: { errcode: 0 }, readback: { servicePresent: true, methodPresent: true, methodCount: 1 }, next: ["service.get 复核（凭据已脱敏）"] },
+    refusalRecovery: [
+        { code: "bizservice-service-config-invalid", action: "serviceConfig 需要 auth{code,parameterlist[]}+commonlist[{code:'url',value}]；按消息补键" },
+        { code: "bizservice-method-config-invalid", action: "methodConfig 需要 httpType/requestBodyType/url/frontEndExtensionEnable 四键" },
+        { code: "bizservice-parameter-face-invalid", action: "每个参数补 configJson.position；URL_VARIABLE 换 QUERY_PARAMS/REQUEST_BODY" },
+        { code: "bizservice-required-field-missing", action: "name/adapterCode/serviceCategoryId 是设计器必填；分类 id 不能为空" },
+        { code: "duplicate-service", action: "serviceCode 已存在；改用 service.update" },
+        { code: "bizservice-adapter-not-whitelisted", action: "写面仅 RESTFUL/DATA_SQL/DATA_TABLE/SAP/KAFKA/SOAP；INTERNAL 走二开扩展包" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: true,
+    prerequisiteData: { source: "service.category.list", fields: ["category.id"] },
+});
+const fieldSerialNumber = Object.freeze({
+    id: "field-serial-number",
+    title: "单据号字段：表单 Serial Number 控件（seqNoSetting 分段构建器，按天/月/年重置原生）——不要落 SequenceService SPI 二开",
+    status: "offline-valid",
+    tool: "field.update",
+    args: {
+        environment,
+        schemaCode: "crm_contract",
+        code: "<字段 code>",
+        name: "合同编号",
+        options: {
+            formPropertyType: 100,
+            seqNoSetting: [
+                { type: "CONSTANT", value: "CT-" },
+                { type: "DATE", value: "yyyyMMdd" },
+                { type: "CONSTANT", value: "-" },
+                { type: "SEQNO", value: { startValue: 1, maxLength: 4, leftPad: true, resetDate: "DAY" } },
+            ],
+        },
+    },
+    preconditions: [
+        "需求是**编号自动生成**（前缀/日期/流水/按期重置），不是人工填写的编号字段——人工填写用普通短文本，别用本配方。",
+        "**单据号=表单 Serial Number 控件（字段类型 100 SequenceNo）**，不是 SHORT_TEXT 字段 + SequenceService SPI 二开（r5-crm 实证：SPI 路线在 8.6.26 无触发配置可写、属重造轮子；表单控件开箱即用）。",
+    ],
+    conditionalRequirements: [
+        "seqNoSetting 是**段数组**（分段构建器，顺序即拼接序）：CONSTANT（固定前缀/分隔）/ DATE（value=Java 格式串 yyyyMMdd 等）/ SEQNO（流水）/ DATAITEM（取行内字段值）/ UID。设计师入口=控件属性「Document Number Configuration」。",
+        "SEQNO 段：startValue（起始）、maxLength（位数）、leftPad（补零）、**resetDate（重置策略 NONE/DAY/MONTH/YEAR——按天重置是原生能力）**。",
+        "写完必须 `field.publish` + `configure_form`（rebuild:true）重建表单并发布，控件才落到表单 attributes 的 options.seqNoSetting。",
+        "**编号生成时机=submit（表单提交管线）**：`data.save`（含 submit:true）不生成编号、行落 DRAFT；直接 `data.submit`（不带 bizObjectId=新建并提交）生成编号且行 COMPLETED（r5-crm 真机：CT-20261009-0001→0002 双跑）。",
+        "验证：连续两次 data.submit，编号应 +1 且格式符合段拼接；跨天重置由 resetDate 保证（勿自建 Redis 计数）。",
+    ],
+    priorToolReferences: [{ tool: "field.get", args: { environment, schemaCode: "<模型>", code: "<字段 code>" }, purpose: "确认字段存在且未配置过 seqNoSetting" }],
+    dryRun: { supported: true, command: `omc call field.update --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验 options 形状，零 wire" },
+    expectedReadback: { performed: { errcode: 0 }, readback: { fieldPresent: true, optionsContain: "seqNoSetting+formPropertyType:100" }, next: ["data.submit 双跑 → 编号 0001/0002、行 COMPLETED"] },
+    refusalRecovery: [
+        { code: "field-options-freeform", action: "options 是自由对象——形状错误不会被出门校验拦，务必对照本配方逐键核对（type 全大写、resetDate 大写枚举）" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: false,
+});
+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 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 bizserviceSelfCallCorp = Object.freeze({
+    id: "bizservice-self-call-corp",
+    title: "业务规则自调本实例：oauth_password 为基础；X-LowCode-Corpid 头视环境而定（token 是否自带 corpId，8.5+ 部分配置才需要）——非铁律，真机判定",
+    status: "offline-valid",
+    tool: "method.update",
+    args: {
+        environment,
+        serviceCode: "<service_code>",
+        methodCode: "<method_code>",
+        inputParameters: [
+            { code: "X-LowCode-Corpid", name: "corpId头", required: false, codeType: 0, bizCode: "<corpId 常量值>", configJson: { position: "REQUEST_HEADER" } },
+        ],
+    },
+    preconditions: [
+        "自调本实例（commonlist.url 指回本平台 /api）鉴权以 oauth_password 为基础（Authorization Bearer）。**X-LowCode-Corpid 头非铁律**：token 自带 corpId claim 的环境（生产多数）不配任何 corpid；token corpId=null 的环境（本沙盒 api 客户端；8.5+ 部分配置）缺头会 HTTP 200 但响应体 errcode:50000（corpId can not be blank，r5 实测 2026-10-10）。",
+        "**判定法（先做再配）**：带 token 直调一次扩展端点看**响应体 errcode**（HTTP 200 不代表成功，平台错误包在体里）；errcode:0 则不配 corpid；errcode:50000 则按本配方补方法参数（code=X-LowCode-Corpid、configJson.position=REQUEST_HEADER、codeType:0 CONST、值放 bizCode——平台注入，调用方无需传；手动 curl 加请求头即可）。",
+        "出站第三方接口按对方要求配鉴权，与本配方无关。",
+    ],
+    conditionalRequirements: [
+        "**参数 code 必须精确等于 `X-LowCode-Corpid`**——适配器按「参数 code = header 名」加入请求头（headerParam.add(key, value)）。",
+        "**corpid 传递有两种实证形状**：①方法级入参 code 为 X-LowCode-Corpid、configJson.position 为 REQUEST_HEADER 整数 2（r3-wms 实证可用）；②规则 BIZ_ACTION 的 inputMappings 加 CONST 映射（serviceMethodParameterCode 为 X-LowCode-Corpid、codeType 为 0、bizCode 放真实 corpId——r4-fin 实证：该环境下方法级 position:2 注入为空头值 [\"\"]，此形状才生效）。**先用 ②，双跑验证头值；①失效（头空）就换 ②**。CONST 值必须放 bizCode（平台只读 bizCode）。",
+        "**corpid 头非空即可（r6-onlinejs R19 实证）**：沙盒 token corpId=null 时，全 0 corpId 头（RELEVANCE-0000…）也 errcode:0；仅空头才 50000。多租户路由才需真值。凭据值不可从读回抄（读面按 ticket 115 掩码为 ***），必须用任务环境事实真值（doctor 显示的 corpId、任务提供的 client_secret）。",
+        "configJson.position 用 REQUEST_HEADER 名即可（工具写侧编码为整数索引 2；wire 上是整数——写名字平台侧反序列化失败、header 根本不进，源码 @JsonCreator get(int)）。",
+        "BIZ_ACTION 节点调用该方法**无需传该常量参数**（方法级常量由平台注入）；只需照常映射业务参数。",
+    ],
+    priorToolReferences: [{ tool: "method.get", args: { environment, serviceCode: "<service_code>", methodCode: "<method_code>" }, purpose: "取现有参数面，update 时整组带回（含本常量头）" }],
+    dryRun: { supported: true, command: `omc call method.update --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验参数面/CONST 形状，零 wire" },
+    expectedReadback: { readback: { methodPresent: true, corpHeaderParam: "code=X-LowCode-Corpid position=REQUEST_HEADER(2) codeType=0 bizCode=<corpId>" }, next: ["BIZ_ACTION 规则触发后 E2E：被调接口不再回 50000 corpId can not be blank"] },
+    refusalRecovery: [
+        { code: "bizservice-parameter-face-invalid", action: "常量头也是参数：configJson.position=REQUEST_HEADER 必带" },
+        { code: "runtime-50000-corpId-blank", action: "header 仍空 = 常量值放错槽（须 bizCode）或参数 code 不是精确的 X-LowCode-Corpid；method.get 读回核对" },
+        { code: "bizservice-auth-credential-placeholder", action: "凭据被掩码/占位值守卫拦截——读回掩码 *** 或自造 RELEVANCE-xxx/全 0 不可注册；凭据必须从任务环境事实取真值（doctor 显示的 corpId、任务提供的 client_secret），不可从读回抄" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: false,
+});
+const listViewConfigure = Object.freeze({
+    id: "configure-default-list",
+    title: "配置模型的默认列表视图（列/排序；默认视图已自动存在）",
+    status: "requires-prior-readback",
+    tool: "listview.configure",
+    args: { environment, schemaCode: model, fieldCodes: ["apply_no", "apply_amount", "apply_note"] },
+    preconditions: ["字段已 field.publish（视图与表单脚手架都依赖已发布字段）", "默认视图在 model.create 时由平台自动生成，code = schemaCode"],
+    conditionalRequirements: [
+        "**省略 `code` 即配置默认视图（code = schemaCode）；不要先 listview.create——那会多出一个自定义视图。** 只有确实需要第二个视图时才 listview.create。",
+        "`fieldCodes` 只列业务字段，可给 propertyCode 或字段显示名；系统列由平台决定。未知引用被拒（listview-columns-unknown-field）。",
+        "数值列 displayFormat 由字段 0 基 `options.scale` 推导（0=整数,1=1位,2=2位…）；本工具会原地修正既有列的 displayFormat。",
+        "`query/update` 自动 publish=TRUE——视图无草稿/发布两态，无需独立发布步骤。",
+    ],
+    priorToolReferences: [
+        { tool: "listview.list", args: { environment, schemaCode: model }, purpose: "确认默认视图 code 与是否已有多视图" },
+        { tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认字段已发布" },
+    ],
+    dryRun: { supported: true, command: `omc call listview.configure --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 预检 fieldCodes/形状，不写" },
+    expectedReadback: { readback: { code: "<schemaCode>", added: ["apply_no", "apply_amount"], columns: "…" }, next: ["data.list 验证读面"] },
+    refusalRecovery: [
+        { code: "listview-columns-unknown-field", action: "字段未发布或名字写错；先 field.create + field.publish 或改引用" },
+        { code: "listview-not-found", action: "默认视图应已存在；用 listview.list 确认 code，必要时 listview.create" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: false,
+});
+const dataListFilter = Object.freeze({
+    id: "list-filter-equality",
+    title: "按等值条件读一批业务数据（filter DSL 的可运行最小形状）",
+    status: "offline-valid",
+    tool: "data.list",
+    args: { environment, schemaCode: model, filter: { op: "eq", field: "status", value: "OPEN" }, size: 20 },
+    preconditions: ["schemaCode 的字段已 field.publish（filter 叶子的 propertyType 从发布面读）"],
+    conditionalRequirements: [
+        "filter 是**一个**子句 `{op, field, value?}`；op ∈ eq/neq/gt/lt/gte/lte/like/notlike/in/notin/between/notbetween/isnull/isnotnull。",
+        "多条件 `filters:[…]`（AND）；分组 `filterGroup:{op:'and'|'or',clauses:[…]}`；系统/外部字段用 rawCondition。",
+    ],
+    priorToolReferences: [
+        { tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认要过滤的字段 code 已发布" },
+    ],
+    dryRun: { supported: false, command: `omc call data.list --env ${environment} --args '<recipe.args>'`, notes: "只读，无 dry-run；直接调用即读回" },
+    expectedReadback: { readback: { total: 1, rows: "…" } },
+    refusalRecovery: [{ code: "invalid-filter-DSL", action: "按错误里的 minimalValidFilter/acceptedOps 修正 op/field/value" }],
+    requiresEnvironmentDerivedIds: false,
+});
+const dictionaryKeyValue = Object.freeze({
+    id: "dictionary-key-value",
+    title: "建一个键值字典并用其 id 作字段下拉来源",
+    status: "offline-valid",
+    tool: "dictionary.save",
+    args: {
+        environment,
+        code: "visit_type",
+        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: "visit_type" }, 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: "visit_type", 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 EXECUTION_METADATA = Object.freeze({
+    "configure_model": Object.freeze({ recipes: [configureModelRecipe], relatedTools: ["discover_environment", "field.update", "listview.create", "listview.get"] }),
+    "configure_form": Object.freeze({ recipes: [configureFormRecipe], relatedTools: ["field.list", "field.update", "listview.create", "listview.get"] }),
+    "field.update": Object.freeze({ recipes: [fieldSerialNumber, formConditionalRequired, formAlwaysReadonly, formConditionalReadonly], relatedTools: ["field.list", "field.publish", "form.draft", "form.publish"] }),
+    "datarule.create": Object.freeze({ recipes: [submitCrossFieldCheck, dataruleCalcRule, dataruleSubtableSum, dataruleChildColumn, dataruleRequired, dataruleReadonly, dataruleDisplay], relatedTools: ["field.list", "datarule.list"] }),
+    "field.create": Object.freeze({ recipes: [numericTwoDecimals, dictionarySelection, childTable, businessModelDropdown], relatedTools: ["dictionary.names", "dictionary.records", "discover_environment", "field.list", "field.publish", "form.draft", "configure_form", "form.publish"] }),
+    "rule.save": Object.freeze({ recipes: [ruleGraph, ruleBranchGraph, ruleTimingTask, dataDuplicateFlag, ruleCrossModelCreate], relatedTools: ["field.list", "rule.get", "rule.enable"] }),
+    "dictionary.save": Object.freeze({ recipes: [dictionaryKeyValue], relatedTools: ["dictionary.names", "dictionary.records", "field.create"] }),
+    "workflow.update": Object.freeze({ recipes: [workflowTemplateUpdate, workflowConditionalBranch], relatedTools: ["workflow.get_draft", "workflow.publish"] }),
+    "workflow.bindRule": Object.freeze({ recipes: [workflowBinding], relatedTools: ["workflow.create", "workflow.get_draft", "workflow.get_published", "rule.list"] }),
+    "data.save": Object.freeze({ recipes: [workflowSave], relatedTools: ["workflow.get_published", "data.submit", "workitem.list"] }),
+    "data.submit": Object.freeze({ recipes: [workflowSubmit], relatedTools: ["data.save", "workitem.list", "data.load"] }),
+    "service.register": Object.freeze({ recipes: [restfulQueryService], relatedTools: ["service.category.list", "service.adapter_config", "service.get", "method.get"] }),
+    "method.update": Object.freeze({ recipes: [bizserviceSelfCallCorp], relatedTools: ["method.get", "method.create", "service.get"] }),
+    "listview.configure": Object.freeze({ recipes: [listViewConfigure], relatedTools: ["listview.list", "listview.get", "field.list", "field.publish"] }),
+    "data.list": Object.freeze({ recipes: [dataListFilter], relatedTools: ["data.load", "data.delete", "listview.configure", "field.list"] }),
+});
+export function executionMetadataFor(tool) {
+    return EXECUTION_METADATA[tool.name];
+}
+//# sourceMappingURL=execution-metadata.js.map