@stalfh233/omc-cli 0.6.6 → 0.6.10

package/dist/read.js

@@ -116,6 +116,11 @@ export async function governedRead(ctx, tool, args, execute, options = {}) {
  * 真实数据在 detailFile 指向的 artifact 里，根键与内联一致（list=items、load=data）。
  */
 function externalizedShapePlaceholders(result, dropped) {
+    // r26b：什么都没折叠时不要宣称 `truncated:true`——`model.list` 曾出现
+    // `truncated:true` + `truncatedKeys:[]`（models 已按 code｜name 内联），
+    // 自相矛盾的标记会让调用方以为还得去 artifact 取。
+    if (dropped.length === 0)
+        return {};
     const placeholders = { truncatedKeys: [...dropped], truncated: true };
     for (const key of dropped)
         placeholders[key] = Array.isArray(result[key]) ? [] : null;
@@ -127,14 +132,11 @@ function droppedShapeKeys(result, payload) {
 function compactReadback(result) {
     const compact = {};
     for (const [key, value] of Object.entries(result)) {
-        if (BULKY_READ_KEYS.has(key)) {
-            compact[`${key}Count`] = Array.isArray(value) ? value.length : value && typeof value === "object" ? Object.keys(value).length : 0;
-        }
-        else if (ACTIVITY_LIST_KEYS.has(key) && Array.isArray(value)) {
-            compact[key] = value.map(activityOfEntry).filter((entry) => entry !== undefined);
-            compact[`${key}Count`] = value.length;
-        }
-        else if (CODE_NAME_LIST_KEYS.has(key) && Array.isArray(value)) {
+        // r26b 读回体积审计（2026-11-05）：分支顺序曾让 CODE_NAME_LIST_KEYS 对 `models`
+        // 变成死代码——`models` 同时在 BULKY_READ_KEYS 里，而那个分支排在最前，于是
+        // 永远只回 `modelsCount:30` + `models:[]`，调用方拿不到任何 schemaCode，被迫
+        // 再花一次 `--jq`/artifact（997 B + 一整轮）。保形分支必须先于折叠分支。
+        if (CODE_NAME_LIST_KEYS.has(key) && Array.isArray(value)) {
             const pairs = value.map(codeNameOfEntry).filter((entry) => entry !== undefined);
             // 40 对上限（~1-2KB）：更大的清单回退 count+artifact，保冷启动可扫又不失控
             if (pairs.length <= 40)
@@ -151,8 +153,37 @@ function compactReadback(result) {
             compact[key] = value.map(codeOfEntry).filter((entry) => entry !== undefined);
             compact[`${key}Count`] = value.length;
         }
+        else if (ACTIVITY_LIST_KEYS.has(key) && Array.isArray(value)) {
+            compact[key] = value.map(activityOfEntry).filter((entry) => entry !== undefined);
+            compact[`${key}Count`] = value.length;
+        }
+        else if (BULKY_READ_KEYS.has(key)) {
+            compact[`${key}Count`] = Array.isArray(value) ? value.length : value && typeof value === "object" ? Object.keys(value).length : 0;
+        }
         else {
-            compact[key] = summarizeValue(value);
+            // r28a 真机（2026-11-05）：`summarizeValue` 对数组给 `{count}`、对对象给
+            // `{keys}`，两套占位形状本身没有「数据不在我这里」的语义——`count: 8`
+            // 读起来像"已经给你 8 条"。同一个逻辑清单（dictionary.names 回数组、
+            // dictionary.list 回分页对象）于是给出两种自相矛盾的占位。
+            // 这里统一补 `omitted:true`（真实数据在 detailArtifactId），不动
+            // summarizeValue 本身——它还服务于 dry-run 的 argsSummary，那里"摘要"
+            // 才是正确语义。
+            // r28a 的 omitted 补丁有副作用（本轮全量门抓到）：`summarizeValue` 对**任何**
+            // 对象都给 `{keys}`，连只有 3 个键的小对象也不例外——`model.list` 的
+            // `applicationResolution: {code, source, applicationCount}` 由此变成
+            // `{keys, sha256, omitted}`，而它正是「零命中只代表这一个应用」的唯一证据。
+            // 规则：小对象（≤4 键且 ≤200B）原样内联——折叠它是纯损失，不是省字节。
+            const small = value !== null && typeof value === "object" && !Array.isArray(value)
+                && Object.keys(value).length <= 4
+                && Buffer.byteLength(JSON.stringify(value), "utf8") <= 200;
+            if (small) {
+                compact[key] = value;
+                continue;
+            }
+            const summarized = summarizeValue(value);
+            compact[key] = summarized !== null && typeof summarized === "object" && !Array.isArray(summarized)
+                ? { ...summarized, omitted: true }
+                : summarized;
         }
     }
     return compact;

package/dist/recipes/businessrule.js

@@ -12,21 +12,20 @@ const ruleGraph = Object.freeze({
         nodeGraph: {
             nodes: [
                 { nodeCode: "Start", nodeType: "START" },
-                { nodeCode: "Create", nodeName: "新增数据", nodeType: "SYSTEM_CREATE", isSystemNode: true },
                 { 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: "End", nodeType: "END" },
             ],
             routes: [
-                { preNode: "Start", postNode: "Create" },
-                { preNode: "Create", postNode: "UPDATE_1" },
+                { preNode: "Start", postNode: "UPDATE_1" },
                 { preNode: "UPDATE_1", postNode: "End" },
             ],
         },
         publish: true,
     },
-    preconditions: ["模型和 target field 已发布；Create 是平台预置触发规则；目标字段可由规则动作写入"],
+    preconditions: ["模型和 target field 已发布；Create 是平台预置触发规则；目标字段可由规则动作写入；**系统节点（SYSTEM_CREATE）由工具注入，不要手写**"],
     conditionalRequirements: [
-        "**自更新 UPDATE 必须排在 SYSTEM_CREATE 之后**（Start→SYSTEM_CREATE→UPDATE→End）——排在前面时规则能存能启用，运行时 `UpdateServiceExecutor` 查不到触发行（日志「查找范围不存在数据，不再做修改数据动作」），字段静默不写回。真机对照 2026-10-20：UPDATE 在 SYSTEM_CREATE 前 → 值不变；挪到其后 → 值写入成功。注意与 ASSIGN/BIZ_ACTION 相反，那两类要排在系统节点之前。",
+        "**系统节点由工具注入，不要手写 `SYSTEM_CREATE/SYSTEM_UPDATE/SYSTEM_DELETE`**——调用方传入会被 `rule-graph-system-node-tool-owned` 忽略后按 ruleCode 重注；手拼只写 Start→UPDATE→End。",
+        "**自更新 UPDATE 必须排在 SYSTEM_CREATE 之后**（工具注入后最终形 Start→SYSTEM_CREATE→UPDATE→End）——排在前面时规则能存能启用，运行时 `UpdateServiceExecutor` 查不到触发行（日志「查找范围不存在数据，不再做修改数据动作」），字段静默不写回。真机对照 2026-10-20：UPDATE 在 SYSTEM_CREATE 前 → 值不变；挪到其后 → 值写入成功。注意与 ASSIGN/BIZ_ACTION 相反，那两类要排在系统节点之前。",
         "BIZ_ACTION 的 outputMappings 必须在 SYSTEM_CREATE/SYSTEM_UPDATE 前被消费；自定义 ruleCode 不会被数据事件自动分发",
     ],
     priorToolReferences: [
@@ -59,15 +58,13 @@ const ruleBranchGraph = Object.freeze({
         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: "Start", postNode: "Branch_1" },
                 { preNode: "Branch_1", postNode: "UPDATE_BIG" },
                 { preNode: "Branch_1", postNode: "UPDATE_NORMAL", routeCondition: false },
                 { preNode: "UPDATE_BIG", postNode: "End" },
@@ -76,12 +73,13 @@ const ruleBranchGraph = Object.freeze({
         },
         publish: true,
     },
-    preconditions: ["模型和 target field（level/amount）已发布；Create 是平台预置触发规则；目标字段可由规则动作写入"],
+    preconditions: ["模型和 target field（level/amount）已发布；Create 是平台预置触发规则；目标字段可由规则动作写入；**系统节点由工具注入，不要手写**"],
     conditionalRequirements: [
-        "**系统节点顺序：BRANCH 必须排在 `SYSTEM_CREATE` 之后**——BRANCH 直接接在 START 后会运行时静默不生效、动作不回写（工具 fail closed）。注意这与 BIZ_ACTION 回写场景相反（那里系统节点要在动作之后）——本 recipe 是分支场景。**`SYSTEM_CREATE` 必须显式写**（工具对分支图的自动注入不可靠）。",
+        "**系统节点由工具注入，不要手写 `SYSTEM_CREATE/SYSTEM_UPDATE/SYSTEM_DELETE`**——调用方传入会被 `rule-graph-system-node-tool-owned` 忽略，再按 ruleCode 重新注入并接到 START 之后。手拼时写 `Start→Branch_1→…` 即可，工具会补上 Create 边。",
+        "**系统节点顺序：BRANCH 必须排在 `SYSTEM_CREATE` 之后**——BRANCH 直接接在 START 后会运行时静默不生效、动作不回写（工具 fail closed）。注意这与 BIZ_ACTION 回写场景相反（那里系统节点要在动作之后）——本 recipe 是分支场景。",
         "**出口条件叶只 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` 需显式。**跨模型写（`targetObjectCode`≠规则模型）已真机验证可用**（1.1.25，2026-10-21：FIXED id / 文本字段 / 单跳关联字段三种 DYNAMIC 来源均命中）——前提是 ① 承载规则真的触发（Create 在提交时、Update 在 data.update、或绑流程事件）；② **目标行必须已提交（COMPLETED）**，DRAFT 行不参与查询（日志「查找范围不存在数据」）。点号路径按子表解析：`关联字段.id` 与两跳 `a.b` 不可用。",
-        "预置规则的系统节点类型必须与 ruleCode 匹配（Create→SYSTEM_CREATE）；放 SYSTEM_UPDATE 会 data.submit 50000（工具 fail closed）。",
+        "预置规则的系统节点类型必须与 ruleCode 匹配（Create→SYSTEM_CREATE）；工具按 ruleCode 注入，手写错类型会被忽略后重注。",
     ],
     priorToolReferences: [
         { tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认 amount/level 已发布" },
@@ -100,10 +98,63 @@ const ruleBranchGraph = Object.freeze({
     requiresEnvironmentDerivedIds: false,
     prerequisiteData: { source: "field.list(published:true)", note: "ruleCode=Create 为平台预置代码" },
 });
+/**
+ * r28c 真机（2026-11-05）：探针要写「金额 > 5000 则 approvedAmount = amount*0.8」，
+ * 但 `rule.save --example business-rule-branch-conditional` 的两条分支全是 FIXED，
+ * EXPRESSION 的写法只在 `--full` 的描述里提了一句「ruleValueType ∈ …/EXPRESSION/…」，
+ * 没有一条可运行样例 → 探针只能猜 `value` 是字符串，猜错。
+ *
+ * 这条把「固定条件 + 公式动作」的最小形状钉死：EXPRESSION 的 `value` 是
+ * **对象** `{formula:"<表达式>"}`，不是字符串。
+ */
+const ruleConditionFormula = Object.freeze({
+    id: "rule-condition-formula-action",
+    title: "条件成立时按公式赋值（EXPRESSION action）",
+    // r28c：alias 要**窄**。"计算规则" 曾把 compute composer 的
+    // 「字段计算规则/子表求和回填」路由抢走（next-first-answer 的 G2 断言
+    // 由 needs-input 退化成 ready）——那是字段级 compute 的地盘，不是业务规则。
+    aliases: ["按比例赋值", "公式赋值", "百分比", "乘以", "按公式赋值"],
+    status: "requires-prior-readback",
+    tool: "rule.save",
+    args: {
+        environment,
+        schemaCode: model,
+        ruleCode: "Create",
+        name: "大额按比例赋值",
+        nodeGraph: {
+            nodes: [
+                { nodeCode: "Start", nodeType: "START" },
+                { nodeCode: "Branch_1", nodeType: "BRANCH", sourceInputMethod: "PRE_OUT", exitConditionGroups: [[{ currentSchemaDataItem: "amount", ruleDataConditionType: "GT", ruleValueType: "FIXED", value: 5000 }]] },
+                // **关键**：EXPRESSION 的 value 是对象 {formula}，不是字符串。
+                { nodeCode: "UPDATE_FORMULA", nodeType: "UPDATE", targetObjectCode: model, dataActions: [{ targetDataItem: "approvedAmount", ruleValueType: "EXPRESSION", ruleActionType: "EQUALS", value: { formula: "{amount}*0.8" } }] },
+                // 只引用字段（不运算）用 DYNAMIC + currentDataItemValue。
+                { nodeCode: "UPDATE_FULL", nodeType: "UPDATE", targetObjectCode: model, dataActions: [{ targetDataItem: "approvedAmount", ruleValueType: "DYNAMIC", ruleActionType: "EQUALS", value: "", currentDataItemValue: "amount" }] },
+                { nodeCode: "End", nodeType: "END" },
+            ],
+            routes: [
+                { preNode: "Start", postNode: "Branch_1" },
+                { preNode: "Branch_1", postNode: "UPDATE_FORMULA" },
+                { preNode: "Branch_1", postNode: "UPDATE_FULL", routeCondition: false },
+                { preNode: "UPDATE_FORMULA", postNode: "End" },
+                { preNode: "UPDATE_FULL", postNode: "End" },
+            ],
+        },
+        publish: true,
+    },
+    preconditions: ["amount/approvedAmount 已发布；Create 是平台预置触发规则，**系统节点（SYSTEM_CREATE）由工具注入，不要手写**"],
+    priorToolReferences: [{ tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认 amount/approvedAmount 已发布" }],
+    conditionalRequirements: [
+        "EXPRESSION 的 `value` 必须是对象 `{formula:\"{amount}*0.8\"}`（字符串会被 dry-run 以 `rule-graph-expression-value-shape` 拒绝）；纯字段引用用 DYNAMIC + currentDataItemValue，value 留空串",
+        "**系统节点由工具注入，不要手写 `SYSTEM_CREATE/SYSTEM_UPDATE`**——传了会被 `rule-graph-system-node-tool-owned` 忽略后重新注入；手拼图只写 Start→Branch→UPDATE→End",
+    ],
+    dryRun: { supported: true, command: `omc call rule.save --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 的图 lint 会拦公式形状错误" },
+    expectedReadback: { performed: { published: true }, readback: { next: "rule.enable 后造两条数据验 approvedAmount" } },
+    refusalRecovery: [{ code: "rule-graph-expression-value-shape", action: "把 value 从字符串改成 {formula:\"...\"} 对象" }, ...commonRecovery],
+    requiresEnvironmentDerivedIds: false,
+});
 const ruleTimingTask = Object.freeze({
     id: "rule-timing-task",
-    title: "定时任务：每天/周期触发规则（TIMING_TASK，SCHEDULER 节点，配置能力）",
-    status: "offline-valid",
+    title: "定时任务：每天/周期触发规则（TIMING_TASK，SCHEDULER 节点，配置能力）", status: "offline-valid",
     tool: "rule.save",
     args: {
         environment,
@@ -263,13 +314,11 @@ const dataDuplicateFlag = Object.freeze({
             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 },
+                { preNode: "A1", postNode: "End", routeCondition: true },
             ],
         },
         publish: true,
@@ -281,8 +330,9 @@ const dataDuplicateFlag = Object.freeze({
         "**改写的是预置 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: [
+        "**系统节点由工具注入，不要手写 `SYSTEM_CREATE`**——本 recipe 只写 Start→BIZ_ACTION→End；工具按 Create 规则注入 SYSTEM_CREATE 并排在 BIZ_ACTION 之后（ASSIGN/BIZ_ACTION 必须在系统节点前）。",
         "**为什么不是规则图内 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 之前。",
+        "预置规则改写要点：最终生效图必须含与 ruleCode 匹配的 SYSTEM_CREATE（工具注入）；BIZ_ACTION 插在 START 之后、SYSTEM_CREATE 之前。",
         "写完 `rule.enable`；**验证**：data.save 同键两条 → 既有那条带标记、新提交那条干净；无代码场景用仅键匹配覆盖。",
         "掩码/占位值（RELEVANCE-全 0、全 0 id、整值 <…>、未替换 ${var}）会被 rule-graph-masked-or-placeholder-value 出门拦截——从回读复制常量时取真实值。",
     ],
@@ -313,13 +363,11 @@ const ruleCrossModelCreate = Object.freeze({
         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: "Start", postNode: "C1", routeCondition: true },
                 { preNode: "C1", postNode: "End", routeCondition: true },
             ],
         },
@@ -328,8 +376,10 @@ const ruleCrossModelCreate = Object.freeze({
     preconditions: [
         "目标模型与目标字段已存在并发布；触发字段存在",
         "**`targetObjectCode` 不能等于承载该 Create 触发规则的同一模型**（否则自触发死循环 → 运行时 550009「业务规则执行异常」；平台有时 publish 直接 550018）",
+        "**系统节点由工具按 ruleCode 注入**（Create→SYSTEM_CREATE / Update→SYSTEM_UPDATE）；手拼不要写 SYSTEM_*",
     ],
     conditionalRequirements: [
+        "**系统节点由工具注入，不要手写 `SYSTEM_CREATE/SYSTEM_UPDATE`**——本 recipe 只写 Start→CREATE→End；工具按承载规则的 ruleCode 注入对应系统节点。",
         "`originatorValueType` **必填**（DYNAMIC=触发字段 code / FIXED=完整用户对象 JSON 串）+ `originatorValue`；`dataActions` **必填**（目标字段映射）；缺任一 → rule.save 真机 50000。",
         "**`dataActions` 要把下游记录所需的业务字段逐条映射**（编号/日期/金额/状态/备注…），**别只挂一个关联 id**——否则下游记录其余字段全 null（真机 2026-10-08）。",
         "**`originatorValueType:\"DYNAMIC\"` 的 `originatorValue` 必须指向人员字段**（STAFF_SELECTOR 等）；指向文本/编号字段会致发起人错误或为空。",
@@ -374,13 +424,11 @@ const ruleBizactionInvokeService = Object.freeze({
             nodes: [
                 { nodeCode: "Start", nodeName: "开始", nodeType: "START" },
                 { nodeCode: "A1", nodeName: "调用服务并回写", nodeType: "BIZ_ACTION", inputParam: "_input", methodMapping: { schemaCode: model, serviceCode: "<svc>", serviceMethodCode: "<method>", inputMappings: [{ serviceMethodParameterCode: "<in_code>", codeType: 1, bizCode: "<src_field>", required: true }], outputMappings: [{ serviceMethodParameterCode: "<out_code>", codeType: 1, bizCode: "<dst_field>" }] } },
-                { 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 },
+                { preNode: "A1", postNode: "End", routeCondition: true },
             ],
         },
         publish: true,
@@ -388,8 +436,10 @@ const ruleBizactionInvokeService = Object.freeze({
     preconditions: [
         "模型与来源/目标字段已发布；服务与方法已注册（service.register 的 readback.method 直接给参数 code）",
         "方法出参类型（bizPropertyType）与目标字段类型匹配",
+        "**系统节点由工具注入，不要手写 SYSTEM_CREATE**",
     ],
     conditionalRequirements: [
+        "**系统节点由工具注入**——本 recipe 只写 Start→BIZ_ACTION→End；工具注入 SYSTEM_CREATE 并排在 BIZ_ACTION 之后（ASSIGN/BIZ_ACTION 必须在系统节点前）。",
         "**出参回写三前提（r28b 8 组实验定案，缺一出参恒 null 且节点日志仍 successful）**：① 响应 JSON 根级平铺出参键（信封嵌套如 {data:{...}} 静默不回写）② 挂预置 Create/Update 规则上下文（自定义规则/rule.run 不回写业务字段）③ 用 data.submit/data.update 触发（data.save 存草稿不触发）。回写是否成功只认 data.load 读字段，不认调用日志。",
         "codeType:1 = 映射模型字段（bizCode=字段 code）；codeType:0 = 常量（bizCode=常量值）；serviceMethodParameterCode 必须与方法声明的参数 code 逐字一致",
         "**接口响应必须在 JSON 根级**返回与出参 code 同名的键——嵌套在信封里（如 {data:{level}}）会静默映射不上（p7 实测；r28b 8 组实验全因信封端点失败，换平铺端点后 4 组一次全过）",
@@ -410,6 +460,6 @@ const ruleBizactionInvokeService = Object.freeze({
     requiresEnvironmentDerivedIds: true,
 });
 export const BUSINESSRULE_METADATA = Object.freeze({
-    "rule.save": Object.freeze({ recipes: [ruleGraph, ruleBranchGraph, ruleTimingTask, ruleTimingBizService, dataDuplicateFlag, ruleCrossModelCreate, ruleBizactionInvokeService], relatedTools: ["field.list", "rule.get", "rule.enable", "service.get"] }),
+    "rule.save": Object.freeze({ recipes: [ruleGraph, ruleBranchGraph, ruleConditionFormula, ruleTimingTask, ruleTimingBizService, dataDuplicateFlag, ruleCrossModelCreate, ruleBizactionInvokeService], relatedTools: ["field.list", "rule.get", "rule.enable", "service.get"] }),
 });
 //# sourceMappingURL=businessrule.js.map

package/dist/recipes/dictionary.js

@@ -22,13 +22,16 @@ const dictionaryKeyValue = Object.freeze({
         "字段侧用 `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 全量）" },
+        // r28a F5：names 不是全量权威面（平台 getDictionaryIdAndNames 覆盖可能 < searchDictionary）；
+        // 全量/防冲突用 list；names 只作轻量摘要。溢成 artifact 是 list/大结果读门行为，不是 names 特有承诺。
+        { tool: "dictionary.list", args: { environment, page: 1, size: 200 }, purpose: "全量清单 + 防 code/name 冲突（权威面；看顶层 total 或 dictionaries.totalElements；大结果可能溢成 artifact，用 --jq 'dictionaries.content[].code' / artifact get 定向取）" },
+        { tool: "dictionary.get", args: { environment, code: "visitType" }, purpose: "按 code 精确查存在性与 id（小结果；确认单个 code 优于扫清单）" },
+        { tool: "dictionary.names", args: { environment }, purpose: "轻量 id/code/name 摘要（平台端点覆盖可能小于 list；回执带 total+coverageNote——不能当全集）" },
     ],
     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）"] },
+    expectedReadback: { performed: { errcode: 0 }, readback: { present: true, dictionary: { id: "<dictionary.id>", code: "visitType" }, records: { totalElements: 3, content: [{ code: "phone" }, { code: "visit" }, { code: "online" }] }, orderNote: "records 顺序不保证与提交一致；顺序请用 sortKey（回读已按 sortKey 升序，同值再按 code）" }, next: ["field.create --example dictionary-backed-single-select（用回读的 id）"] },
     refusalRecovery: [
-        { code: "dictionary-create-duplicate", action: "code 已存在：从 dictionary.names 取 id 后改传 id 做更新" },
+        { code: "dictionary-create-duplicate", action: "code 已存在：从 dictionary.list / dictionary.get 取 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,

package/dist/recipes/form.js

@@ -13,7 +13,53 @@ const configureFormRecipe = Object.freeze({
     refusalRecovery: [{ code: "capability-out-of-coverage", action: "先发布字段再发表单" }, ...commonRecovery],
     requiresEnvironmentDerivedIds: false,
 });
+/**
+ * r28e F3（真机复现 2026-11-05）：`describe form.draft --param draftViewJson` 只有
+ * 一句散文「一行 N 个 code=N 列」，探针据此猜了 3 轮才写出可发布的布局。
+ * 这里给一个**最小可抄**的两列 + 末行整宽样例；形状由 `form-layout.ts`
+ * 的 validateFormLayout 把关（rows 必须是二维字符串数组、attrs 与 rows 覆盖一致、
+ * 控件 options 必须是对象而不是 JSON 字符串）。
+ */
+const formDraftTwoColumn = Object.freeze({
+    id: "two-column-layout",
+    title: "表单两列布局 + 末行整宽（draftViewJson/draftAttributesJson 最小形状）",
+    // 教训（r28c+r28e 各踩一次）：alias 必须**窄**。「自定义表单布局」
+    // 「表单布局形状」会把整包 ladder（model→form→listview→businessrule→onlinejs）
+    // 抢成单配方命中，于是 next 不再给 intent 主路径与方法论节。
+    aliases: ["两列布局", "两列表单", "整宽一行"],
+    status: "offline-valid",
+    tool: "form.draft",
+    args: {
+        environment,
+        schemaCode: model,
+        // 行分组 = 列分组：第一行两个控件（两列），第二行一个控件（整宽）。
+        draftViewJson: '[[\"visitNo\",\"customer\"],[\"remark\"]]',
+        draftAttributesJson: JSON.stringify({
+            visitNo: { key: "visitNo", type: 1, options: { name: "拜访单号", span: 12 } },
+            customer: { key: "customer", type: 1, options: { name: "客户", span: 12 } },
+            remark: { key: "remark", type: 1, options: { name: "备注", span: 24 } },
+        }, null, 0),
+    },
+    preconditions: ["visitNo/customer/remark 三个字段已 field.publish（布局只能引用已发布字段）", "两段 JSON 都是**字符串**（tool 参数是 string，不是对象）"],
+    conditionalRequirements: [
+        "**列数由行分组决定，不由 span 决定**：一行放几个 code 就是几列；span 只控制控件在行内的 24 栅格宽度，且必须与行分组自洽（两列 span:12+12，整宽 span:24）",
+        "draftAttributesJson 的每个控件的 `options` 必须是**对象**，不能是 JSON 字符串（否则运行时写 options.name_i18n 抛错、整页空白）",
+        "rows 与 attrs 的 code 集合必须一致，否则 `layout_coverage_mismatch`",
+        "改列数就改行分组、重写 attrs 的 span —— 不要只改 span",
+    ],
+    priorToolReferences: [{ tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认要摆的字段已发布" }],
+    dryRun: { supported: true, command: `omc call form.draft --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 会跑 validateFormLayout，形状不合规当场拒绝" },
+    expectedReadback: { performed: { hasDraft: true }, readback: { next: ["form.publish", "form.get full:true 验布局"] } },
+    refusalRecovery: [
+        { code: "layout_coverage_mismatch", action: "把 draftViewJson 里出现的每个 code 都补进 draftAttributesJson（反之亦然）" },
+        { code: "control_options_not_object", action: "把控件 options 从 JSON 字符串改成对象" },
+        { code: "form-field-not-published", action: "先 field.publish 再排布局" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: false,
+});
 export const FORM_METADATA = Object.freeze({
     "configure_form": Object.freeze({ recipes: [configureFormRecipe], relatedTools: ["field.list", "field.update", "listview.create", "listview.get"] }),
+    "form.draft": Object.freeze({ recipes: [formDraftTwoColumn], relatedTools: ["field.list", "field.publish", "form.get", "form.publish"] }),
 });
 //# sourceMappingURL=form.js.map

package/dist/recipes/runtime-data.js

@@ -38,7 +38,7 @@ const plainSubmit = Object.freeze({
         { code: "submit-biz-object-absent", action: "bizObjectId 在平台无行（304001）——回 data.save 重建草稿后再直提" },
         { code: "invalid-input", action: "带了 workItemId/workflowInstanceId 时必须同时带 bizObjectId（fail-closed）" },
     ],
-    notes: "r23 复盘修正：本配方曾教先 save 再 submit 两步——正确路径是无 id 一调（业务约定：正式数据一律 data.submit）。Create/Update 规则只在 COMPLETED 分发（DomainServiceImpl.java:240-248）；规则效果以提交读回/data.load 为准（data.load 参数名=bizObjectId，直接用提交读回的 objectId）。data.save 定位=草稿/暂存",
+    notes: "本配方曾教先 save 再 submit 两步——正确路径是无 id 一调（正式数据一律 data.submit）。Create/Update 规则只在 COMPLETED 分发（DomainServiceImpl:240-248）；效果以 data.load 读回为准（参数名=bizObjectId，用提交读回的 objectId）。data.save 定位=草稿/暂存",
     requiresEnvironmentDerivedIds: true,
 });
 const workflowSubmit = Object.freeze({
@@ -92,7 +92,8 @@ const dataDeleteSweep = Object.freeze({
     tool: "data.delete",
     args: { environment, schemaCode: model, bizObjectIds: ["<data.list 逐条 id>"] },
     preconditions: [
-        "先 data.list 取全量 ids（page 0 起、size 够大或翻页）；**submit 后平台会同时保留 DRAFT 与 COMPLETED 两类行（r30 实证 5 次提交 = 10 行），清理对象按 data.list 全量**",
+        "先 data.list 取全量 ids（`all:true` 才含 DRAFT；翻页取全），清理对象按 data.list 全量",
+        "**行数以 data.list total 为准，别按「N 提交=2N 行」外推**：带流程的 submit 原地推进同一行（r28b 实测 3→3）；双行只在平台另起草稿行时出现（r30 的 5→10）",
     ],
     conditionalRequirements: [
         "参数名是 `bizObjectIds`（数组）——不是 ids/bizObjectId（单条删除另有其参）",

package/dist/refusal-guidance.js

@@ -113,17 +113,41 @@ const FIX_FIRST_GATES = Object.freeze({
     "capability-out-of-coverage": "需求不在覆盖面内：这份拒绝就是答案——用 omc capabilities 核对运行时清单，不要换相近工具伪造实现",
     "version-family-evidence-missing": "平台版本证据缺失，写被关闭：先 omc doctor / discover_environment 取版本证据，非 8.6/1.1.25 家族按边界处理",
 });
-/** `tool-input-invalid` and friends: point at the refused tool's own describe. */
-function inputInvalidGuidance(toolName) {
+/**
+ * `tool-input-invalid` and friends: point at the refused **parameter**, not the
+ * whole tool. Whole-tool describe is 4 KB (`rule.save`) to 17 KB (`--full`);
+ * the failing path is already in `issues[].path`, so `--param <top key>` is
+ * 150–900 B and answers the actual question (HANDOFF §三.1-1).
+ */
+function inputInvalidGuidance(toolName, failedPath) {
     if (!toolName)
         return undefined;
+    const param = failedPath?.split(".")[0];
     return {
         whatWentWrong: "入参没过工具的 schema 校验（缺必填或类型不对）",
-        correctShape: "必填参数与类型见 command 指向的 describe（firstCall 自带最小可跑形状）",
-        command: `omc describe ${toolName}`,
+        correctShape: param === undefined
+            ? `必填参数与类型见 command 指向的 describe（firstCall 自带最小可跑形状）；要可运行的一整份参数用 omc describe ${toolName} --example`
+            : `只看失败的那个参数：omc describe ${toolName} --param ${param}（含类型/枚举/说明）；要可运行的一整份参数用 --example`,
+        command: param === undefined ? `omc describe ${toolName}` : `omc describe ${toolName} --param ${param}`,
         doNot: "不要盲目重试——同参数必然同拒绝",
     };
 }
+/** The first failed property path of a shape refusal, if the payload carries one. */
+function firstIssuePath(payload) {
+    const issues = payload.issues;
+    if (!Array.isArray(issues))
+        return undefined;
+    for (const issue of issues) {
+        if (issue === null || typeof issue !== "object")
+            continue;
+        const path = issue.path;
+        if (typeof path === "string" && path.length > 0)
+            return path;
+        if (Array.isArray(path) && path.length > 0)
+            return path.map((segment) => String(segment)).join(".");
+    }
+    return undefined;
+}
 /**
  * r19 p14 — the report BI boundary (`/dashboard/v1/*`). A deployment without
  * the report service answers every BI call with a gateway 502 (live p9
@@ -177,7 +201,7 @@ export function refusalRecovery(blocker, payload, options = {}) {
     if (fixFirst)
         return { whatWentWrong: String(payload.message ?? blocker).slice(0, 160), fixFirst };
     if (blocker === "tool-input-invalid")
-        return inputInvalidGuidance(options.toolName);
+        return inputInvalidGuidance(options.toolName, firstIssuePath(payload));
     return undefined;
 }
 /**

package/dist/rule-support.js

@@ -959,6 +959,14 @@ export async function executeRuleSaveWrite(session, args) {
     // readback therefore pins the CURRENT effective row id/version so callers
     // never have to guess which row the designer now renders.
     const versionNote = "同一 ruleCode 的更新会产生新规则记录 ID（旧 ID 仍可读、前端持旧 ID 显示旧图）；readback.id 是当前生效行（rule.get 请用它，或以 rule.list 同编码且 latestPublished:true 的新 ID 为准）";
+    // r28j F14 live: rule.save on an already-enabled preset Create returned
+    // published:false + enabled:true, nextAction only talked about designer
+    // visibility — but data.submit still ran the OLD published graph (77 vs 99).
+    // Same "保存≠生效" theme: draft save never becomes the runtime graph until
+    // publish (+ enable when the DRAFT switch needs flipping).
+    const saveNotEffectiveNextAction = enabled
+        ? "保存≠生效：本次只写了 DRAFT。规则虽 enabled:true，运行时仍跑上一版已发布图——请再 rule.enable（内部 publish + 翻 DRAFT 启用）或 rule.save 传 publish:true 后再 rule.enable，用 data.submit/data.load 核对新图副作用"
+        : "保存≠生效：本次只写了 DRAFT。rule.enable（businessrule/publish 出新版本 + 翻 DRAFT 启用开关）后规则才会分发；或 rule.save 传 publish:true 只发布（启用仍走 rule.enable）";
     const currentRow = async () => wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } })).data).find((item) => item.code === args.ruleCode);
     if (args.publish === true) {
         const row = await currentRow();
@@ -1029,6 +1037,11 @@ export async function executeRuleSaveWrite(session, args) {
             rulePresent: true,
             published: false,
             enabled,
+            // F14: enabled:true alongside published:false means the previous published
+            // graph is still what data events run — not the draft just saved.
+            effective: false,
+            requiresPublishAction: "rule.enable",
+            ...(existing?.defaultRule === true || PLATFORM_TRIGGER_RULE_CODES.has(args.ruleCode) ? { presetRule: true } : {}),
             ...(lintWarnings.length > 0 ? { lintWarnings } : {}),
             ...(lintHazards.length > 0 ? { lintHazards } : {}),
             customTrigger: customTriggerApplied,
@@ -1037,7 +1050,7 @@ export async function executeRuleSaveWrite(session, args) {
             ruleVersion: effective?.ruleVersion,
             latestPublished: effective?.latestPublished,
             ...(existing?.id ? { versionNote } : {}),
-            nextAction: "rule.enable 发布后设计器才可见（businessrule/publish 出新版本 + 翻 DRAFT 启用开关）；或 rule.save 传 publish:true 只发布",
+            nextAction: saveNotEffectiveNextAction,
         },
     };
 }

package/dist/rule-when.js

@@ -114,7 +114,7 @@ export async function cmdRuleWhen(args) {
     const name = flag("--name");
     const environment = flag("--env") ?? flag("--environment");
     const apply = args.includes("--apply");
-    const usage = '用法：omc rule-when --schema <模型> --on create|update --when "字段=值" [--when ...可多个,AND] --then "set:字段=值|{来源字段}|{公式}" [--then ...] [--apply]\n条件操作符：= != > < >= <= ~=（包含） !~（不包含）。默认 dry-run；--apply 保存并发布（rule.enable 仍需显式执行）。';
+    const usage = '用法：omc rule-when --schema <模型> --on create|update --when "字段=值" [--when ...可多个,AND] --then "set:字段=值|{来源字段}|{公式}" [--then ...] [--apply]\n触发时机只有 create|update（**没有 submit**；“提交时”用 create 或 update）。条件操作符：= != > < >= <= ~=（包含） !~（不包含）。默认 dry-run；--apply 保存并发布（rule.enable 仍需显式执行）。';
     const invalid = (message) => {
         writeEnvelope(envelope("error", {}, request, { code: "invalid-input", message: `${message}\n${usage}`, retryable: false }));
         return CLI_EXIT_CODES.invalidInput;
@@ -122,7 +122,7 @@ export async function cmdRuleWhen(args) {
     if (!schema)
         return invalid("--schema 必填");
     if (on !== "create" && on !== "update")
-        return invalid("--on 只支持 create|update");
+        return invalid("--on 只支持 create|update（没有 submit；提交后执行请用 create 或 update）");
     let createArgs;
     try {
         createArgs = composeRuleWhenArgs({ schema, on: on, when, then, name, environment, apply });

package/dist/tool-types.js

@@ -213,14 +213,20 @@ export function parseToolInput(tool, input) {
                 if (guidance !== undefined)
                     return guidance;
                 const closest = closestSchemaKey(key, schemaKeys);
-                return closest === undefined ? "unknown key; no close match in this tool's params" : `unknown key; closest: ${closest}`;
+                // 语言规则（HANDOFF §三.3-8）：人读句子中文、机器字段/键名英文。issues[]
+                // 与人读 message 同源（B4），所以这里也是中文句子 + 英文键名。
+                return closest === undefined ? "未知键；本工具的合法键里没有相近的" : `未知键；最接近的合法键：${closest}`;
             };
+            // 未知键的下一步应指向**正确的那个参数**，不是整份 describe（4–17 KB）。
+            // 有近邻时 `--param <nearKey>` 是 150–900 B，且直接回答「本来想写哪个键」。
+            const nearestKey = closestSchemaKey(unknown[0], schemaKeys);
+            const paramCommand = nearestKey !== undefined ? `omc describe ${tool.name} --param ${nearestKey}` : `omc describe ${tool.name}`;
             throw new ToolInputError({
                 status: "error",
                 blocker: "tool-input-unknown-keys",
                 tool: tool.name,
-                message: `写面工具不接受未知键（会被静默丢弃）：${unknown.join("、")}。${twoStep.length > 0 ? twoStep.join(" ") : `最接近的合法键：${suggestions.join("；")}。参数表：omc describe ${tool.name}`}`,
-                ...(twoStep.length > 0 ? { nextCommand: `omc describe ${tool.name}` } : {}),
+                message: `写面工具不接受未知键（会被静默丢弃）：${unknown.join("、")}。${twoStep.length > 0 ? twoStep.join(" ") : `最接近的合法键：${suggestions.join("；")}。参数表：${paramCommand}`}`,
+                ...(twoStep.length > 0 ? { nextCommand: `omc describe ${tool.name}` } : { nextCommand: paramCommand }),
                 issues: unknown.map((key) => ({ path: [key], code: "unrecognized_key", message: issueHintFor(key) })),
             });
         }