@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/lanes/businessrule-contract.js

@@ -0,0 +1,232 @@
+import { behaviorBinding, CONTRACT_FAMILY, CONTRACT_REFERENCE_VERSION, assertDescriptionCarries, assertLaneContract, describeTool, emitterBinding } from "./contract-support.js";
+import { LANES } from "./lane-ids.js";
+import { RULE_ACTION_TYPES, RULE_CODE_TYPES, RULE_CONDITION_TYPES, RULE_DATA_SOURCE_TYPES, RULE_NODE_TEMPLATES, RULE_NODE_TYPES, RULE_SCHEDULER_CYCLE_TYPES, RULE_SCHEDULER_END_TYPES, RULE_SCHEDULER_EXECUTE_TYPES, RULE_SCHEDULER_SETTING_TEMPLATE, RULE_SCHEDULER_TRIGGER_TIME_TYPES, RULE_VALUE_TYPES } from "./rule-graph.js";
+/** Rule `enabled` is the runtime dispatch truth; `status` may lag (platform quirk). */
+export const RULE_STATUS = Object.freeze({ enabled: "ENABLE", disabled: "DISABLED" });
+/** Enum re-exports: rule-graph.ts is the single source (validator + fake + contract all import it). */
+export { RULE_VALUE_TYPES, RULE_ACTION_TYPES, RULE_CONDITION_TYPES, RULE_NODE_TYPES, RULE_NODE_TEMPLATES };
+/** The DISABLED dead-state body every fresh rule.save upsert writes. */
+export const RULE_CREATE_BODY = Object.freeze({
+    enabled: false,
+    status: RULE_STATUS.disabled,
+    defaultRule: false,
+    developmentMode: 0,
+});
+export const RULE_PLATFORM_QUIRK = "enabled is the dispatch truth; status may still read DISABLED after enable — never infer enable state from status";
+const RULE_NODE_GRAPH_EXAMPLE = '[{"nodeCode":"Start","nodeName":"开始","nodeType":"START",x,y,height,width},{"nodeCode":"UPDATE_1","nodeType":"UPDATE","targetObjectCode":"<target schemaCode>","inputParam":"_input","updateNodeType":"UPDATE_MODEL","execFormMapping":false,"filterCondition":{"mainConditions":[[{"targetSchemaDataItem":"<target field>","ruleConditionType":"EQ","ruleValueType":"DYNAMIC","currentSchemaDataItem":"<trigger field>"}]],"sheetConditions":[]},"dataActions":[{"targetDataItem":"<target field>","ruleValueType":"DYNAMIC","value":"","ruleActionType":"EQUALS","currentDataItemValue":"<trigger field>"}],x,y,height,width},{"nodeCode":"End","nodeName":"结束","nodeType":"END",x,y,height,width}]';
+export const RULE_NODE_GRAPH_WIRE = Object.freeze({
+    inputParam: "_input",
+    valueTypes: RULE_VALUE_TYPES.join("/"),
+    actionTypes: RULE_ACTION_TYPES.join("/"),
+    conditionTypes: RULE_CONDITION_TYPES.join("/"),
+    nodeTypes: RULE_NODE_TYPES.join("/"),
+    dynamicConditionSource: "currentSchemaDataItem",
+    dynamicActionSource: "currentDataItemValue",
+    dynamicConditionValue: "filter value is omitted for DYNAMIC",
+    dynamicActionValue: "action value is empty for DYNAMIC",
+    dynamicNameKeys: "targetDataItemName/currentDataItemValueName",
+    fixedValueTypes: "select 族（RADIO/DROPDOWN_BOX/DROPDOWN_MULTI_BOX/CHECKBOX）= 裸选项字符串（如 \"待处理\"）——RadioConverter.java:41-88：JSON 数组串 [\"x\"] 在 (JSONObject)selection 强转处 ClassCastException 被吞、原样透传导致 *_key 失配为 null（live 2026-09-15 复核修正 ticket 09 的数组串记载，旧模型数组形历史数据是老版本写入、同病）；对象数组 [{key,label}] 形态是条件键值映射的另一用途，非 FIXED 赋值；number/boolean = native；text = bare string",
+    presetSystemNode: "预设触发规则 Create/Update/Delete 的图必须保留平台系统节点 SYSTEM_CREATE/SYSTEM_UPDATE/SYSTEM_DELETE（nodeCode Create/Update/Delete，isSystemNode:true）——它是触发行持久化节点；tool 自动补在 START 之后，调用方只写自己的动作节点（2026-09-12 live：缺它则行永远停在 DRAFT）。**不要往预置规则里放类型不匹配的 SYSTEM_* 节点**（如 Create 规则塞 SYSTEM_UPDATE）——错配会让触发行写错、data.submit 报 50000（真机 2026-09-25，工具已 fail closed `rule-graph-preset-system-node-mismatch`）；省略 SYSTEM_* 即让工具注入正确的那个。",
+    schedulerSetting: "SCHEDULER 节点无时机字段，调度参数在规则行 schedulerSetting（JSON 字符串，bizRuleType:2）；缺 schedulerSetting 则规则保存成功但永不触发",
+    triggerDispatch: "触发分发铁律（ticket 111 源码铁证）：数据新增/修改/删除只分发到预置 code 行——DomainServiceImpl.java:226-314 经 getBusinessRuleOfExecutable(schemaCode, DefaultBusinessRuleType.CREATE/UPDATE/DELETE.getCode()) 按 code 字面量精确查询，绝不扫描 bizRuleType=0 的自定义规则；自定义 ruleCode 只能由按钮 targetCode（HistoricalRuleHandler.java:116-145）、流程事件 bizActions BIZ_RULE（InstanceContext.java:421-438）或显式 executeMethod 触发；定时入口强制 bizRuleType=TIMING_TASK(2)（BizRuleScheduling.java:202-205）。要求数据事件自动触发 → 动作必须挂在预置 Create/Update/Delete 行上",
+    systemNodeFamilies: "系统/流程节点 GET_LIST（dataSourceType:GET_LIST 原生列表 / BIZ_SERVICE 绑 BizMethod）、LOAD/CANCEL/AVAILABLE（isSystemNode:true）为平台预置系统节点，模板见 nodeTemplates",
+    bizMethodMapping: `BIZ_ACTION / GET_LIST(BIZ_SERVICE) 的 methodMapping：{schemaCode,serviceCode,serviceMethodCode,methodCode?,inputMappings[],outputMappings[]}；serviceCode+serviceMethodCode 是集成方法存在性对，methodCode 是模型级 BizMethod 注册槽。映射元素 = 8.6.26 MappingModel，codeType 按 int：${RULE_CODE_TYPES.map((t, i) => `${i}=${t}`).join("/")}（1=PROPERTY 须带 bizCode；0=CONST）。映射元素只校验语义键，其余键非语义透传（工具不按版本增删；index/required/displayName/bizCodeName 等 v2 键原样随行、模板不产出）；required 以方法参数面为权威自动镜像（面缺席则映射保持缺席，显式矛盾本地拒绝）`,
+    bizMethodValidation: "rule.save 写前 wire 校验：图内每个 methodMapping 的服务+方法必须经 bizservice get_by_code + list_by_service_code 解析存在，且 inputMappings/outputMappings 的 serviceMethodParameterCode 必须命中方法声明的参数面，否则 refused（平台 update/publish 只拦服务缺失 BUSINESS_SERVICE_NOT_EXIST；publish 干门 550018 同语义拒参数面悬空——live 2026-09-12）；RESTFUL/DATA_SQL 绑定目标必须带适配器必需 configJson 键——只有名字/参数面的注册壳 refused `rule-graph-bizmethod-registration-shell`（INTERNAL/扩展包方法不受此门）",
+    bizActionPersistence: "BIZ_ACTION 的 outputMappings 结果由 SYSTEM_CREATE/SYSTEM_UPDATE 持久化节点消费，故动作节点必须排在系统节点之前（Start→BizAction→SYSTEM_CREATE→End），否则合并结果不落库（live 2026-09-12 ticket 36 铁证：系统节点在动作前时 echoResult 恒 null，重排后回写生效——IntegrationServiceExecutor.mergeResult 只刷新 _input，SystemCreateActivityBehavior 持久化其 _input 输入）；injectDefaultSystemNode 默认把系统节点补在 START 之后，有回写动作时须显式提供系统节点并置于动作之后",
+    triggerConditions: "节点触发条件（平台 i18n 模块 196233 节点属性表；evidence/form-conditions-and-rules-truth.md §4）：UPDATE.filterCondition=**查找满足条件的主表数据**（要更新哪条；空 mainConditions=无条件下更新整表，bench23 病灶，干 lint 出 `rule-graph-filter-empty-main` warning）、UPDATE.filterSubCondition=子表条件；CREATE.findMainData=查找满足条件的主表数据（只影响是否新增）、CREATE.filterCondition=存在符合数据则不新增（aggregation 布尔=分组/单条新增）；DELETE.filterCondition=删除满足条件的数据；ASSIGN.filterCondition=满足条件时赋值、triggerType∈CURRENT/RULE_VARIABLE；BIZ_ACTION.execConditionGroups=满足条件时执行业务方法；BRANCH.sourceInputMethod(PRE_OUT/OTHER_MODEL)/exitConditionGroups；通用 dataCondition=输入数据满足条件时执行、childTriggerConditionType∈ADD/MODIFY/DELETE；路由 routeCondition/matchType(ANY/ALL/CUSTOM)。除 BRANCH.exitConditionGroups 外，条件组与 filterCondition 同构 [[{targetSchemaDataItem,ruleConditionType,ruleValueType,...}]]（DYNAMIC 来源键 currentSchemaDataItem）；**BRANCH.exitConditionGroups 例外**：反序列化为 DataFilterCondition，出口叶用 [[{currentSchemaDataItem,ruleDataConditionType,ruleValueType,value}]]（照抄 UI 键会 save+publish 过但运行时 50000）。",
+    example: RULE_NODE_GRAPH_EXAMPLE,
+    draftRowNote: "目标行查询不匹配 DRAFT 行。",
+});
+/**
+ * The rule-node-graph wire contract, generated from the frozen facts above.
+ * The `_input` rule is the 2026-09-11 ticket-02 finding: `inputParam` must be
+ * the literal `"_input"` (RuleExecutorImpl.saveRuleInput registers the trigger
+ * data under that name); a schemaCode literal only passes the dry-gate and
+ * silently no-ops at runtime.
+ */
+export function ruleNodeGraphDescription() {
+    const wire = RULE_NODE_GRAPH_WIRE;
+    return `rule nodes (array or pre-serialized JSON string). 自动布局：线性图（无 BRANCH）若缺坐标或节点框重叠，工具自动按平台标准单列铺开（x=327，158×40，y=36/116/196…，间距 80）；已可正常渲染的布局与分支图原样保留——调用方无需手算几何。Live-proven cross-model UPDATE shape (2026-09-11, tickets 02/09): ${wire.example}. 铁律：inputParam 必须是 "${wire.inputParam}"（RuleExecutorImpl.saveRuleInput 以该名注册触发数据，schemaCode 字面量只过 dry-gate、运行时静默空转）；ruleValueType ∈ ${wire.valueTypes}；ruleActionType ∈ ${wire.actionTypes}；ruleConditionType ∈ ${wire.conditionTypes}（BRANCH 出口叶例外，键见 BRANCH 模板）；DYNAMIC 过滤来源必须放 ${wire.dynamicConditionSource}，DYNAMIC 赋值来源必须放 ${wire.dynamicActionSource}，${wire.dynamicConditionValue}；${wire.dynamicActionValue}，展示名惯例为 ${wire.dynamicNameKeys}；FIXED 值分型：${wire.fixedValueTypes}。${wire.presetSystemNode}。触发分发：${wire.triggerDispatch}。${wire.draftRowNote} nodeType ∈ ${wire.nodeTypes}。${wire.systemNodeFamilies}。${wire.bizMethodMapping}。${wire.bizActionPersistence}。触发条件：${wire.triggerConditions}。${wire.schedulerSetting}。`;
+}
+export const RULE_ROUTES_DESCRIPTION = "edges, e.g. [{preNode:'Start',postNode:'UPDATE_1',points:[..],routeCondition:true,matchType:'ANY'}] (or a JSON string). 工具自动规范化：缺失的 points 由节点边中点（源底边中点→目标顶边中点）推导，缺失的 routeCondition/matchType 补 true/ANY；调用方无需手算坐标。";
+export const RULE_BIZ_RULE_TYPE_DESCRIPTION = "rule trigger family; 0 = data operation, 1 = get-list, 2 = timing task (8.6.26 BizRuleType)";
+/**
+ * Rule-level scheduler shape, emitted as a JSON string into the rule row's
+ * `schedulerSetting` column. Only meaningful with a SCHEDULER node /
+ * `bizRuleType:2`; the node itself carries no timing fields.
+ */
+export function schedulerSettingDescription() {
+    const template = JSON.stringify(RULE_SCHEDULER_SETTING_TEMPLATE);
+    return `SCHEDULER 规则的调度参数（对象或 JSON 字符串；写在规则行 schedulerSetting，不在节点上）。形状示例：${template}。枚举：triggerTimeType ∈ ${RULE_SCHEDULER_TRIGGER_TIME_TYPES.join("/")}；executeType ∈ ${RULE_SCHEDULER_EXECUTE_TYPES.join("/")}；cycleType ∈ ${RULE_SCHEDULER_CYCLE_TYPES.join("/")}；endType ∈ ${RULE_SCHEDULER_END_TYPES.join("/")}；dataSourceType ∈ ${RULE_DATA_SOURCE_TYPES.join("/")}；triggerTimeType=DATE_FIELD 时必须带 triggerDataItem。证据：8.6.26 SchedulerSetting.java:27-52。`;
+}
+const RULE_SAVE_DESCRIPTION = describeTool("保存业务规则（upsert）：`ruleCode` 已存在则 `businessrule/update`，否则 `businessrule/create`。", [
+    "这样可把规则配置进**平台预置触发规则**（`Create`=数据新增、`Update`=数据更新、`Delete`=数据删除、`Available`=流程生效、`Cancel`=流程作废、`GetList`=获取集合、`Load`=加载表单详情），即在触发规则上追加动作节点。",
+    "`nodeGraph` 传 `{ nodes, routes, bizRuleType?, schedulerSetting? }`（可为数组或 JSON 字符串）；工具拼成平台要求的 `node`/`route`/`schedulerSetting` JSON 字符串，保持 `enabled:false`/`status:DISABLED`。",
+    "**START/END 必须显式给出（2026-09-22 实测，勿与 cp-model 的 scripts/rule.js 混淆——那套会自动补，本工具不补）**：`nodes` 必须含恰好 1 个 START 与 ≥1 个 END，缺了干 lint 直接拒（rule-graph-start-count / rule-graph-end-missing）；工具只合成 CUSTOM_NODE/SYSTEM_* 预置节点，不补 START/END。数据事件规则必须挂平台预置 `Create` 触发行才分发；跨表落库用 SYSTEM_CREATE 系统节点，动作节点排其前。",
+    "**系统/定时/流程节点（ticket 27）**：GET_LIST/LOAD/AVAILABLE/CANCEL/SCHEDULER/EXCEPTION/HINT 已入已知集并有形状模板；SCHEDULER 必须同时在 `nodeGraph.schedulerSetting` 传规则级调度形状（节点上无时机字段，缺它则规则保存成功但永不触发）。",
+    "**条件执行**：① 单分支→动作节点自身 `filterCondition`（UPDATE/DELETE/ASSIGN 的 `mainConditions`：身份匹配 DYNAMIC + 固定条件 FIXED，同叶组 AND）。② 多路分支→`BRANCH` 节点：出口叶（DataFilterCondition）键为 `{currentSchemaDataItem(左值),ruleDataConditionType(操作符),ruleValueType,value}`，出路由 `routeCondition:true` 走条件、`false` 兜底 else。**别照抄其它条件组的 targetSchemaDataItem+ruleConditionType——未知键 save+publish 过但运行时 50000（lint fail closed `rule-graph-branch-condition-keys`）**。按数据走流程流转用 `ruleConditionGroup`。",
+    "**生命周期铁律（2026-09-11 live 取证）**：update 只写 DRAFT 工作行，get/list 读 PUBLISH 面因此看不到变化——必须再 `rule.enable`（publish 出新版本 + 翻 DRAFT 启用开关）才会生效；数据事件分发：DRAFT 保存不触发，submit（DRAFT→COMPLETED）触发 Create。保存 ≠ 设计器可见：readback 的 `published:false` + nextAction 标明尚未发布；传 `publish:true` 可在同一次调用内发布新版本（仅发布，启用仍走 `rule.enable`）。",
+    "**BizMethod 绑定（ticket 35/96）**：BIZ_ACTION / GET_LIST(BIZ_SERVICE) 的 methodMapping 须逐键对 8.6.26 DTO（codeType int 0=CONST/1=PROPERTY…；非语义键原样透传）；写前 wire 校验服务+方法真实存在（get_by_code + list_by_service_code），悬空即 refused `rule-graph-bizmethod-unresolved`——平台只拦服务不拦方法，绝不用注册壳冒充已发布 BizMethod；RESTFUL/DATA_SQL 方法必须带适配器必需 configJson 键，只有名字/参数面的注册壳 refused `rule-graph-bizmethod-registration-shell`；映射 `required` 以方法参数面为权威镜像（省略→按面填入，面缺席→保持缺席，显式矛盾→本地拒绝零写入）。",
+    "**幻影 schema 门（ticket 96 live 事故）**：rule.save 写前先以 bizmodels/get_all 探测模型存在（缺失 → refused `rule-schema-unresolved`，零规则面 wire 调用）——平台的 list/save 面会对任意 schemaCode 自动补建 7 条预置规则且 API 删除不可达（list 即重灌），幻影 schema 必须在写前拒绝。",
+    "**输出回写排序（ticket 36 live 铁证）**：BIZ_ACTION 的 outputMappings 由 SYSTEM_CREATE/SYSTEM_UPDATE 持久化节点消费，动作节点必须排在系统节点之前（`Start→BizAction→SYSTEM_CREATE→End`）；工具默认把系统节点补在 START 之后，有回写动作时须显式提供系统节点并置于动作之后，否则合并结果不落库（echoResult 恒 null）。",
+]);
+export const BUSINESSRULE_LANE_CONTRACT = Object.freeze({
+    lane: LANES.businessrule,
+    family: CONTRACT_FAMILY,
+    referenceVersion: CONTRACT_REFERENCE_VERSION,
+    endpoints: Object.freeze({
+        list: "businessRuleListBySchemaCode",
+        runtimeList: "runtimeBusinessRuleListBySchemaCode",
+        get: "businessRuleGet",
+        create: "businessRuleCreate",
+        update: "businessRuleUpdate",
+    }),
+    wire: Object.freeze({
+        inputParam: RULE_NODE_GRAPH_WIRE.inputParam,
+        valueTypes: RULE_NODE_GRAPH_WIRE.valueTypes,
+        actionTypes: RULE_NODE_GRAPH_WIRE.actionTypes,
+        conditionTypes: RULE_NODE_GRAPH_WIRE.conditionTypes,
+        nodeTypes: RULE_NODE_GRAPH_WIRE.nodeTypes,
+        nodeTemplates: Object.fromEntries(Object.entries(RULE_NODE_TEMPLATES).map(([type, entry]) => [type, entry.template])),
+        schedulerSettingTemplate: RULE_SCHEDULER_SETTING_TEMPLATE,
+        dryLint: "rule.save 出门前跑图校验（DYNAMIC 键位/路由连通/inputParam 链/nodeType↔dataTriggerType/GET_LIST dataSourceType/EXCEPTION errMsg/HINT content/SCHEDULER schedulerSetting/methodMapping 逐键），失败返回结构化 blocker",
+        bizMethodMapping: RULE_NODE_GRAPH_WIRE.bizMethodMapping,
+        bizMethodValidation: RULE_NODE_GRAPH_WIRE.bizMethodValidation,
+        bizActionPersistence: RULE_NODE_GRAPH_WIRE.bizActionPersistence,
+        triggerConditions: RULE_NODE_GRAPH_WIRE.triggerConditions,
+        compatibilityMatrix: "CREATE -> dictionary-backed selection is blocked by evidence; use UPDATE after CREATE. Rule EXPRESSION requires non-empty value.formula and never reuses FORMULA(100) parsing.",
+        dynamicConditionSource: RULE_NODE_GRAPH_WIRE.dynamicConditionSource,
+        dynamicActionSource: RULE_NODE_GRAPH_WIRE.dynamicActionSource,
+        dynamicConditionValue: RULE_NODE_GRAPH_WIRE.dynamicConditionValue,
+        dynamicActionValue: RULE_NODE_GRAPH_WIRE.dynamicActionValue,
+        dynamicNameKeys: RULE_NODE_GRAPH_WIRE.dynamicNameKeys,
+        fixedValueTypes: RULE_NODE_GRAPH_WIRE.fixedValueTypes,
+        triggerDispatch: RULE_NODE_GRAPH_WIRE.triggerDispatch,
+        upsertPreserves: "update keeps the existing enabled/status; create writes the DISABLED dead state",
+        lifecycle: "update writes the DRAFT working row; rule.enable publishes the new version and flips the DRAFT switch",
+        platformQuirk: RULE_PLATFORM_QUIRK,
+    }),
+    wireBindings: Object.freeze({
+        inputParam: Object.freeze([emitterBinding("lanes/rule-graph.RULE_TRIGGER_INPUT_PARAM", assertBusinessRuleContract)]),
+        valueTypes: Object.freeze([emitterBinding("lanes/rule-graph.RULE_VALUE_TYPES", assertBusinessRuleContract)]),
+        actionTypes: Object.freeze([emitterBinding("lanes/rule-graph.RULE_ACTION_TYPES", assertBusinessRuleContract)]),
+        conditionTypes: Object.freeze([emitterBinding("lanes/rule-graph.RULE_CONDITION_TYPES", assertBusinessRuleContract)]),
+        nodeTypes: Object.freeze([emitterBinding("lanes/rule-graph.RULE_NODE_TYPES", assertBusinessRuleContract)]),
+        nodeTemplates: Object.freeze([emitterBinding("lanes/rule-graph.RULE_NODE_TEMPLATES", assertBusinessRuleContract)]),
+        schedulerSettingTemplate: Object.freeze([emitterBinding("lanes/rule-graph.RULE_SCHEDULER_SETTING_TEMPLATE", assertBusinessRuleContract)]),
+        dryLint: Object.freeze([behaviorBinding("test/rule-graph-validation.test.ts#rule.save refuses a mis-shaped graph BEFORE any wire call", assertBusinessRuleContract)]),
+        bizMethodMapping: Object.freeze([behaviorBinding("test/b2-bizmethod-binding.test.ts#ticket 35 dry lint: methodMapping element shape is located per key", assertBusinessRuleContract)]),
+        bizMethodValidation: Object.freeze([behaviorBinding("test/b2-bizmethod-binding.test.ts#ticket 35 wire gate: dangling serviceMethodCode is refused before any rule write", assertBusinessRuleContract)]),
+        bizActionPersistence: Object.freeze([behaviorBinding("test/rule-list.test.ts#DYNAMIC UPDATE uses the production source-field wire and backfills the related target row", assertBusinessRuleContract)]),
+        triggerConditions: Object.freeze([behaviorBinding("test/rule-graph-validation.test.ts#C.2: UPDATE with an empty filterCondition is flagged (warning) as a whole-table operation", assertBusinessRuleContract)]),
+        compatibilityMatrix: Object.freeze([behaviorBinding("test/ticket-05-rule-compatibility-preflight.test.ts#known-invalid CREATE plus dictionary selection is refused before rule mutation", assertBusinessRuleContract)]),
+        dynamicConditionSource: Object.freeze([emitterBinding("lanes/rule-graph.DYNAMIC_CONDITION_SOURCE_KEY", assertBusinessRuleContract)]),
+        dynamicActionSource: Object.freeze([emitterBinding("lanes/rule-graph.DYNAMIC_ACTION_SOURCE_KEY", assertBusinessRuleContract)]),
+        dynamicConditionValue: Object.freeze([behaviorBinding("test/rule-graph-validation.test.ts#negative: ticket 09 lesion", assertBusinessRuleContract)]),
+        dynamicActionValue: Object.freeze([behaviorBinding("test/rule-graph-validation.test.ts#negative: ticket 09 lesion", assertBusinessRuleContract)]),
+        dynamicNameKeys: Object.freeze([behaviorBinding("test/rule-list.test.ts#DYNAMIC UPDATE uses the production source-field wire", assertBusinessRuleContract)]),
+        fixedValueTypes: Object.freeze([behaviorBinding("test/rule-list.test.ts#FIXED value typing remains explicit in the businessrule contract and fake", assertBusinessRuleContract)]),
+        triggerDispatch: Object.freeze([behaviorBinding("test/ticket-111-contract-fixes.test.ts#contract: trigger-dispatch and FIXED-typing facts are pinned", assertBusinessRuleContract)]),
+        upsertPreserves: Object.freeze([emitterBinding("lanes/businessrule-contract.RULE_CREATE_BODY", assertBusinessRuleContract)]),
+        lifecycle: Object.freeze([behaviorBinding("test/rule-save-publish.test.ts#rule.save without publish reports the draft-only state", assertBusinessRuleContract)]),
+        platformQuirk: Object.freeze([emitterBinding("lanes/businessrule-contract.RULE_PLATFORM_QUIRK", assertBusinessRuleContract)]),
+    }),
+    evidence: Object.freeze([
+        "ticket 02 (2026-09-11): cross-model UPDATE with inputParam:\"schemaCode\" dry-gates clean but silently no-ops at runtime; inputParam:\"_input\" is the live-proven binding",
+        "ticket 09 production capture (2026-09-11): DYNAMIC filter source is currentSchemaDataItem and DYNAMIC action source is currentDataItemValue; DYNAMIC value is empty; *Name keys are display-string metadata",
+        "ticket 09 production capture (2026-09-11): FIXED select values are JSON array strings, numeric/boolean values are native, and text values are bare strings",
+        "ticket 111 evidence correction (live 2026-09-15 + RadioConverter.java:41-88): FIXED select values are BARE option strings — the JSON array string form ClassCastExceptions inside parseKeyValueMap and passes through unresolved (matched *_key null); the ticket-09 capture recorded a legacy stored shape, not a working write",
+        "RuleExecutorImpl.saveRuleInput registers the trigger input under the name \"_input\"",
+        "ticket 02 (2026-09-11): update writes DRAFT; get/list read PUBLISH; rule.enable is required for the rule to take effect",
+        "ticket 27 (8.6.26 source): RuleNodeType enum has GET_LIST/LOAD/CANCEL/AVAILABLE/SCHEDULER/EXCEPTION/HINT (RuleNodeType.java:26-42); GetListNode.dataSourceType, ExceptionNode.errMsg, HintNode.content are the only semantic node fields; SchedulerSetting is a rule-row column (BusinessRuleModel.java:52-53)",
+        "ticket 35 + 96 (8.6.26 source): BizActionNode.methodMapping is BizMethodMappingModel{schemaCode,serviceCode,serviceName,serviceMethodCode,serviceMethodName,methodCode,businessRuleId,nodeCode,inputMappings,outputMappings}; MappingModel has NO index/required/displayName in 8.6.26 (fwb v2 keys ride along as NON-semantic passthrough — the tool neither adds nor drops them by version); CodeType serializes as int index (0=CONST,1=PROPERTY); BusinessRuleFacadeImpl.addBizMethodMapping gates SERVICE existence only (BUSINESS_SERVICE_NOT_EXIST) — a dangling serviceMethodCode is silently disabled at app import (BizModelExportImportService.parseBusinessRule:2063-2066); ticket 96: mapping `required` mirrors the method parameter face (absent face key keeps the mapping absent), and a RESTFUL/DATA_SQL binding whose method lacks adapter-required configJson keys is refused as a registration shell",
+    ]),
+    tools: Object.freeze({
+        "rule.list": Object.freeze({
+            scope: "latest rule business-field listing",
+            description: "列出某模型的最新业务规则版本，回显 enabled/status/developmentMode/ruleVersion 等业务字段；服务端不过滤，客户端自行筛选。",
+        }),
+        "rule.get": Object.freeze({
+            scope: "rule node route readback",
+            description: "读回一条业务规则的完整定义（businessrule/get?id=），解析并回显 node/route 图 JSON（触发节点、UPDATE/CREATE 动作节点的 targetObjectCode/inputParam/dataActions/filterCondition 等）——规则族读写链的权威读回面，也是对照设计器生成图形的取证入口。",
+        }),
+        "rule.save": Object.freeze({
+            scope: "dead-state CRUD conditional node graphs",
+            description: RULE_SAVE_DESCRIPTION,
+        }),
+        "rule.node.update": Object.freeze({
+            scope: "dead-state CRUD conditional node graphs",
+            description: "精确改一个节点：按 schemaCode+ruleCode 读当前图，把 patch 浅合并到 nodeCode 对应的节点，再走与 rule.save 相同的保存 seam（所有图门禁与读回一致）。用来改一个分支阈值/条件/动作而不必重发整图。nodeCode/nodeType 不可改（平台按 nodeCode 连路由、节点类型不可变）；改完默认只存草稿，生效仍需 rule.enable（publish:true 可顺带发布）。",
+        }),
+    }),
+});
+export function assertBusinessRuleContract() {
+    assertLaneContract(BUSINESSRULE_LANE_CONTRACT);
+    if (RULE_NODE_GRAPH_WIRE.inputParam !== "_input")
+        throw new Error("businessrule contract pins inputParam to the literal _input");
+    assertDescriptionCarries(BUSINESSRULE_LANE_CONTRACT, "rule.save", ["nodeGraph", "rule.enable", "DRAFT", "PUBLISH", "businessrule/update", "schedulerSetting", "methodMapping", "rule-graph-bizmethod-unresolved", "rule-graph-bizmethod-registration-shell", "rule-schema-unresolved", "required", "参数面", "outputMappings", "SYSTEM_CREATE", "publish:true", "published:false", "条件执行", "filterCondition"]);
+    if (!String(BUSINESSRULE_LANE_CONTRACT.wire.compatibilityMatrix).includes("CREATE -> dictionary-backed selection"))
+        throw new Error("businessrule contract must expose the evidence-backed compatibility matrix");
+    assertDescriptionCarries(BUSINESSRULE_LANE_CONTRACT, "rule.get", ["inputParam", "node/route"]);
+    assertDescriptionCarries(BUSINESSRULE_LANE_CONTRACT, "rule.node.update", ["schemaCode", "ruleCode", "nodeCode", "patch", "rule.save", "rule.enable"]);
+    assertDescriptionCarries({ tools: { "rule.nodeGraph": { scope: "node graph", description: ruleNodeGraphDescription() } } }, "rule.nodeGraph", [
+        "inputParam",
+        "_input",
+        RULE_NODE_GRAPH_WIRE.valueTypes,
+        RULE_NODE_GRAPH_WIRE.actionTypes,
+        RULE_NODE_GRAPH_WIRE.conditionTypes,
+        RULE_NODE_GRAPH_WIRE.dynamicConditionSource,
+        RULE_NODE_GRAPH_WIRE.dynamicActionSource,
+        RULE_NODE_GRAPH_WIRE.dynamicConditionValue,
+        RULE_NODE_GRAPH_WIRE.dynamicActionValue,
+        RULE_NODE_GRAPH_WIRE.fixedValueTypes,
+        RULE_NODE_GRAPH_WIRE.triggerDispatch,
+    ]);
+    if (!RULE_NODE_GRAPH_WIRE.triggerDispatch.includes("DomainServiceImpl.java:226-314"))
+        throw new Error("rule contract must pin the ticket-111 trigger-dispatch evidence");
+    if (!RULE_NODE_GRAPH_WIRE.fixedValueTypes.includes("RadioConverter.java:41-88"))
+        throw new Error("rule contract must pin the ticket-111 FIXED typing evidence");
+    if (!RULE_NODE_GRAPH_WIRE.valueTypes.includes("DYNAMIC") || !RULE_NODE_GRAPH_WIRE.valueTypes.includes("FIXED"))
+        throw new Error("businessrule contract must pin the rule value types");
+    if (!RULE_NODE_GRAPH_WIRE.actionTypes.includes("EQUALS"))
+        throw new Error("businessrule contract must pin the rule action types");
+    if (!RULE_NODE_GRAPH_WIRE.conditionTypes.includes("EQ"))
+        throw new Error("businessrule contract must pin the rule condition types");
+    if (!RULE_NODE_GRAPH_WIRE.nodeTypes.includes("START") || !RULE_NODE_GRAPH_WIRE.nodeTypes.includes("SCHEDULER"))
+        throw new Error("businessrule contract must pin the rule node types");
+    if (!RULE_NODE_TEMPLATES.SCHEDULER)
+        throw new Error("businessrule contract must pin the SCHEDULER node template");
+    if (!("triggerTimeType" in RULE_SCHEDULER_SETTING_TEMPLATE))
+        throw new Error("businessrule contract must pin the scheduler setting template");
+    if (!String(BUSINESSRULE_LANE_CONTRACT.wire.dryLint).includes("inputParam"))
+        throw new Error("businessrule contract must describe the dry-lint coverage");
+    if (!RULE_NODE_GRAPH_WIRE.bizMethodMapping.includes("serviceMethodCode"))
+        throw new Error("businessrule contract must pin the biz-method mapping shape");
+    if (!RULE_NODE_GRAPH_WIRE.bizMethodValidation.includes("serviceMethodParameterCode"))
+        throw new Error("businessrule contract must pin the biz-method validation refusal");
+    if (!RULE_NODE_GRAPH_WIRE.bizActionPersistence.includes("SYSTEM_CREATE"))
+        throw new Error("businessrule contract must pin the biz-action persistence ordering");
+    if (!RULE_NODE_GRAPH_WIRE.triggerConditions.includes("filterCondition") || !RULE_NODE_GRAPH_WIRE.triggerConditions.includes("findMainData") || !RULE_NODE_GRAPH_WIRE.triggerConditions.includes("execConditionGroups"))
+        throw new Error("businessrule contract must pin the node trigger-condition semantics (filterCondition/findMainData/execConditionGroups)");
+    if (RULE_NODE_GRAPH_WIRE.dynamicConditionSource !== "currentSchemaDataItem")
+        throw new Error("businessrule contract pins the DYNAMIC condition source key");
+    if (RULE_NODE_GRAPH_WIRE.dynamicActionSource !== "currentDataItemValue")
+        throw new Error("businessrule contract pins the DYNAMIC action source key");
+    if (!RULE_NODE_GRAPH_WIRE.dynamicConditionValue.includes("DYNAMIC"))
+        throw new Error("businessrule contract must pin the DYNAMIC condition value rule");
+    if (!RULE_NODE_GRAPH_WIRE.dynamicActionValue.includes("DYNAMIC"))
+        throw new Error("businessrule contract must pin the DYNAMIC action value rule");
+    if (!RULE_NODE_GRAPH_WIRE.dynamicNameKeys.includes("currentDataItemValueName"))
+        throw new Error("businessrule contract must pin the DYNAMIC display-name keys");
+    if (!("disabled" in RULE_STATUS) || RULE_STATUS.disabled !== "DISABLED")
+        throw new Error("businessrule contract pins the DISABLED dead state");
+    if (!RULE_CREATE_BODY.status || RULE_CREATE_BODY.enabled !== false)
+        throw new Error("businessrule contract pins the create body dead state");
+    if (!RULE_PLATFORM_QUIRK.includes("status"))
+        throw new Error("businessrule contract must pin the enabled/status platform quirk");
+    if (!String(BUSINESSRULE_LANE_CONTRACT.wire.upsertPreserves).includes("DISABLED"))
+        throw new Error("businessrule contract must pin the upsert-preserves rule");
+    if (!String(BUSINESSRULE_LANE_CONTRACT.wire.lifecycle).includes("rule.enable"))
+        throw new Error("businessrule contract must pin the rule lifecycle");
+}
+//# sourceMappingURL=businessrule-contract.js.map

package/dist/lanes/businessrule-coverage.js

@@ -0,0 +1,16 @@
+import { claim, declareLaneCoverage } from "./coverage-declaration.js";
+import { BUSINESSRULE_LANE_CONTRACT } from "./businessrule-contract.js";
+const T = BUSINESSRULE_LANE_CONTRACT.tools;
+export const BUSINESSRULE_COVERAGE = declareLaneCoverage(BUSINESSRULE_LANE_CONTRACT.lane, [
+    {
+        capability: "B1 dead-state rules and B1.2 CRUD/conditional node graphs",
+        evidence: ["src/businessrule-contract.ts", ".scratch/omc-business-rules/acceptance/b1-dead-live-20260908044544040.md"],
+        tools: [claim("rule.save", T["rule.save"].scope), claim("rule.node.update", T["rule.node.update"].scope)],
+    },
+    {
+        capability: "rule.list latest business-rule listing and rule.get node route definition readback",
+        evidence: ["packages/omc-cli/src/tools.ts", "packages/omc-cli/test/rule-list.test.ts"],
+        tools: [claim("rule.list", T["rule.list"].scope), claim("rule.get", T["rule.get"].scope)],
+    },
+]);
+//# sourceMappingURL=businessrule-coverage.js.map

package/dist/lanes/businessrule.js

@@ -0,0 +1,221 @@
+import { z } from "zod";
+import { ENDPOINTS } from "../endpoints.js";
+import { capabilityArg, environmentArg } from "../args.js";
+import { governedRead } from "../read.js";
+import { writeTool } from "../write.js";
+import { decodeJsonColumn, JSON_COLUMN_NULL_COALESCE } from "../json-column.js";
+import { executeRuleSaveWrite, ruleNodeGraphArg } from "../rule-support.js";
+import { defineTool, ToolInputError, ToolRefusalError } from "../tool-types.js";
+import { resolveRuleRowId } from "../identity.js";
+import { wireCall, wireRows } from "../wire.js";
+import { BUSINESSRULE_LANE_CONTRACT } from "./businessrule-contract.js";
+const RULE_LANE = BUSINESSRULE_LANE_CONTRACT.lane;
+const RULE_TOOLS = BUSINESSRULE_LANE_CONTRACT.tools;
+/**
+ * Deterministic layout keys the designer/canvas derives and `prepareRuleGraph`
+ * re-injects on save: a node's `x/y/width/height` and a route's `points`. They
+ * carry no rule semantics, so the default `rule.get` projection drops them and
+ * `full:true` restores the raw stored graph (2026-09-25 cost pass; same pattern
+ * as the workflow route view). Every other key — nodeCode/nodeType/nodeName,
+ * sourceInputMethod/inputParam/judgeMethod, exitConditionGroups, filterCondition,
+ * dataActions, methodMapping, … — is preserved verbatim, so the projection still
+ * round-trips back into `rule.save`.
+ */
+const RULE_NODE_LAYOUT_KEYS = ["x", "y", "width", "height"];
+const RULE_ROUTE_LAYOUT_KEYS = ["points"];
+function projectRuleGraph(nodes, routes, full) {
+    if (full)
+        return { nodes, routes };
+    const strip = (value, keys) => {
+        if (!Array.isArray(value))
+            return value;
+        return value.map((entry) => {
+            if (entry === null || typeof entry !== "object" || Array.isArray(entry))
+                return entry;
+            const copy = { ...entry };
+            for (const key of keys)
+                delete copy[key];
+            return copy;
+        });
+    };
+    return { nodes: strip(nodes, RULE_NODE_LAYOUT_KEYS), routes: strip(routes, RULE_ROUTE_LAYOUT_KEYS) };
+}
+export function registerBusinessRuleLane(tools) {
+    tools.push(defineTool({
+        name: "rule.list",
+        layer: "low",
+        kind: "read",
+        lane: RULE_LANE,
+        scope: RULE_TOOLS["rule.list"].scope,
+        description: RULE_TOOLS["rule.list"].description,
+        inputSchema: {
+            environment: environmentArg,
+            schemaCode: z.string().min(1),
+            full: z.boolean().optional().describe("内联完整规则列表；默认只返回摘要与 detailFile"),
+            capability: capabilityArg,
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            const rows = wireRows((await wireCall(session, { path: ENDPOINTS.runtimeBusinessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } })).data);
+            return {
+                schemaCode: args.schemaCode,
+                rules: rows.map((row) => ({
+                    id: row.id,
+                    code: row.code,
+                    name: row.name,
+                    schemaCode: row.schemaCode,
+                    bizRuleType: row.bizRuleType,
+                    enabled: row.enabled,
+                    status: row.status,
+                    developmentMode: row.developmentMode,
+                    ruleVersion: row.ruleVersion,
+                    latestPublished: row.latestPublished,
+                    templateType: row.templateType,
+                    defaultRule: row.defaultRule,
+                    createdTime: row.createdTime,
+                    creator: row.creater ?? row.creator,
+                })),
+            };
+        }, { full: args.full === true, target: `rule.list:${args.schemaCode}` }),
+    }));
+    tools.push(defineTool({
+        name: "rule.get",
+        layer: "low",
+        kind: "read",
+        lane: RULE_LANE,
+        scope: RULE_TOOLS["rule.get"].scope,
+        description: RULE_TOOLS["rule.get"].description,
+        inputSchema: {
+            environment: environmentArg,
+            id: z.string().min(1).optional().describe("规则记录 id（历史版本行可能指向旧图）；也可改用 schemaCode + ruleCode 业务键定位"),
+            schemaCode: z.string().min(1).optional().describe("业务键定位：模型 code（与 ruleCode 同传，免去先 rule.list 取 id）"),
+            ruleCode: z.string().min(1).optional().describe("业务键定位：规则 code（如 Create/Update/自定义），与 schemaCode 同传"),
+            full: z.boolean().optional().describe("返回原始存储图（含确定性布局 x/y/width/height 与路由 points）；默认返回语义图，确定性布局已投影去掉（可直接重存，保存时会重新生成布局）"),
+            capability: capabilityArg,
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            // Identity seam: prefer the business key (schemaCode + ruleCode) when
+            // given; fall back to the row id. Resolving the business key here removes
+            // the forced rule.list → rule.get dance and the "same code, new id"
+            // confusion (we always read the CURRENT effective row for that code).
+            let ruleId = args.id;
+            if (!ruleId) {
+                if (!args.schemaCode || !args.ruleCode)
+                    throw new ToolInputError({ status: "error", blocker: "tool-input-invalid", tool: "rule.get", message: "需要 id，或 schemaCode + ruleCode 两者一起" });
+                ruleId = (await resolveRuleRowId(session, args.schemaCode, args.ruleCode)) ?? undefined;
+                if (!ruleId)
+                    return { schemaCode: args.schemaCode, ruleCode: args.ruleCode, absent: true };
+            }
+            const record = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id: ruleId } })).data;
+            if (!record)
+                return { id: ruleId, absent: true };
+            // node/route/schedulerSetting are JSON-string columns; policy:
+            // non-strings null-coalesce, unparseable strings pass through.
+            const parse = (value) => decodeJsonColumn(value, JSON_COLUMN_NULL_COALESCE);
+            const routes = parse(record.route);
+            // Ticket 109 — render compatibility: the designer canvas resolves
+            // e.points[0] DIRECTLY per route (admin/js/12404.1675d362.js
+            // addAnnotationToLine), so a route without a non-empty string-array
+            // points breaks RENDERING while the data layer stays green. The
+            // readback reports it instead of letting "data ok" masquerade as
+            // "designer ok".
+            const routeList = Array.isArray(routes) ? routes : [];
+            // renderCompat validates the RAW routes (it needs `points`); the returned
+            // graph is projected separately at the return below.
+            const validPoints = (points) => Array.isArray(points) && points.length > 0 && points.every((point) => typeof point === "string" && point.trim().length > 0);
+            const violations = routeList
+                .map((route, index) => ({ index, route, ok: validPoints(route?.points) }))
+                .filter((entry) => !entry.ok)
+                .map((entry) => ({
+                index: entry.index,
+                preNode: String(entry.route?.preNode ?? ""),
+                postNode: String(entry.route?.postNode ?? ""),
+                problem: "points missing or not non-empty string array",
+            }));
+            const renderCompat = { ok: violations.length === 0, ...(violations.length > 0 ? { violations } : {}) };
+            // Ticket 109 — stale-row detection: same-code saves mint NEW record
+            // ids while old ids stay readable (historical graphs). Reading by a
+            // superseded id shows an OLD graph; flag it and pin the effective id.
+            let staleRow = false;
+            let effectiveId;
+            let staleRowMessage;
+            if (typeof record.schemaCode === "string" && record.schemaCode && typeof record.code === "string" && record.code) {
+                try {
+                    const currentRows = wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: record.schemaCode } })).data);
+                    const current = currentRows.find((row) => row.code === record.code);
+                    if (current?.id && current.id !== ruleId) {
+                        staleRow = true;
+                        effectiveId = String(current.id);
+                        staleRowMessage = "该 id 是历史版本行（同 code 后续保存产生了新记录）；rule.get 用 effectiveId 读当前生效行，否则看到的是旧图";
+                    }
+                }
+                catch {
+                    // the list face being unreachable must not break the row readback
+                }
+            }
+            const projected = projectRuleGraph(parse(record.node), routes, args.full === true);
+            return {
+                id: ruleId,
+                absent: false,
+                code: record.code,
+                name: record.name,
+                schemaCode: record.schemaCode,
+                bizRuleType: record.bizRuleType,
+                enabled: record.enabled,
+                ruleStatus: record.status,
+                defaultRule: record.defaultRule,
+                developmentMode: record.developmentMode,
+                ruleVersion: record.ruleVersion,
+                templateType: record.templateType,
+                nodes: projected.nodes,
+                routes: projected.routes,
+                schedulerSetting: parse(record.schedulerSetting),
+                renderCompat,
+                ...(staleRow ? { staleRow, effectiveId, staleRowMessage } : {}),
+            };
+        }, { full: args.full === true, target: `rule.get:${args.id ?? `${args.schemaCode}/${args.ruleCode}`}` }),
+    }));
+    writeTool(tools, "rule.save", RULE_LANE, RULE_TOOLS["rule.save"].scope, RULE_TOOLS["rule.save"].description, {
+        schemaCode: z.string().min(1),
+        ruleCode: z.string().min(1),
+        name: z.string().min(1),
+        nodeGraph: ruleNodeGraphArg,
+        publish: z.boolean().optional().describe("also publish the new version in this call (businessrule/publish) so the designer sees it; enabling stays with rule.enable — default false keeps the legacy draft-only save"),
+        customTrigger: z.boolean().optional().describe("默认开：自定义 ruleCode + bizRuleType 0（非平台触发码 Create/Update/Delete/GetList/Load/Available/Cancel）即按钮/流程规则，工具在 START 后合成平台标准 CUSTOM_NODE「自定义按钮/流程触发」系统触发节点（nodeCode=ruleCode，live 布局 x558/y233）；调用方已写 CUSTOM_NODE 则原样保留；显式 false 退回"),
+    }, async (session, args) => executeRuleSaveWrite(session, args));
+    // Round 10 (issue 04) — precise modify. `rule.save` replaces the WHOLE nodeGraph,
+    // so changing one branch threshold meant read the whole graph, edit, resend. This
+    // tool reads the current graph, patches ONE node, and reuses the same save seam
+    // (so every graph gate + readback is identical). Platform constraints honoured:
+    // `nodeCode`/`nodeType` are immutable (routes reference nodeCode; the platform
+    // cannot retype a node), so the patch may not change them.
+    writeTool(tools, "rule.node.update", RULE_LANE, RULE_TOOLS["rule.node.update"].scope, RULE_TOOLS["rule.node.update"].description, {
+        schemaCode: z.string().min(1),
+        ruleCode: z.string().min(1),
+        nodeCode: z.string().min(1).describe("要改的节点 nodeCode（在现有图里定位，不是新建）"),
+        patch: z.record(z.string(), z.unknown()).describe("浅合并到该节点的字段（如 exitConditionGroups/filterCondition/dataActions/nodeName）；不允许改 nodeCode/nodeType"),
+        publish: z.boolean().optional().describe("改完同样顺带 publish（默认 false，仅存草稿；生效仍需 rule.enable）"),
+        customTrigger: z.boolean().optional(),
+    }, async (session, args) => {
+        const id = await resolveRuleRowId(session, args.schemaCode, args.ruleCode);
+        if (!id)
+            throw new ToolRefusalError({ status: "refused", blocker: "rule-absent", message: `规则 ${args.schemaCode}.${args.ruleCode} 不存在；拒绝 node patch` });
+        const record = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id } })).data;
+        if (!record)
+            throw new ToolRefusalError({ status: "refused", blocker: "rule-absent", message: `规则 ${args.schemaCode}.${args.ruleCode}（id ${id}）读回为空` });
+        for (const key of ["nodeCode", "nodeType"])
+            if (key in args.patch)
+                throw new ToolRefusalError({ status: "refused", blocker: "rule-node-immutable-key", message: `node patch 不允许改 ${key}（平台按 nodeCode 连接路由、节点类型不可变）；要改名/改型请整图 rule.save` });
+        // node/route are SEPARATE JSON-string columns (see rule.get): `node` is the
+        // nodes array, `route` the routes array — not one {nodes,routes} object.
+        const nodes = decodeJsonColumn(record.node, JSON_COLUMN_NULL_COALESCE);
+        const routes = decodeJsonColumn(record.route, JSON_COLUMN_NULL_COALESCE);
+        const nodeList = Array.isArray(nodes) ? nodes : [];
+        const target = nodeList.find((node) => node.nodeCode === args.nodeCode);
+        if (!target)
+            throw new ToolRefusalError({ status: "refused", blocker: "rule-node-absent", message: `现有图中没有 nodeCode=${args.nodeCode}；用 rule.get schemaCode+ruleCode 查看 nodeCode` });
+        const mergedNode = { ...target, ...args.patch };
+        const mergedGraph = { nodes: nodeList.map((node) => (node.nodeCode === args.nodeCode ? mergedNode : node)), ...(Array.isArray(routes) ? { routes } : {}) };
+        return executeRuleSaveWrite(session, { schemaCode: args.schemaCode, ruleCode: args.ruleCode, name: String(record.name ?? args.ruleCode), nodeGraph: mergedGraph, ...(args.publish === true ? { publish: true } : {}), ...(args.customTrigger === true ? { customTrigger: true } : {}) });
+    });
+}
+//# sourceMappingURL=businessrule.js.map

package/dist/lanes/contract-support.js

@@ -0,0 +1,65 @@
+import { ENDPOINTS } from "../endpoints.js";
+export const CONTRACT_FAMILY = "8.6";
+export const CONTRACT_REFERENCE_VERSION = "8.6.26";
+/**
+ * An emitter/fake/decoder actually imports and consumes the referenced value,
+ * and `verify` re-checks the platform truth against it.
+ */
+export function emitterBinding(ref, verify) {
+    return Object.freeze({ kind: "emitter-constant", ref, verify });
+}
+/**
+ * The referenced behavior test proves the fact. `verify` runs the lane's
+ * shared contract assertion (the same seam the test calls) so a constant or
+ * emitter change fails both the test and the build gate.
+ */
+export function behaviorBinding(ref, verify) {
+    return Object.freeze({ kind: "behavior-test", ref, verify });
+}
+/** A UI-only fact proven by a conformance/frontend-oracle assertion id. */
+export function oracleBinding(ref, verify) {
+    return Object.freeze({ kind: "oracle", ref, verify });
+}
+/** Compose a tool description from one lead sentence plus ordered guide sentences. */
+export function describeTool(lead, guides) {
+    return [lead, ...guides]
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0)
+        .join(" ");
+}
+/** Shared per-lane invariants; every lane's assertXxxContract() starts here. */
+export function assertLaneContract(contract) {
+    if (!contract.lane.trim())
+        throw new Error("lane contract requires a lane name");
+    if (contract.family !== CONTRACT_FAMILY)
+        throw new Error(`${contract.lane} contract must target family ${CONTRACT_FAMILY}`);
+    if (contract.referenceVersion !== CONTRACT_REFERENCE_VERSION)
+        throw new Error(`${contract.lane} contract must anchor on ${CONTRACT_REFERENCE_VERSION}`);
+    const toolNames = Object.keys(contract.tools);
+    if (toolNames.length === 0)
+        throw new Error(`${contract.lane} contract must declare at least one tool`);
+    for (const name of toolNames) {
+        const tool = contract.tools[name];
+        if (!tool.scope.trim())
+            throw new Error(`${name} requires a coverage scope`);
+        if (!tool.description.trim())
+            throw new Error(`${name} requires a description`);
+    }
+    for (const [label, key] of Object.entries(contract.endpoints)) {
+        if (!(key in ENDPOINTS))
+            throw new Error(`${contract.lane} endpoint ${label} -> ${key} is not a live-proven ENDPOINTS key`);
+    }
+    if (contract.evidence.length === 0)
+        throw new Error(`${contract.lane} contract requires at least one evidence anchor`);
+    if (Object.keys(contract.wire).length === 0)
+        throw new Error(`${contract.lane} contract requires wire facts`);
+}
+/** Assert every listed wire token appears verbatim in a tool's contract description. */
+export function assertDescriptionCarries(contract, toolName, tokens) {
+    const description = contract.tools[toolName]?.description ?? "";
+    for (const token of tokens) {
+        if (!description.includes(token))
+            throw new Error(`${toolName} description must carry the contract token ${JSON.stringify(token)}`);
+    }
+}
+//# sourceMappingURL=contract-support.js.map

package/dist/lanes/coverage-declaration.js

@@ -0,0 +1,9 @@
+/** Declare one tool's scope claim inside a capability. */
+export function claim(tool, scope) {
+    return Object.freeze({ tool, scope });
+}
+/** Group a lane's capability declarations, injecting the lane id once. */
+export function declareLaneCoverage(lane, capabilities) {
+    return Object.freeze(capabilities.map((capability) => Object.freeze({ lane, ...capability })));
+}
+//# sourceMappingURL=coverage-declaration.js.map