@stalfh233/omc-cli 0.4.72 → 0.4.74

package/dist/lanes/rule-graph.js

@@ -792,6 +792,37 @@ export function prepareRuleGraph(ruleCode, graph, customTrigger, schemaCode) {
                 warnings.push({ code: "rule-graph-input-param-defaulted", nodeCode: String(node.nodeCode ?? ""), key: "inputParam", severity: "warning", message: `${nodeType} "${String(node.nodeCode ?? "")}" 缺 inputParam，已默认补 "_input"（平台按 inputParam 解析节点输入 schema，缺则 publish 300010「数据模型编码不能为空」）` });
             }
         }
+        // ASSIGN's quote stage dereferences three keys without a null check:
+        // `RuleAssignmentQuoteImpl.quote:61` calls `getNonMatchingAdded().booleanValue()`
+        // and `:77` does the same per child mapping. A graph that omits it therefore
+        // publishes as 50000 "服务异常" with an NPE in the launcher log — live
+        // 2026-10-22 (r8 seal sandbox), reproduced on a scratch model with an
+        // otherwise valid graph. The designer always writes them, so default the
+        // whole designer set instead of leaving a landmine.
+        if (nodeType === "ASSIGN") {
+            const defaults = [
+                ["triggerType", "CURRENT"],
+                ["dataCondition", { conditionGroup: [] }],
+                ["ruleVariableDataActions", []],
+                ["orderBys", []],
+                ["filterCondition", { mainConditions: [], sheetConditions: [] }],
+                ["dataActions", []],
+                ["children", []],
+                ["nonMatchingAdded", false],
+                ["addChildDataActions", []],
+            ];
+            const missing = defaults.filter(([key]) => current[key] === undefined || current[key] === null);
+            if (missing.length > 0) {
+                current = { ...current, ...Object.fromEntries(missing) };
+                warnings.push({
+                    code: "rule-graph-assign-keys-defaulted",
+                    nodeCode: String(node.nodeCode ?? ""),
+                    key: "nonMatchingAdded",
+                    severity: "warning",
+                    message: `ASSIGN "${String(node.nodeCode ?? "")}" 缺设计器固定键（${missing.map(([key]) => key).join("、")}），已按设计器默认补齐——尤其 nonMatchingAdded：平台 quote 阶段直接 .booleanValue()，缺它会 publish 50000（NPE RuleAssignmentQuoteImpl.quote:61）`,
+                });
+            }
+        }
         if (String(current.nodeName ?? "").trim())
             return current;
         const nodeCode = String(current.nodeCode ?? "");
@@ -923,7 +954,7 @@ export const RULE_NODE_TEMPLATES = Object.freeze({
         },
     },
     ASSIGN: {
-        description: "数据赋值（真机 2026-09-28 复核：可发布、可运行）。**`dataCondition` = 执行门**（输入数据满足条件才执行该节点，\"输入数据满足条件时触发执行动作\"）；**`filterCondition` = 按条件在输入数据源中匹配要取值的行**（\"根据此条件在输入数据源中进行匹配。匹配到多条数据时，会按第一条数据执行赋值\"）——**两者是两码事，别混**：要\"满足条件才赋值\"用 `dataCondition`，不是 `filterCondition`（后者不拦执行）。`triggerType` ∈ CURRENT(当前数据)/RULE_VARIABLE(规则变量)；CURRENT 时 `targetObjectCode` 默认 `\"_input\"`(=当前/输入对象)，dataActions 写目标字段；RULE_VARIABLE 时 targetObjectCode 隐藏、dataActions 写 `_var_*`、`orderBys` 有默认 `[{code:\"createdTime\",direction:\"ASC\"}]`。**CURRENT+dataActions 必须排在系统持久化节点(SYSTEM_CREATE/SYSTEM_UPDATE)之前**（Start→ASSIGN→SYSTEM_CREATE→End），否则赋值合并进 _input 晚于持久化、读回无变化（工具 fail closed `rule-graph-assign-persistence-order`；工具注入系统节点时也会自动排到 ASSIGN/BIZ_ACTION 之后）。平台设计器键（SHEET_ASSIGN）required：nodeCode/nodeName/targetObjectCode/ruleVariableDataActions/dataActions/orderBys/addChildDataActions；dataCondition 默认 `{conditionGroup:[]}`、filterCondition 默认 `{mainConditions:[],sheetConditions:[]}`、nonMatchingAdded 默认 false、children/addChildDataActions 默认 []。",
+        description: "数据赋值：把输入里的值写进 `targetObjectCode` 指向的**目标行**（`targetObjectCode` 是**写入目标**，不是取数来源；缺省 `_input` = 当前/输入对象）。实测 2026-10-22（1.1.25）：`targetObjectCode:\"_input\"` + `dataActions[{targetDataItem:\"<本单字段>\", ruleValueType:\"DYNAMIC\", currentDataItemValue:\"<本单来源字段>\"}]` 可发布可启用，目标字段是关联单选的也能写。**写成 `targetObjectCode:<别的模型>` + 目标是本单字段 → 平台自检 550018**（它按 targetObjectCode 校验 targetDataItem）；**漏 `nonMatchingAdded` → quote 阶段 NPE，publish 50000**（`RuleAssignmentQuoteImpl.quote:61`；工具已按设计器键补齐并给 warning `rule-graph-assign-keys-defaulted`）。**`dataCondition` = 执行门**（输入数据满足条件才执行该节点，\"输入数据满足条件时触发执行动作\"）；**`filterCondition` = 按条件在输入数据源中匹配要取值的行**（\"根据此条件在输入数据源中进行匹配。匹配到多条数据时，会按第一条数据执行赋值\"）——**两者是两码事，别混**：要\"满足条件才赋值\"用 `dataCondition`，不是 `filterCondition`（后者不拦执行）。`triggerType` ∈ CURRENT(当前数据)/RULE_VARIABLE(规则变量)；CURRENT 时 `targetObjectCode` 默认 `\"_input\"`(=当前/输入对象)，dataActions 写目标字段；RULE_VARIABLE 时 targetObjectCode 隐藏、dataActions 写 `_var_*`、`orderBys` 有默认 `[{code:\"createdTime\",direction:\"ASC\"}]`。**CURRENT+dataActions 必须排在系统持久化节点(SYSTEM_CREATE/SYSTEM_UPDATE)之前**（Start→ASSIGN→SYSTEM_CREATE→End），否则赋值合并进 _input 晚于持久化、读回无变化（工具 fail closed `rule-graph-assign-persistence-order`；工具注入系统节点时也会自动排到 ASSIGN/BIZ_ACTION 之后）。平台设计器键（SHEET_ASSIGN）required：nodeCode/nodeName/targetObjectCode/ruleVariableDataActions/dataActions/orderBys/addChildDataActions；dataCondition 默认 `{conditionGroup:[]}`、filterCondition 默认 `{mainConditions:[],sheetConditions:[]}`、nonMatchingAdded 默认 false、children/addChildDataActions 默认 []。",
         template: {
             nodeCode: "Assign_1", nodeName: "数据赋值", nodeType: "ASSIGN", nodeCategory: "actionNode", triggerType: "CURRENT", inputParam: "_input",
             dataCondition: { conditionGroup: [] }, dataConditionVisible: false,
@@ -1174,6 +1205,23 @@ export function formulaWarnings(action, nodeCode, index) {
 }
 /** Validate one dataAction; returns blockers (empty = clean). */
 export function validateDataAction(action, nodeCode, index) {
+    // 1.1 (r8 2026-10-22): a DYNAMIC source written as a dotted path is parsed by
+    // DatasetImpl as a CHILD-TABLE column — it collects that column across all
+    // child rows, so a scalar target receives a COLLECTION. The graph saves and
+    // publishes, then the runtime write answers 50000
+    // (WorkSheetBizField.fillClientContent: "Incorrect value type, should be
+    // string or map"). The engine reads a single-hop relation by its bare field
+    // code (takes .id); there is no supported dotted scalar shape.
+    {
+        const source = String(action.currentDataItemValue ?? action.currentSchemaDataItem ?? "").trim();
+        if (String(action.ruleValueType ?? "").toUpperCase() === "DYNAMIC" && source.includes("."))
+            return [{
+                    code: "rule-graph-create-dynamic-source-is-child-collection",
+                    nodeCode,
+                    key: `dataActions[${index}].currentDataItemValue`,
+                    message: `${nodeCode}: DYNAMIC 来源 "${source}" 用了点号——引擎把 "x.y" 当**子表列集合**解析（DatasetImpl），不是"关联字段.id"，标量目标会收到集合，运行期 submit/update 报 50000（WorkSheetBizField.fillClientContent: Incorrect value type, should be string or map）。单跳关联字段直接用字段 code（引擎取 .id）；子表列只用于公式/聚合（FORMULA AGGREGATION），不能作为规则赋值来源。来源：r8 印章沙盒 2026-10-22。`,
+                }];
+    }
     const blockers = [];
     const where = `dataActions[${index}]`;
     const valueType = String(action.ruleValueType ?? "");
@@ -1510,6 +1558,7 @@ export function validateRuleNodeGraph(graph, ruleCode, schemaCode, options = {})
                 nodeCode: String(crossModel[0].nodeCode ?? ""),
                 key: "targetObjectCode",
                 severity: "warning",
+                ...(updateOnlyTrigger ? { hazard: true } : {}),
                 message: updateOnlyTrigger
                     ? `跨模型写回节点位于预置 Update 规则中：Update 规则只在 data.update 时触发，create/submit 不会执行它（真机 2026-09-28 复核）。要让回写在订单提交时生效，请把该 UPDATE 节点放进本模型的 Create 规则，或放进绑定到流程事件（如流程 end）的规则。`
                     : `跨模型写回（目标 "${String(crossModel[0].targetObjectCode)}"）：平台支持，运行时生效的两个前提——① 承载它的规则必须真的触发（Create 在提交时触发，Update 只在 data.update 触发；也可绑定流程事件）；② 目标行必须已提交（COMMITTED），目标查询不匹配 DRAFT 行，data.save 未提交的行不会被回写。`,
@@ -1756,6 +1805,43 @@ export function validateRuleNodeGraph(graph, ruleCode, schemaCode, options = {})
                 walkConditionLeaves(node.targetConditionGroups, (leaf, where) => blockers.push(...validateConditionLeaf(leaf, nodeCode, where, warnings, (relaxEnums || carried?.has(String(node.nodeCode ?? "")) === true))));
                 scanConditionKeyCollisions(node.targetConditionGroups, nodeCode, warnings);
             }
+            // QUERY has THREE silent-empty exits in the engine (1.1.25 source, r9
+            // §14.1): `QueryActivityBehavior:47-50` returns null when the resolved
+            // inputs are empty, `:78-86` returns emptyList when getMainConditions()
+            // is null/empty, and `ActivityBizObjectManagerImpl:172-178` returns
+            // emptyList on a zero-hit page. NONE of them logs anything, so "executed,
+            // matched nothing" is indistinguishable from "executed, worked" — r9 lost
+            // ~1/4 of its call budget to this. The two shapes that reliably land in
+            // the first two exits are visible here before the wire:
+            const groups = node.targetConditionGroups;
+            const targetIsChild = typeof node.targetSchemaCode === "string" && node.targetSchemaCode.includes(".");
+            const mainEmpty = groups === undefined || countConditionLeaves(groups.mainConditions ?? groups) === 0;
+            const sheetEmpty = countConditionLeaves(groups?.sheetConditions ?? []) === 0;
+            // Mirrors QueryActivityBehavior.getPage exactly: an empty MAIN group
+            // returns emptyList unconditionally; the sheet group is only consulted
+            // when the target is a child table.
+            if (mainEmpty || (targetIsChild && sheetEmpty)) {
+                // A QUERY with no conditions at all is the "return emptyList" path, not
+                // "select everything" — the opposite of UPDATE's semantics. Fail closed:
+                // a caller who really wants every row must say so with an always-true
+                // leaf, which is visible in the graph.
+                blockers.push({
+                    code: "rule-graph-query-conditions-empty",
+                    nodeCode,
+                    key: "targetConditionGroups",
+                    message: `QUERY 的 ${mainEmpty ? "mainConditions" : "sheetConditions"} 没有任何条件叶——引擎 getPage 会直接返回空列表且不写日志（QueryActivityBehavior:78-86，1.1.25），运行期表现为「节点执行开始」后静默无输出。要查全表请显式写一条恒真条件叶（如 targetSchemaDataItem:"id" + ruleConditionType:"NOT_EMPTY"），否则补上真正的筛选条件。`,
+                });
+            }
+            if (node.dataCondition !== undefined && node.dataCondition !== null && countConditionLeaves(node.dataCondition) === 0) {
+                blockers.push({
+                    code: "rule-graph-query-datacondition-empty",
+                    nodeCode,
+                    key: "dataCondition",
+                    severity: "warning",
+                    hazard: true,
+                    message: "QUERY 的 dataCondition 是空条件组——输入数据经 DefaultConditionGroupBizObjectCompare 过滤后为空，QueryActivityBehavior:47-50 直接 return null（静默无输出，1.1.25）。要么去掉 dataCondition，要么写至少一条条件叶。",
+                });
+            }
         }
         if (nodeType === "BRANCH") {
             // Source evidence: RuleBranchQuoteImpl.getCurrentBizSchema throws

package/dist/lanes/rule-lifecycle.js

@@ -7,6 +7,7 @@ import { executeRuleSaveWrite, ruleNodeGraphArg, assertRuleSchemaExists, explain
 import { ToolRefusalError } from "../tool-types.js";
 import { prepareRuleGraph, validateRuleNodeGraph, PLATFORM_TRIGGER_RULE_CODES } from "./rule-graph.js";
 import { wireCall, wireRows, WireError } from "../wire.js";
+import { currentUsageArgsDigest, priorIdenticalSuccess } from "../usage-log.js";
 import { RULE_ENABLE_CHAIN, RULE_LIFECYCLE_LANE_CONTRACT } from "./rule-lifecycle-contract.js";
 const RULE_LIFECYCLE_LANE = RULE_LIFECYCLE_LANE_CONTRACT.lane;
 const RULE_LIFECYCLE_TOOLS = RULE_LIFECYCLE_LANE_CONTRACT.tools;
@@ -52,6 +53,25 @@ export async function executeRuleEnableWrite(session, args) {
     const full = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id: String(row.id) } })).data;
     if (!full)
         throw new WireError("business", `rule ${args.ruleCode} 完整模型读回为空（businessrule/get id ${row.id}），拒绝用列表投影发布`, 302024);
+    // Idempotency (r9 2026-10-22): identical `rule.enable` calls answered
+    // `alreadyEnabled:true` 14 times and each one still minted a new rule version
+    // row. The session log is the only durable memory a CLI has, so the memo is
+    // there: same (schemaCode, ruleCode) already enabled successfully, with no
+    // `rule.save` in between ⇒ nothing to do. Any save invalidates it.
+    const digest = currentUsageArgsDigest();
+    if (digest) {
+        const prior = priorIdenticalSuccess("call rule.enable", digest, { invalidators: ["call rule.save", "call rule.node.update"], keyFields: ["schemaCode", "ruleCode"] });
+        if (prior && prior.count > 0) {
+            return {
+                performed: { errcode: 0, alreadyEnabled: true, noop: true },
+                readback: {
+                    enabled: true,
+                    ...(prior.requestIds.length > 0 ? { priorRequestIds: prior.requestIds } : {}),
+                    nextAction: "本会话已用相同参数成功 enable 过该规则，且此后没有 rule.save；本次未发任何 wire 请求（重复 enable 只会多铸一个规则版本）。改了图就先 rule.save，再按需 rule.enable",
+                },
+            };
+        }
+    }
     let published;
     try {
         published = await wireCall(session, { path: ENDPOINTS.businessRulePublish, method: "POST", body: { ...full, enabled: true, status: "ENABLED" } });

package/dist/lanes/workflow-contract.js

@@ -148,7 +148,7 @@ export const WORKFLOW_LANE_CONTRACT = Object.freeze({
         }),
         "org.department.list": Object.freeze({
             scope: "workflow participant resolution",
-            description: "列出组织结构（`GET /api/api/organization/department/tree`），扁平化为 {id,name,code,corpId,parentId}。用于需要按部门解析审批人（配合 `FindUserByRole({Originator.OU},\"<roleCode>\",\"random\")` 或部门引用）时取得真实 code/id。",
+            description: "列出组织结构（`GET /api/api/organization/department/tree`），扁平化为 {id,name,code,corpId,parentId}。**平台语义：不带 deptIds 只返回根部门；带 deptIds=<id> 返回该部门整棵子树（不是一层）**——工具先取根再逐个取子树，支持多层；可选 parentId 只看子树。用于需要按部门解析审批人（配合 `FindUserByRole({Originator.OU},\"<roleCode>\",\"random\")` 或部门引用）时取得真实 code/id。",
         }),
         "org.user.search": Object.freeze({
             scope: "workflow participant resolution",

package/dist/lanes/workflow-coverage.js

@@ -18,6 +18,27 @@ export const WORKFLOW_COVERAGE = declareLaneCoverage(WORKFLOW_LANE_CONTRACT.lane
             claim("workflow.delete", T["workflow.delete"].scope),
             claim("configure_workflow", T["configure_workflow"].scope),
             claim("workflow.validate", T["workflow.validate"].scope),
+            // Organization writes (role group / role / members / management scope).
+            claim("org.role.users", "organization role member read (role/users)"),
+            claim("org.role.userScope", "organization role member management scope read (role/get_ouscope)"),
+            claim("org.roleGroup.create", "organization role group create (role/add_role_group)"),
+            claim("org.role.create", "organization role create (role/add_role)"),
+            claim("org.role.update", "organization role update (role/modify_role)"),
+            claim("org.role.addUsers", "organization role member add (role/add_role_user)"),
+            claim("org.role.removeUsers", "organization role member remove (role/strike_out_role_user)"),
+            claim("org.role.setUserScope", "organization role member scope update (role/update_ouscope)"),
+            claim("org.role.delete", "organization role delete (role/strike_out_role)"),
+            claim("org.roleGroup.delete", "organization role group delete (role/strike_out_role_group)"),
+            claim("org.user.transferDepartment", "organization user department transfer (user/dept_transfer)"),
+            claim("org.department.create", "organization department create (department/add)"),
+            claim("org.department.update", "organization department update (department/modefied)"),
+            claim("org.department.delete", "organization department delete (department/strike_out)"),
+            claim("org.department.users", "organization department member read (department/list_user)"),
+            claim("org.user.create", "organization user create (user/add)"),
+            claim("org.user.update", "organization user update (user/modify)"),
+            claim("org.user.delete", "organization user delete (user/strike_out)"),
+            claim("org.user.info", "organization user read (user/info)"),
+            claim("org.user.departments", "organization user department read (user/departments)"),
         ],
     },
     {

package/dist/lanes/workflow.js

@@ -2313,9 +2313,18 @@ export function registerWorkflowLane(tools) {
         lane: WORKFLOW_LANE,
         scope: WORKFLOW_TOOLS["org.role.list"].scope,
         description: WORKFLOW_TOOLS["org.role.list"].description,
-        inputSchema: { environment: environmentArg, capability: capabilityArg },
+        inputSchema: { environment: environmentArg, expandAll: z.boolean().optional().describe("默认 true：展开所有角色组并带回角色。平台的 /role/list 只有 expandAll=true 才填 children（RoleController.list，1.1.25）；传 false 只回角色组、roles 恒为空，别据此判断「角色未创建」"), capability: capabilityArg },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
-            const data = (await wireCall(session, { path: ENDPOINTS.organizationRoleList })).data;
+            // `/role/list` without `expandAll=true` only expands the FIRST group's
+            // children (RoleController.list, 1.1.25), so a role created under any
+            // other group is invisible — r9 read that as "role not created" and
+            // burned 8 org.role.list calls. Always expand; expose the flag only so
+            // a caller can ask for the container-only face deliberately.
+            const expandAll = args.expandAll ?? true;
+            const data = (await wireCall(session, {
+                path: ENDPOINTS.organizationRoleList,
+                query: expandAll ? { expandAll: "true" } : {},
+            })).data;
             return flattenRoleTree(wireRows(data));
         }),
     }));
@@ -2326,11 +2335,51 @@ export function registerWorkflowLane(tools) {
         lane: WORKFLOW_LANE,
         scope: WORKFLOW_TOOLS["org.department.list"].scope,
         description: WORKFLOW_TOOLS["org.department.list"].description,
-        inputSchema: { environment: environmentArg, capability: capabilityArg },
+        inputSchema: { environment: environmentArg, parentId: z.string().min(1).optional().describe("只列出该部门下的子树（默认从根递归展开整棵部门树）"), capability: capabilityArg },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
-            const data = (await wireCall(session, { path: ENDPOINTS.organizationDepartmentTree })).data;
-            const list = Array.isArray(data?.departmentList) ? data.departmentList : wireRows(data);
-            const departments = list.map((dept) => ({
+            // `/department/tree` semantics (live 2026-10-22, 1.1.25): no `deptIds`
+            // → the ROOTS; with `deptIds=<id>` → that department's WHOLE SUBTREE
+            // (not one level). So: roots once, then one subtree call per root.
+            const requested = args.parentId;
+            const fetchLevel = async (deptId) => {
+                const query = deptId === undefined ? {} : { deptIds: deptId };
+                const data = (await wireCall(session, { path: ENDPOINTS.organizationDepartmentTree, query })).data;
+                return Array.isArray(data?.departmentList) ? data.departmentList : wireRows(data);
+            };
+            const levels = [];
+            const seen = new Set();
+            const push = (rows) => {
+                for (const row of rows) {
+                    const id = String(row.id ?? "");
+                    if (id === "" || seen.has(id))
+                        continue;
+                    seen.add(id);
+                    levels.push(row);
+                }
+            };
+            if (requested === undefined) {
+                push(await fetchLevel(undefined));
+            }
+            else {
+                // `deptIds=<id>` returns the subtree BELOW that department, excluding
+                // it (live 2026-10-22). A caller asking for `parentId` expects that
+                // department itself too, so add it from the authoritative record.
+                try {
+                    const self = (await wireCall(session, { path: ENDPOINTS.organizationDepartmentGet, query: { deptId: requested } })).data;
+                    if (self)
+                        push([self]);
+                }
+                catch {
+                    // an unknown id simply yields an empty list
+                }
+                push(await fetchLevel(requested));
+            }
+            for (const root of levels.filter((row) => String(row.parentId ?? "") === "" || requested !== undefined).map((row) => String(row.id ?? ""))) {
+                if (seen.size >= 500)
+                    break;
+                push(await fetchLevel(root));
+            }
+            const departments = levels.map((dept) => ({
                 id: dept.id ?? null,
                 name: dept.name ?? null,
                 code: dept.code ?? null,

package/dist/rule-support.js

@@ -7,6 +7,7 @@ import { RULE_BIZ_RULE_TYPE_DESCRIPTION, RULE_CREATE_BODY, RULE_ROUTES_DESCRIPTI
 import { validateRuleNodeGraph, prepareRuleGraph, PLATFORM_TRIGGER_RULE_CODES, DEFAULT_SYSTEM_NODE_BY_RULE_CODE } from "./lanes/rule-graph.js";
 import { compileMethodConfigPlain } from "./bizservice-config.js";
 import { RESERVED_CODES } from "./code-rules.js";
+import { FIELD_PROPERTY_TYPES } from "./field-families.js";
 /** Business-rule node graph. Platform trigger rules are addressed by ruleCode: Create / Update / Delete / Available / Cancel / GetList / Load. */
 export const ruleNodeGraphArg = z
     .object({
@@ -399,6 +400,108 @@ async function assertBizActionMappingFieldsExist(session, schemaCode, nodes) {
  * the schema against the authoritative model list BEFORE the first rule wire
  * call and refuses on miss — zero pollution.
  */
+/**
+ * ASSIGN（数据赋值）is an OLD node — it is not new in 8.7/1.x. What changed is
+ * its SHAPE.
+ *
+ * Evidence (8.6.26 metadata):
+ *  - `BusinessRuleUpgradeServiceImpl` batch-upgrades stored rules through
+ *    `UpgradeRuleHandler`;
+ *  - `UpgradeRuleHandler.upgradeAssignNode()` reads the legacy
+ *    `triggerObjectCode`, writes `inputParam`+`targetObjectCode`, rewrites
+ *    `currentDataItemValue` for child paths, and deletes
+ *    `currentDataModel`/`targetSchemaModel`/`tableConditionGroups`/
+ *    `tableConditionGroupsVisible`.
+ *
+ * An upgrade path only exists because older installations already stored ASSIGN
+ * in that legacy shape. So: ASSIGN exists before 8.6, the MODERN shape starts at
+ * 8.6, and AI-Platform 1.x uses the same modern shape (DataAssignNode in
+ * 1.1.25). OMC only writes the modern shape, so on a pre-8.6 environment it must
+ * refuse rather than send keys the target will silently misread.
+ */
+export function assignNodes(nodes) {
+    return nodes
+        .filter((node) => String(node.nodeType ?? "") === "ASSIGN")
+        .map((node) => String(node.nodeCode ?? "ASSIGN"));
+}
+export function isModernAssignVersion(version) {
+    if (version === undefined || version.trim() === "")
+        return true;
+    const match = /^(\d+)\.(\d+)/u.exec(version.trim());
+    if (!match)
+        return true;
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    if (major >= 1 && major < 8)
+        return true;
+    return major > 8 || (major === 8 && minor >= 6);
+}
+/**
+ * 1.2 (r8 2026-10-22, 1.1.25): a `dataCondition` that compares a text-CHOICE field
+ * (RADIO/CHECKBOX/DROPDOWN) with a FIXED value never evaluates — the launcher
+ * logs 「解析选框类型数据项的比较值失败」 and the node runs UNCONDITIONALLY (the
+ * customer's "异常归还" was written back as if it were "已归还"). This is a
+ * platform-boundary behaviour we cannot fix, but shipping a silent always-true
+ * gate is worse than warning: emit a non-gating warning naming the field and the
+ * supported alternatives (BRANCH, or two rules).
+ */
+const CHOICE_CONDITION_TYPES = new Set([12, 13, 14, 15]);
+async function radioConditionWarnings(session, schemaCode, nodes) {
+    const sources = new Set();
+    const collect = (condition) => {
+        if (!condition || typeof condition !== "object")
+            return;
+        const record = condition;
+        const groups = record.dataConditionGroups ?? record.conditionGroup ?? record.execConditionGroups;
+        if (!Array.isArray(groups))
+            return;
+        for (const group of groups) {
+            if (!Array.isArray(group))
+                continue;
+            for (const leaf of group) {
+                if (!leaf || typeof leaf !== "object")
+                    continue;
+                const item = leaf;
+                if (String(item.ruleValueType ?? "").toUpperCase() !== "FIXED")
+                    continue;
+                const source = String(item.currentSchemaDataItem ?? item.currentDataItemValue ?? "").trim();
+                if (source !== "" && !source.includes("."))
+                    sources.add(source);
+            }
+        }
+    };
+    for (const node of nodes)
+        collect(node.dataCondition);
+    if (sources.size === 0)
+        return [];
+    let rows;
+    try {
+        rows = wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode, isPublish: "true" } })).data);
+    }
+    catch {
+        return [];
+    }
+    const choice = rows.filter((row) => {
+        const code = String(row.code ?? row.propertyCode ?? "");
+        // The real wire carries `propertyType`; the fake/older projections carry
+        // `type`. Accept both (numbers, numeric strings, or family names).
+        const rawType = row.propertyType ?? row.type ?? row.typeName;
+        const type = typeof rawType === "number" ? rawType : FIELD_PROPERTY_TYPES[String(rawType ?? "").toUpperCase()] ?? Number(rawType);
+        return sources.has(code) && CHOICE_CONDITION_TYPES.has(type);
+    });
+    if (choice.length === 0)
+        return [];
+    return [
+        {
+            code: "rule-graph-radio-condition-unparseable",
+            nodeCode: "",
+            key: "dataCondition",
+            severity: "warning",
+            hazard: true,
+            message: `dataCondition 用 FIXED 值比较文本选择类字段（${choice.map((row) => String(row.name ?? row.code ?? "")).join("、")}）：1.1.25 运行时日志「解析选框类型数据项的比较值失败」，条件**不生效**，节点会无条件执行（r8 印章沙盒 2026-10-22：异常归还也被当成已归还回写）。改用 BRANCH 判断该字段，或拆成两条规则；不要把「规则已 ENABLED」当作条件已生效。`,
+        },
+    ];
+}
 export async function assertRuleSchemaExists(session, schemaCode) {
     // Authoritative per-schema probe: GET /bizmodels/get_all (BizSchemaController
     // .java:615-633) resolves getBizSchemaBySchemaCode and answers
@@ -554,9 +657,16 @@ export async function executeRuleSaveWrite(session, args) {
     // legacy warning 原样回传）；新增/改动节点维持严格。存量永远可编辑。
     const carriedNodeCodes = await computeCarriedNodeCodes(session, args.schemaCode, args.ruleCode, preparedGraph);
     const blockers = [...prepared.warnings, ...validateRuleNodeGraph(preparedGraph, args.ruleCode, typeof args.schemaCode === "string" ? args.schemaCode : undefined, carriedNodeCodes ? { carriedNodeCodes } : {})];
+    // 1.2: needs the published field types (pure lint cannot see them).
+    blockers.push(...(await radioConditionWarnings(session, args.schemaCode, Array.isArray(preparedGraph.nodes) ? preparedGraph.nodes : [])));
     // Ticket 113: warning-severity findings (e.g. unknown mapping keys) do not
     // gate the write; they surface in the readback as lintWarnings.
-    const lintWarnings = blockers.filter((blocker) => blocker.severity === "warning");
+    const warningFindings = blockers.filter((blocker) => blocker.severity === "warning");
+    // `hazard` warnings stay non-gating but are surfaced separately: the readback
+    // must not let an always-true condition or an inert trigger look like a
+    // plain advisory.
+    const lintWarnings = warningFindings.filter((blocker) => blocker.hazard !== true);
+    const lintHazards = warningFindings.filter((blocker) => blocker.hazard === true);
     if (blockers.some((blocker) => blocker.severity !== "warning")) {
         throw new ToolRefusalError({
             status: "refused",
@@ -583,6 +693,25 @@ export async function executeRuleSaveWrite(session, args) {
     // Ticket 96: phantom-schema gate — BEFORE the first businessrule wire call
     // (the rule list itself auto-creates preset rows for unknown schemas).
     await assertRuleSchemaExists(session, args.schemaCode);
+    // ASSIGN shape is version-dependent (see isModernAssignVersion).
+    const assignCodes = assignNodes(nodes);
+    if (assignCodes.length > 0) {
+        const version = session.detectedVersion();
+        if (!isModernAssignVersion(version)) {
+            throw new ToolRefusalError({
+                status: "refused",
+                blocker: "rule-graph-assign-version-unsupported",
+                schemaCode: args.schemaCode,
+                ruleCode: args.ruleCode,
+                version: version ?? "unknown",
+                nodes: assignCodes,
+                message: `检测到 CloudPivot ${version ?? "未知版本"}：「数据赋值」在 8.6 之前是旧形状（triggerObjectCode/currentDataModel/targetSchemaModel/tableConditionGroups），` +
+                    `8.6.26 自带 BusinessRuleUpgradeServiceImpl + UpgradeRuleHandler.upgradeAssignNode 正是用来把旧图升级成 inputParam+targetObjectCode+nonMatchingAdded 的。` +
+                    `也就是说 ASSIGN 本身不是新节点，**现代形状从 8.6 起**（AI-Platform 1.x 同形）。OMC 只写现代形状，在旧形状环境会静默误读。` +
+                    `请改用 UPDATE/CREATE 表达同一逻辑，或在该版本的设计器里配置 ASSIGN。`,
+            });
+        }
+    }
     // Ticket 35: wire existence gate for BizMethod bindings — runs after the
     // local lint, before the create/update wire call (fail-closed; the platform
     // itself only gates the SERVICE, never the METHOD, at design time).
@@ -720,6 +849,7 @@ export async function executeRuleSaveWrite(session, args) {
                 enabled,
                 status: effective?.status,
                 ...(lintWarnings.length > 0 ? { lintWarnings } : {}),
+                ...(lintHazards.length > 0 ? { lintHazards } : {}),
                 id: effective?.id ?? undefined,
                 ruleVersion: effective?.ruleVersion,
                 latestPublished: effective?.latestPublished,
@@ -736,6 +866,7 @@ export async function executeRuleSaveWrite(session, args) {
             published: false,
             enabled,
             ...(lintWarnings.length > 0 ? { lintWarnings } : {}),
+            ...(lintHazards.length > 0 ? { lintHazards } : {}),
             id: effective?.id ?? undefined,
             ruleVersion: effective?.ruleVersion,
             latestPublished: effective?.latestPublished,

package/dist/tools.js

@@ -12,6 +12,7 @@ import { registerBusinessRuleLane } from "./lanes/businessrule.js";
 import { registerRuleLifecycleLane } from "./lanes/rule-lifecycle.js";
 import { registerRuntimeDataLane } from "./lanes/runtime-data.js";
 import { registerWorkflowLane } from "./lanes/workflow.js";
+import { registerOrganizationLane } from "./lanes/organization.js";
 import { registerOnlineJsLane } from "./lanes/online-js.js";
 import { registerB2Lane } from "./lanes/b2-registration.js";
 import { registerListViewLane } from "./lanes/list-view.js";
@@ -41,6 +42,7 @@ export function buildToolRegistry() {
     registerRuleLifecycleLane(tools);
     registerRuntimeDataLane(tools);
     registerWorkflowLane(tools);
+    registerOrganizationLane(tools);
     registerOnlineJsLane(tools);
     registerB2Lane(tools);
     registerListViewLane(tools);

package/dist/usage-log.js

@@ -2,6 +2,14 @@ import { appendFileSync, existsSync, mkdirSync, openSync, readFileSync, readSync
 import { createHash } from "node:crypto";
 import { dirname, resolve } from "node:path";
 let pending;
+/**
+ * The project session marker: a working directory that opted into the usage log
+ * (`.omc-env` present) or an explicit OMC_USAGE_LOG. Session-scoped caches key
+ * off this so repo tests and the golden master (no `.omc-env`) stay stable.
+ */
+export function projectSessionActive() {
+    return logPath() !== undefined;
+}
 function logPath() {
     const explicit = process.env.OMC_USAGE_LOG;
     if (explicit)
@@ -9,6 +17,60 @@ function logPath() {
     const projectEnv = resolve(process.cwd(), ".omc-env");
     return existsSync(projectEnv) ? resolve(process.cwd(), ".omc", "usage.jsonl") : undefined;
 }
+/** The args digest of the in-flight invocation (session-scoped memo key). */
+export function currentUsageArgsDigest() {
+    return pending?.argsDigest;
+}
+/** The summarized args of the in-flight invocation (safe keys only). */
+export function currentUsageArgSummary() {
+    return pending?.argSummary;
+}
+/**
+ * Was this exact invocation (same command + same args) already SUCCESSFUL in the
+ * current project session, with no intervening call from `invalidators` for the
+ * same business key?
+ *
+ * r9 (2026-10-22) called `rule.enable` with identical args 14 times; each call
+ * answered `alreadyEnabled:true` and minted another rule version. The log is the
+ * only durable session memory a CLI has, so the idempotency memo lives there.
+ */
+export function priorIdenticalSuccess(command, argsDigest, options = {}) {
+    const path = logPath();
+    if (!path)
+        return undefined;
+    const limit = options.limit ?? 60;
+    const tail = readUsageTail(path, 131072).slice(-limit);
+    const current = pending?.argSummary ?? {};
+    const keyFields = options.keyFields ?? ["schemaCode", "ruleCode", "code"];
+    const sameKey = (record) => {
+        const summary = record.argSummary && typeof record.argSummary === "object" ? record.argSummary : {};
+        return keyFields.every((field) => {
+            const wanted = current[field];
+            if (wanted === undefined)
+                return true;
+            return String(summary[field] ?? "") === String(wanted);
+        });
+    };
+    let count = 0;
+    const requestIds = [];
+    for (let index = tail.length - 1; index >= 0; index -= 1) {
+        const record = tail[index];
+        const recordCommand = String(record.command ?? "");
+        if (options.invalidators?.includes(recordCommand) && sameKey(record))
+            return count > 0 ? { count, requestIds } : undefined;
+        if (recordCommand !== command)
+            continue;
+        if (String(record.argsDigest ?? "") !== argsDigest)
+            continue;
+        if (String(record.status ?? "") !== "ok")
+            continue;
+        count += 1;
+        const requestId = record.requestId;
+        if (typeof requestId === "string" && requestIds.length < 3)
+            requestIds.push(requestId);
+    }
+    return count > 0 ? { count, requestIds } : undefined;
+}
 /** The command string of the in-flight invocation (for diagnostics). */
 export function currentUsageCommand() {
     return pending?.command;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stalfh233/omc-cli",
-  "version": "0.4.72",
+  "version": "0.4.74",
   "description": "CloudPivot 8.6 configuration capability CLI — governed, fail-closed, coverage-manifest bounded.",
   "type": "module",
   "bin": {
@@ -50,9 +50,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@stalfh233/omc-fake-platform": "0.4.72",
+    "@stalfh233/omc-fake-platform": "0.4.74",
     "commander": "14.0.3",
-    "omc-core": "0.4.72",
+    "omc-core": "0.4.74",
     "proper-lockfile": "4.1.2",
     "write-file-atomic": "6.0.0",
     "zod": "^3.23.8",

package/skills/omc-business-configuration.md

@@ -151,7 +151,20 @@ rules:
 - **两条路**：模型+表单+流程一揽子交付走**意图**（`intent` 的 `workflow` 能力，声明式一次 apply）；只动流程或想逐步控制走**低层链** `workflow.create → workflow.update（权限/节点）→ workflow.publish`，标准链配方见 `omc describe workflow.update`（含多级审批/participant 三形态/自动回填说明）。流程权限细节见下节。
 - 一个模型只能有一个流程；已有流程的模型直接 `workflow.update`，不要另建。
 - **清理测试数据用批量删除**：`data.delete --args '{"schemaCode":"<code>","bizObjectIds":["id1","id2"]}'` 一次往返删多条（真机 r6：207 次逐条 `data.delete` 占 13.5% 调用）。
+- **「聚合计算」是字段能力，不是规则节点**：FORMULA(计算公式)字段的 `options.formulaConfig.formulaType="AGGREGATION"` 就是 UI 里的「配置方式 → 聚合计算」，跨模型做 SUM/MAX/MIN/COUNT（1.1.25 实测可用，8.6.26 同形）。形状：
+  `options = {persistent:true, formulaConfig: JSON字符串({resultType:2, resultFormat:"", formulaType:"AGGREGATION", aggregation: JSON字符串({schemaCode:"<目标模型>", dataItemCode:"<目标字段>", calculateType:"SUM", formula:"SUM({<目标模型>.<字段>})", queryConditions:[[{propertyCode, propertyType, operatorType, propertyValue, valueType:"FIXED"}]]})})}`。
+  **`propertyType`/`operatorType` 必须写整数**（Jackson 按 int 反序列化枚举）：propertyType 2=NUMERICAL、3=DATE…；operatorType 1=EQ / 2=NEQ / 3=GT / 4=IT / 5=GTEQ / 6=ITEQ / 9=IS_NULL / 10=IS_NOT_NULL …（工具接受名字并自动转成整数）。`queryConditions` 为**空数组时聚合结果是 0**（不是全表求和）；目标模型的**草稿行不参与**（实测：DRAFT 行不入计数，提交后 10+32.5→42.5）。已发布的公式字段**不能改配置方式**（field.update 报 -1），要改就新建字段或趁草稿改。
+- **DYNAMIC 来源不要写点号**：`dataActions` 的 `currentDataItemValue` 写 `items.sealNo` 会被引擎当成**子表列集合**（DatasetImpl），标量目标收到集合 → 运行期 `submit/update` 报 50000（`WorkSheetBizField.fillClientContent: Incorrect value type`）。单跳关联字段直接写字段 code（引擎取 `.id`）；子表列只能用于公式/聚合。`rule.save` 已写前拒绝（`rule-graph-create-dynamic-source-is-child-collection`）。
+- **单选字段的 `dataCondition` 在 1.1.25 不生效**：用 FIXED 值比较 RADIO/CHECKBOX/DROPDOWN 时，运行时日志「解析选框类型数据项的比较值失败」，条件被跳过、节点**无条件执行**（r8：异常归还被当成已归还回写）。`rule.save` 会把它放进 `readback.lintHazards`（`rule-graph-radio-condition-unparseable`）；改用 BRANCH 判断该字段，或拆两条规则。
+- **预置 Update 规则里的跨模型回写只在 `data.update` 触发**：`rule-graph-cross-model-update-trigger-inert` 现在是 hazard（在 `readback.lintHazards`，不混进 `lintWarnings`）；create/submit 不执行它。要提交时生效，把节点放进 Create 规则或流程事件规则。
+- **部门/员工写面**：`org.department.create`（`deptType` 传名字或 0..3，平台按 **int 枚举**反序列化，写 `"dept"` 会 10009）→ `org.department.update`（先读再合并）/`org.department.delete`（`strike_out`）；`org.user.create` 必填 `name/username/departmentId`，**平台对 `userLabelIds`/`userManagerConfigList`/`roleIds` 的 null 直接 NPE**（50000，`UserHelper.dealUserLabel:428`），工具已补空数组；`org.user.update` 同样必须先补 `deptIds` 等数组（`UserHelper.modified` 对 null 的 `deptIds` NPE）。`org.department.list` 递归展开整棵树（`/department/tree` 每次只返回一层）；`org.department.users` / `org.user.info` / `org.user.departments` 用于回读。新建用户的 `active` 平台回读为 false（账号激活另有流程），不要把 active 当作创建成功标志。
+- **组织写面（角色/成员/管理范围）**：界面上的「分组」= 角色（`group:false`），容器是角色组（`group:true`）。链路：`org.roleGroup.create`（**parentId 必填**，1.1.25 传空会 50000 `parentIds cannot be empty`）→ `org.role.create`（roleId 平台生成，code 随后补 `SYS<时间戳>`）→ `org.role.addUsers`（`id` 必须传 **recId**，不是账号；工具补 `type:3`/`unitType:"3"`）→ `org.role.setUserScope`（**平台覆盖语义、无回滚**：默认读旧值合并，`mode:"replace"` 才整体替换；`unitType` 传数字 3）。读回用 `org.role.users` / `org.role.userScope`。
+  - **`corpId` 默认写当前企业，不要写 `"other"`**（r9 2026-10-22 更正）：`RoleGroupHelper.createRoleGroupModel` 只从 body 取 corpId，缺省才按 parentId 反查企业设置、查不到就 NPE（被吞成 errcode 0）；`other` 是平台**合法的「非组织分组」语义**，不是兜底值。工具现在默认 `session.enterpriseId()`，并回读校验（不一致给 warning）；只有明确要建非组织分组时才显式传 `corpId:"other"`。
+  - **`org.role.list` 必须带 `expandAll=true`**：`/role/list` 不带该参数只展开**第一个**角色组的 children（`RoleController.list`，1.1.25），所以建在别的组下的角色读回为「不存在」——r9 因此误判「角色未创建」并重复读了 8 次。工具已默认展开，`expandAll:false` 才拿容器面。
+  - **`org.role.update` 的平台前置条件**：`modify_role` 的 `validateRoleParam` 要求 `roleName` 与 `roleGroupId` **都非空**（否则 202001 / 202012），所以只改备注也要回填这两项——工具已从 `role/get` 自动补齐。`corpId` 在 update 里不生效，换企业只能重建角色。
+  - **角色参与人可用性**：r9 对照实验证明，`corpId=other` 的角色**仍能正常解析参与人**（把非发起人加进该角色后，待办正确落到该人）。所以「审批人变成发起人」要按**解析为空**排查（角色零成员 / 成员没挂部门 / 自由文本 / 角色码不存在），不要归因于 corpId。
 - **系统持久化节点是平台自带的，不要手写**：预置 `Create/Update/Delete` 行本来就带 `SYSTEM_CREATE/SYSTEM_UPDATE/SYSTEM_DELETE`（实测基线 `Start → Create(SYSTEM_CREATE) → End`）。`rule.save` 会丢弃调用方传入的 `SYSTEM_*` 并**从平台基线原样携带**那一个节点（code/name/几何都不由我们猜）。手写的后果：预置规则里类型错配 → `data.submit` 50000；自定义规则/流程事件里带系统节点 → 结束事件无当前对象，`Object <id> is not serialized`，每步仍回 DELIVERED 但什么都没写。只写平台允许配置的业务节点（UPDATE/CREATE/DELETE/BRANCH/ASSIGN/MESSAGE/BIZ_ACTION…）。
+- **QUERY 节点的三个「静默空结果」入口（1.1.25 源码，r9 §14.1）**：`QueryActivityBehavior:47-50`（输入数据为空，或 `dataCondition` 过滤后为空 → `return null`）、`:78-86`（`mainConditions` 为空 → `emptyList`；目标带 `.` 时 `sheetConditions` 为空也 `emptyList`）、`ActivityBizObjectManagerImpl:172-178`（真查询 0 命中 → `emptyList`）。**三条都不写日志**，所以「节点执行开始后什么都没有」既可能是配置错也可能是 0 命中。前两条工具已在写前拦：`rule-graph-query-conditions-empty`（无条件叶，fail closed——QUERY 的空条件**不是**「查全表」，与 UPDATE 语义相反；要全表请写恒真叶）与 `rule-graph-query-datacondition-empty`（hazard）。第三条只能在运行期验证：先 `data.list` 确认目标行存在且状态已提交。
 - **取 artifact 先投影**：`artifact get <id> --summary` 看形状 → `--jq '<path>'` 取那一段；只有确实要整份时才裸取（r6：47 次整包拉取 650KB，0 次用投影）。
 - **读回产物会自动清理，也可手动清**：每次大结果落一个 artifact（机器级目录，跨项目累积；实测一轮沙盒 504 个/3.4MB）。`createArtifact` 每 24h 顺手删 7 天未动的；要立刻回收用 `omc artifact prune --older-than 7d --max-bytes 268435456`（默认预算 256MB，超出按最旧优先删），`--json` 回 removed/freedBytes/kept。
 - **核验状态用投影，别重复整条读**：`data.load --args '{"schemaCode":..,"bizObjectId":..,"fields":["sequenceStatus","<业务状态字段>"]}'` 只回指定字段（缺失项在 `missingFields`）——r4 实测同一对象被整条读 74 次；大结果先 `artifact get <id> --summary` → `--keys/--jq`，别整包内联进推理。
@@ -211,7 +224,9 @@ rules:
 规则支持**触发条件**，不要用「两条无条件规则」表达互斥结果：
 
 - **节点级条件有两大类，别混**（各节点类型都可能有，完整字段/样例见 `describe rule.save --full` 的 RULE_NODE_TEMPLATES）：
-  - **定位要操作哪些数据**（`filterCondition`：叶 `targetSchemaDataItem`+`ruleConditionType`）：UPDATE=改哪条（空=整表）、DELETE=删哪条、CREATE=存在符合则不新增+`findMainData`、QUERY=`targetConditionGroups`、**ASSIGN=在输入数据源匹配要取值的行（不是执行门！）**。⚠️ 非唯一字段（金额等）会命中**多条**；改「当前/关联那一条」用唯一键（`id` 或 `from`）。`actions.filter` 表达这类（同模型省略→默认 `id=id`；跨模型省略 fail-closed）。
+  - **`ASSIGN`（数据赋值）不是新节点，新的是它的形状**：8.6.26 自带 `BusinessRuleUpgradeServiceImpl` + `UpgradeRuleHandler.upgradeAssignNode`，职责就是把旧形状（`triggerObjectCode`/`currentDataModel`/`targetSchemaModel`/`tableConditionGroups`）升级为 `inputParam`+`targetObjectCode`+`nonMatchingAdded`——存在升级器就说明 8.6 之前已经有 ASSIGN。**现代形状从 8.6 起**，AI-Platform 1.x 同形；<8.6 存的是旧形状，写现代形状会被静默误读，OMC 直接拒绝（`rule-graph-assign-version-unsupported`）。
+  - **`ASSIGN` 的 `targetObjectCode` 是写入目标，不是取数来源**：默认 `_input` = 当前单；`dataActions.targetDataItem` 必须是**该目标模型已发布字段**（写成别的模型 + 本单字段 → 550018）。要"从关联单取值回填本单"，就 `targetObjectCode:"_input"` + `currentDataItemValue:"<本单来源字段>"`（关联字段引擎取 .id），不要把它指到对面模型。漏 `nonMatchingAdded` 会让 quote 阶段 NPE（publish 50000），工具已按设计器键补齐（warning `rule-graph-assign-keys-defaulted`）。
+  - **定位要操作哪些数据**（`filterCondition`：叶 `targetSchemaDataItem`+`ruleConditionType`）：UPDATE=改哪条（空=整表）、DELETE=删哪条、CREATE=存在符合则不新增+`findMainData`、QUERY=`targetConditionGroups`、**ASSIGN=在目标表里匹配要赋值的行（不是执行门！）**。⚠️ 非唯一字段（金额等）会命中**多条**；改「当前/关联那一条」用唯一键（`id` 或 `from`）。`actions.filter` 表达这类（同模型省略→默认 `id=id`；跨模型省略 fail-closed）。
   - **执行门 / 满足条件触发**（`dataCondition`，BIZ_ACTION 用 `execConditionGroups`）：**与定位两码事**——决定「要不要执行」，不决定「改哪条」。compact `actions.when` 表达 UPDATE 执行门（叶 `currentSchemaDataItem`+`ruleDataConditionType`）；其它节点用 `nodeGraph`。**条件改自身**：`when: [{field: amount, gt: 10000}]` + 省略 `filter`（默认 `id=id`）——别把条件写进 `filter`，那会改掉所有符合的行（bench66 多行互覆）。
   - 子表定位 `filterSubCondition`；子表触发范围 `childTriggerConditionType∈ADD/MODIFY/DELETE`。
 - **触发时机**：数据事件（`Create`/`Update`/`Delete`）**只分发到平台预置 code 行**；流程相关用预置 `Available`（流程生效）/`Cancel`（流程作废），或流程事件绑定 `workflow.bindRule` 的 `end`/`cancel`/`start`/`activate`。