@stalfh233/omc-cli 0.4.49 → 0.4.51

package/dist/cli.js

@@ -20,6 +20,7 @@ import { resolve } from "node:path";
 import { buildToolRegistry } from "./tools.js";
 import { acquireWriteLock } from "./write-lock.js";
 import { cmdCompute } from "./compute.js";
+import { cmdRuleWhen } from "./rule-when.js";
 // --utf8：单次调用明文输出（等效 OMC_ASCII_STDOUT=0）。在 asciiStdout 缓存读取前生效。
 if (process.argv.includes("--utf8"))
     process.env.OMC_ASCII_STDOUT = "0";
@@ -947,6 +948,10 @@ async function main() {
         const rest = ["compute", ...(options.schema ? ["--schema", options.schema] : []), ...(options.schemaCode ? ["--schema-code", options.schemaCode] : []), ...(options.target ? ["--target", options.target] : []), ...(options.property ? ["--property", options.property] : []), ...(options.formula !== undefined ? ["--formula", options.formula] : []), ...(options.name ? ["--name", options.name] : []), ...(options.env ? ["--env", options.env] : []), ...(options.environment ? ["--environment", options.environment] : []), ...(options.apply ? ["--apply"] : [])];
         commandExitCode = await cmdCompute(rest);
     });
+    command.command("rule-when").option("--schema <schemaCode>").option("--schema-code <schemaCode>").option("--on <trigger>").option("--when <condition>", undefined, { variadic: true }).option("--then <action>", undefined, { variadic: true }).option("--name <name>").option("--env <environment>").option("--environment <environment>").option("--apply").addHelpText("after", "\n条件-动作规则拼装器：--when 条件（可多个 AND）→ --then set:字段=值/引用/公式。编译为设计器验证形状（预置触发+UPDATE filter/赋值）。默认 dry-run，--apply 保存并发布；前台生效按输出清单人工验证。\n").action(async (options) => {
+        const rest = ["rule-when", ...(options.schema ? ["--schema", options.schema] : []), ...(options.schemaCode ? ["--schema-code", options.schemaCode] : []), ...(options.on ? ["--on", options.on] : []), ...(Array.isArray(options.when) ? options.when.flatMap((w) => ["--when", w]) : []), ...(Array.isArray(options.then) ? options.then.flatMap((a) => ["--then", a]) : []), ...(options.name ? ["--name", options.name] : []), ...(options.env ? ["--env", options.env] : []), ...(options.environment ? ["--environment", options.environment] : []), ...(options.apply ? ["--apply"] : [])];
+        commandExitCode = await cmdRuleWhen(rest);
+    });
     command.command("script [file]").option("--env <environment>", "行内无 env 时的默认环境").option("--continue", "某行失败后继续执行剩余行（默认停在首个失败）").description("NDJSON 多调脚本：每行 {\"tool\":\"<名称>\",\"args\":{...},\"env\":\"<环境>\",\"dryRun\":true}（# 注释/空行忽略；file 为 - 读 stdin）；一个进程一次会话跑完全部，逐行输出 {index,tool,exitCode,result}").action(async (file, options) => {
         const { runScript, parseScript, readScriptInput } = await import("./script.js");
         let lines;

package/dist/lanes/rule-graph.js

@@ -1023,11 +1023,13 @@ export function countConditionLeaves(container) {
     return count;
 }
 /** Validate one condition leaf; returns blockers (empty = clean). */
-export function validateConditionLeaf(leaf, nodeCode, where, warnings) {
+export function validateConditionLeaf(leaf, nodeCode, where, warnings, legacyTolerant = false) {
     const blockers = [];
     const valueType = String(leaf.ruleValueType ?? "");
     if (!RULE_CONDITION_VALUE_TYPES.includes(valueType)) {
-        if (valueType === "specifyOption")
+        if (legacyTolerant && valueType)
+            warnings?.push({ code: "rule-graph-legacy-operator-roundtrip", nodeCode, key: "ruleValueType", severity: "warning", message: `${where}: ruleValueType "${valueType}" 是存量携带的设计器取值类型（round-trip 原样保留）；新增取值请用 ${RULE_CONDITION_VALUE_TYPES.join("/")}` });
+        else if (valueType === "specifyOption")
             warnings?.push({ code: "rule-graph-legacy-operator-roundtrip", nodeCode, key: "ruleValueType", severity: "warning", message: `${where}: ruleValueType "specifyOption" 是设计器 UI 独有下拉取值类型——按原样保留回传（round-trip 保真），OMC 不支持新建；新增取值请用 ${RULE_CONDITION_VALUE_TYPES.join("/")}` });
         else
             blockers.push({ code: "rule-graph-condition-value-type", nodeCode, key: "ruleValueType", message: `${where}: ruleValueType "${valueType}" 不在 ${RULE_CONDITION_VALUE_TYPES.join("/")}（当前叶：${JSON.stringify(leaf)}）` });
@@ -1065,13 +1067,17 @@ export function validateConditionLeaf(leaf, nodeCode, where, warnings) {
             blockers.push({ code: "rule-graph-condition-today-offset-missing", nodeCode, key: DYNAMIC_CONDITION_SOURCE_KEY, message: `${where}: ruleValueType "today" 的日期偏移必须放在 ${DYNAMIC_CONDITION_SOURCE_KEY}（运行时 Integer.parseInt(source)）——如 "0"=今天、"-7"=7天前、"30"=30天后、"-1-week"/"2-month" 带单位；缺失或非数字会在查询时抛 NumberFormatException，扫描 0 行、规则「永不触发」（真机 2026-10-08）。` });
     }
     if (leaf.ruleConditionType !== undefined && !RULE_CONDITION_TYPES.includes(String(leaf.ruleConditionType))) {
-        if (String(leaf.ruleConditionType) === "CHANGED")
+        if (legacyTolerant)
+            warnings?.push({ code: "rule-graph-legacy-operator-roundtrip", nodeCode, key: "ruleConditionType", severity: "warning", message: `${where}: ruleConditionType "${String(leaf.ruleConditionType)}" 是存量携带的设计器算子（round-trip 原样保留）；新增条件请用 ${RULE_CONDITION_TYPES.join("/")}` });
+        else if (String(leaf.ruleConditionType) === "CHANGED")
             warnings?.push({ code: "rule-graph-legacy-operator-roundtrip", nodeCode, key: "ruleConditionType", severity: "warning", message: `${where}: ruleConditionType "CHANGED" 是设计器 UI 独有变更检测算子——按原样保留回传（round-trip 保真），OMC 不支持新建此类算子；新增条件请用 ${RULE_CONDITION_TYPES.join("/")}` });
         else
             blockers.push({ code: "rule-graph-condition-type", nodeCode, key: "ruleConditionType", message: `${where}: ruleConditionType "${String(leaf.ruleConditionType)}}" 不在 ${RULE_CONDITION_TYPES.join("/")}` });
     }
     if (leaf[BRANCH_EXIT_OPERATOR_KEY] !== undefined && !RULE_CONDITION_TYPES.includes(String(leaf[BRANCH_EXIT_OPERATOR_KEY]))) {
-        if (String(leaf[BRANCH_EXIT_OPERATOR_KEY]) === "CHANGED")
+        if (legacyTolerant)
+            warnings?.push({ code: "rule-graph-legacy-operator-roundtrip", nodeCode, key: BRANCH_EXIT_OPERATOR_KEY, severity: "warning", message: `${where}: ${BRANCH_EXIT_OPERATOR_KEY} "${String(leaf[BRANCH_EXIT_OPERATOR_KEY])}" 是存量携带的设计器算子（round-trip 原样保留）；新增条件请用 ${RULE_CONDITION_TYPES.join("/")}` });
+        else if (String(leaf[BRANCH_EXIT_OPERATOR_KEY]) === "CHANGED")
             warnings?.push({ code: "rule-graph-legacy-operator-roundtrip", nodeCode, key: BRANCH_EXIT_OPERATOR_KEY, severity: "warning", message: `${where}: ${BRANCH_EXIT_OPERATOR_KEY} "CHANGED" 是设计器 UI 独有变更检测算子——按原样保留回传（round-trip 保真），OMC 不支持新建此类算子；新增条件请用 ${RULE_CONDITION_TYPES.join("/")}` });
         else
             blockers.push({ code: "rule-graph-condition-type", nodeCode, key: BRANCH_EXIT_OPERATOR_KEY, message: `${where}: ${BRANCH_EXIT_OPERATOR_KEY} "${String(leaf[BRANCH_EXIT_OPERATOR_KEY])}" 不在 ${RULE_CONDITION_TYPES.join("/")}` });
@@ -1328,7 +1334,7 @@ export function validatePresetSystemNodeIdentity(nodesInput, ruleCode) {
     }
     return blockers;
 }
-export function validateRuleNodeGraph(graph, ruleCode, schemaCode) {
+export function validateRuleNodeGraph(graph, ruleCode, schemaCode, options = {}) {
     const blockers = [];
     const warnings = [];
     const merged = () => [...blockers, ...warnings];
@@ -1338,6 +1344,8 @@ export function validateRuleNodeGraph(graph, ruleCode, schemaCode) {
         return [{ code: "rule-graph-empty", message: "nodeGraph.nodes 不能为空" }];
     }
     const nodeRecords = nodes.filter((node) => Boolean(node && typeof node === "object"));
+    const carried = options.carriedNodeCodes;
+    const relaxEnums = options.relaxEnums === true;
     if (nodeRecords.length !== nodes.length)
         blockers.push({ code: "rule-graph-node-not-object", message: "nodes 中存在非对象元素" });
     // Cross-model write-back: SUPPORTED (verified live 2026-09-28). An UPDATE whose
@@ -1503,7 +1511,7 @@ export function validateRuleNodeGraph(graph, ruleCode, schemaCode) {
             if (!filter || typeof filter !== "object")
                 blockers.push({ code: "rule-graph-filter-missing", nodeCode, key: "filterCondition", message: `${nodeType} 节点缺 filterCondition（mainConditions/sheetConditions）` });
             else {
-                walkConditionLeaves(filter, (leaf, where) => blockers.push(...validateConditionLeaf(leaf, nodeCode, where, warnings)));
+                walkConditionLeaves(filter, (leaf, where) => blockers.push(...validateConditionLeaf(leaf, nodeCode, where, warnings, (relaxEnums || carried?.has(String(node.nodeCode ?? "")) === true))));
                 // Platform label (HANDOFF C.2 / evidence §4): UPDATE.filterCondition =
                 // 「查找满足条件的主表数据」(which row to update), DELETE.filterCondition =
                 // 「删除满足条件的数据」. An EMPTY mainConditions therefore means the node
@@ -1544,7 +1552,7 @@ export function validateRuleNodeGraph(graph, ruleCode, schemaCode) {
             if (node.targetConditionGroups !== undefined) {
                 if (Array.isArray(node.targetConditionGroups))
                     blockers.push({ code: "rule-graph-query-condition-group-shape", nodeCode, key: "targetConditionGroups", message: "QUERY 的 targetConditionGroups 必须是对象 {mainConditions:[[叶…]],sheetConditions:[[叶…]]}（TableConditionGroup.java），不能是裸数组 [[…]]（那是 filterCondition/exitConditionGroups 的形状）——裸数组 save 通过但 live businessrule/update 50000（真机 2026-10-07）。" });
-                walkConditionLeaves(node.targetConditionGroups, (leaf, where) => blockers.push(...validateConditionLeaf(leaf, nodeCode, where, warnings)));
+                walkConditionLeaves(node.targetConditionGroups, (leaf, where) => blockers.push(...validateConditionLeaf(leaf, nodeCode, where, warnings, (relaxEnums || carried?.has(String(node.nodeCode ?? "")) === true))));
                 scanConditionKeyCollisions(node.targetConditionGroups, nodeCode, warnings);
             }
         }
@@ -1584,7 +1592,7 @@ export function validateRuleNodeGraph(graph, ruleCode, schemaCode) {
                 blockers.push({ code: "rule-graph-branch-conditions", nodeCode, key: "exitConditionGroups", message: "BRANCH 节点缺 exitConditionGroups（[[叶]] 与或组）" });
             else {
                 walkConditionLeaves(node.exitConditionGroups, (leaf, where) => {
-                    blockers.push(...validateConditionLeaf(leaf, nodeCode, where, warnings));
+                    blockers.push(...validateConditionLeaf(leaf, nodeCode, where, warnings, (relaxEnums || carried?.has(String(node.nodeCode ?? "")) === true)));
                     // 8.6.26: exitConditionGroups deserialize into DataFilterCondition, whose
                     // left/source key is currentSchemaDataItem and operator key is
                     // ruleDataConditionType. The UI/line-shaped targetSchemaDataItem +
@@ -1652,7 +1660,7 @@ export function validateRuleNodeGraph(graph, ruleCode, schemaCode) {
             if (node.aggregation !== undefined && typeof node.aggregation !== "boolean")
                 blockers.push({ code: "rule-graph-create-aggregation", nodeCode, key: "aggregation", message: "CREATE 节点 aggregation 存在时必须是布尔（true=分组新增 / false=单条依次新增）" });
             if (node.findMainData !== undefined)
-                walkConditionLeaves(node.findMainData, (leaf, where) => blockers.push(...validateConditionLeaf(leaf, nodeCode, where, warnings)));
+                walkConditionLeaves(node.findMainData, (leaf, where) => blockers.push(...validateConditionLeaf(leaf, nodeCode, where, warnings, (relaxEnums || carried?.has(String(node.nodeCode ?? "")) === true))));
             if (node.filterCondition !== undefined)
                 walkConditionLeaves(node.filterCondition, (leaf, where) => blockers.push(...validateConditionLeaf(leaf, nodeCode, where)));
             scanConditionKeyCollisions(node.filterCondition, nodeCode, warnings);

package/dist/rule-support.js

@@ -425,6 +425,44 @@ export async function assertRuleSchemaExists(session, schemaCode) {
         });
     }
 }
+/** 与存量图逐节点稳定序列化比对，得出"原样携带"节点集合（round-trip 放宽）。 */
+export async function computeCarriedNodeCodes(session, schemaCode, ruleCode, preparedGraph) {
+    try {
+        const { resolveRuleRowId } = await import("./identity.js");
+        const { wireCall } = await import("./wire.js");
+        const { ENDPOINTS } = await import("./endpoints.js");
+        const existingId = await resolveRuleRowId(session, schemaCode, ruleCode);
+        if (!existingId)
+            return undefined;
+        const row = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id: existingId } })).data;
+        if (!row || typeof row.node !== "string")
+            return undefined;
+        const currentNodes = JSON.parse(row.node);
+        if (!Array.isArray(currentNodes) || !Array.isArray(preparedGraph.nodes))
+            return undefined;
+        const stable = (value) => {
+            if (Array.isArray(value))
+                return "[" + value.map(stable).join(",") + "]";
+            if (value && typeof value === "object") {
+                return "{" + Object.keys(value).sort().map((k) => JSON.stringify(k) + ":" + stable(value[k])).join(",") + "}";
+            }
+            return JSON.stringify(value) ?? "null";
+        };
+        const carried = new Set();
+        for (const node of preparedGraph.nodes) {
+            const code = String(node?.nodeCode ?? "");
+            if (!code)
+                continue;
+            const match = currentNodes.find((cur) => String(cur?.nodeCode ?? "") === code);
+            if (match && stable(match) === stable(node))
+                carried.add(code);
+        }
+        return carried;
+    }
+    catch {
+        return undefined; // 取不到存量图 → 维持严格闭集，行为与放宽前一致
+    }
+}
 export async function executeRuleSaveWrite(session, args) {
     // Pre-flight dry lint (ticket 14): a mis-shaped graph must be refused BEFORE
     // any wire call, with structured blockers locating the node/key — never
@@ -446,7 +484,11 @@ export async function executeRuleSaveWrite(session, args) {
     // graph: preset system node → button/flow CUSTOM_NODE trigger → route shape.
     const prepared = prepareRuleGraph(args.ruleCode, graph, args.customTrigger, args.schemaCode);
     const preparedGraph = prepared.graph;
-    const blockers = [...prepared.warnings, ...validateRuleNodeGraph(preparedGraph, args.ruleCode, typeof args.schemaCode === "string" ? args.schemaCode : undefined)];
+    // 回读差异放宽（中冶 2026-10-16）：更新已存在规则时取存量图逐节点比对，
+    // 与存量完全一致的"原样携带"节点免闭集硬校验（设计器 UI 独有算子降级
+    // 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 } : {})];
     // 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");

package/dist/rule-when.js

@@ -0,0 +1,138 @@
+/**
+ * `omc rule-when` — 条件-动作规则拼装器（v1：预置触发 + 单 UPDATE 节点）。
+ *
+ * 中冶 2026-10-16 后续：规则面三大高频形态之三（计算=omc compute、定时=recipe、
+ * 条件动作=本命令）。把「当 X 满足条件 → 给字段设值」压成一条平铺命令：
+ *
+ *   omc rule-when --schema s --on update \
+ *     --when "status=履行中" --when "amount>=100000" \
+ *     --then "set:level=A" --then "set:total={amount}*0.9" [--apply]
+ *
+ * 编译目标只用**设计器验证过**的形状（前台生效约束，2026-10-16 用户裁决：后端
+ * 接口大量不拦截，save/publish 通过≠门户生效）：
+ * - 预置触发行 Create/Update（设计器原生行，非自定义）
+ * - 单 UPDATE 节点：filterCondition（查找满足条件的主表数据）+ dataActions（赋值）
+ * - FIXED 字面量 / DYNAMIC 字段引用 / EXPRESSION 公式（含 DATEDIF 语法，均真机验证）
+ * - 布局/路由交给 prepareRuleGraph 注入（points 画布兼容，Ticket 109）
+ *
+ * 产出必带前台验证清单：运行时行为（分支是否真跑、公式是否真算）由测试数据 +
+ * 人工前台确认——工具保证结构与设计器兼容性，不冒充运行时断言。
+ */
+import { runToolCall } from "./call.js";
+import { envelope, requestId, classifyResult, CLI_EXIT_CODES } from "./cli-contract.js";
+import { writeEnvelope } from "./cli-output.js";
+const WHEN_OPS = { "=": "EQ", "==": "EQ", "!=": "NEQ", ">": "GT", "<": "LT", ">=": "GTEQ", "<=": "LTEQ", "~=": "CT", "!~": "NCT" };
+/** 编译 --when/--then DSL 为设计器验证形状的规则图（导出供测试断言）。 */
+export function composeRuleWhenGraph(options) {
+    if (options.when.length === 0)
+        throw new Error("至少给一个 --when 条件；无条件更新整表是 bench23 病灶（空 mainConditions=无条件更新全部行）");
+    if (options.then.length === 0)
+        throw new Error("至少给一个 --then 动作");
+    const leaves = [];
+    for (const raw of options.when) {
+        // 最长操作符优先：>= <= ~= !~ == != > <
+        const match = /^([A-Za-z_][A-Za-z0-9_]*)(>=|<=|~=|!~|==|!=|=|>|<)([\s\S]+)$/.exec(raw.trim());
+        if (!match)
+            throw new Error(`--when "${raw}" 解析失败：形如 字段=值 / 字段!=值 / 字段>=数字 / 字段~=文本（包含）`);
+        const [, field, op, rawValue] = match;
+        if (rawValue.startsWith("="))
+            throw new Error(`--when "${raw}" 疑似操作符手误（值以 = 开头）：检查是否多打了等号`);
+        const opCode = WHEN_OPS[op];
+        if (!opCode)
+            throw new Error(`--when 操作符 "${op}" 不受支持`);
+        const value = /^-?\d+(\.\d+)?$/.test(rawValue.trim()) ? Number(rawValue.trim()) : rawValue.trim();
+        leaves.push({ targetSchemaDataItem: field, ruleConditionType: opCode, ruleValueType: "FIXED", value });
+    }
+    const actions = [];
+    for (const raw of options.then) {
+        const match = /^set:([A-Za-z_][A-Za-z0-9_]*)=([\s\S]*)$/.exec(raw.trim());
+        if (!match)
+            throw new Error(`--then "${raw}" 解析失败：v1 只支持 set:<字段>=<字面量>、set:<字段>={来源字段} 或 set:<字段>={公式}（如 set:total={amount}*0.9）`);
+        const [, field, rawValue] = match;
+        if (/^\{[A-Za-z_][A-Za-z0-9_.]*\}$/.test(rawValue.trim())) {
+            // 纯字段引用 → DYNAMIC
+            actions.push({ targetDataItem: field, ruleValueType: "DYNAMIC", value: "", ruleActionType: "EQUALS", currentDataItemValue: rawValue.trim().slice(1, -1) });
+        }
+        else if (rawValue.includes("{") && rawValue.includes("}")) {
+            // 含引用的表达式 → EXPRESSION（公式语言真机验证：IF/DATEDIF/INTDOWN 等）
+            actions.push({ targetDataItem: field, ruleValueType: "EXPRESSION", ruleActionType: "EQUALS", value: { formula: rawValue.trim() } });
+        }
+        else {
+            const value = /^-?\d+(\.\d+)?$/.test(rawValue.trim()) ? Number(rawValue.trim()) : rawValue.trim();
+            actions.push({ targetDataItem: field, ruleValueType: "FIXED", ruleActionType: "EQUALS", value });
+        }
+    }
+    return {
+        ruleCode: options.on === "create" ? "Create" : "Update",
+        nodeGraph: {
+            nodes: [
+                { nodeCode: "Start", nodeType: "START" },
+                { nodeCode: "UpdateData1", nodeType: "UPDATE", targetObjectCode: options.schema, inputParam: "_input",
+                    filterCondition: { mainConditions: [leaves], sheetConditions: [] },
+                    dataActions: actions },
+                { nodeCode: "End", nodeType: "END" },
+            ],
+            routes: [
+                { preNode: "Start", postNode: "UpdateData1", routeCondition: true, matchType: "ANY" },
+                { preNode: "UpdateData1", postNode: "End", routeCondition: true, matchType: "ANY" },
+            ],
+        },
+    };
+}
+export function composeRuleWhenArgs(options) {
+    const compiled = composeRuleWhenGraph(options);
+    return {
+        schemaCode: options.schema,
+        ruleCode: compiled.ruleCode,
+        name: options.name ?? `${options.schema} ${compiled.ruleCode} 条件动作`,
+        nodeGraph: compiled.nodeGraph,
+        ...(options.apply ? { publish: true } : {}),
+        ...(options.environment ? { environment: options.environment } : {}),
+        dryRun: !options.apply,
+    };
+}
+export async function cmdRuleWhen(args) {
+    const request = requestId();
+    const flag = (name) => {
+        const index = args.indexOf(name);
+        return index >= 0 ? args[index + 1] : undefined;
+    };
+    const multi = (name) => {
+        const values = [];
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] === name && args[i + 1] !== undefined)
+                values.push(args[i + 1]);
+        }
+        return values;
+    };
+    const schema = flag("--schema") ?? flag("--schema-code");
+    const on = (flag("--on") ?? "update").toLowerCase();
+    const when = multi("--when");
+    const then = multi("--then");
+    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 invalid = (message) => {
+        writeEnvelope(envelope("error", {}, request, { code: "invalid-input", message: `${message}\n${usage}`, retryable: false }));
+        return CLI_EXIT_CODES.invalidInput;
+    };
+    if (!schema)
+        return invalid("--schema 必填");
+    if (on !== "create" && on !== "update")
+        return invalid("--on 只支持 create|update");
+    let createArgs;
+    try {
+        createArgs = composeRuleWhenArgs({ schema, on: on, when, then, name, environment, apply });
+    }
+    catch (error) {
+        return invalid(error instanceof Error ? error.message : String(error));
+    }
+    const { result, exitCode } = await runToolCall("rule.save", { args: createArgs, requestId: request, environment });
+    const classified = classifyResult(result);
+    writeEnvelope(envelope(classified.status, result, request, classified.error));
+    if (apply && classified.status === "ok")
+        process.stderr.write("[omc] 前台生效验证清单（后端通过≠门户生效）：1) omc call rule.enable 启用；2) 造一条命中 --when 的测试数据提交；3) 门户打开该记录核对 --then 字段已变更；4) 再造一条不命中的数据确认不误改；5) 设计器打开本规则确认节点/条件显示正常。\n");
+    return exitCode;
+}
+//# sourceMappingURL=rule-when.js.map

package/dist/write.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { randomUUID } from "node:crypto";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 /** Parse a JSON string for the dry-lint; unparseable input returns undefined so the shape validators report it. */
 function parseJsonOrUndefined(text) {
     try {
@@ -151,7 +151,7 @@ async function governedWrite(ctx, tool, args, execute, dryRunPayload) {
                 rollbackable: rollbackBefore !== undefined && !rollbackCaptureError,
                 ...(rollbackCaptureError ? { note: `before-capture failed: ${rollbackCaptureError}` } : {}),
                 artifactFile: artifactRef.detailFile,
-                artifactId: artifactRef.detailFile.split("/").pop()?.replace(/\.json$/, "") ?? "",
+                artifactId: basename(artifactRef.detailFile).replace(/\.artifact$/, "") || basename(artifactRef.detailFile),
                 artifactSha: artifactRef.detailSha256,
             });
             rollbackRef = { seq: entry.seq, hint: `omc rollback plan ${entry.seq}（--env ${entry.environment}）` };
@@ -211,7 +211,10 @@ export function writeTool(tools, name, lane, scope, description, inputSchema, ex
             // would wave through the shapes it does not touch.
             const ruleCode = String(args.ruleCode ?? "");
             const prepared = prepareRuleGraph(ruleCode, (args.nodeGraph ?? {}), args.customTrigger, typeof args.schemaCode === "string" ? args.schemaCode : undefined);
-            const blockers = [...prepared.warnings, ...validateRuleNodeGraph(prepared.graph, ruleCode, typeof args.schemaCode === "string" ? args.schemaCode : undefined)];
+            const blockers = [...prepared.warnings, ...validateRuleNodeGraph(prepared.graph, ruleCode, typeof args.schemaCode === "string" ? args.schemaCode : undefined, { relaxEnums: true })];
+            // relaxEnums（中冶 2026-10-16）：本闸无 session 取不到存量图，枚举类（UI 独有
+            // 算子/取值）在预览与实调前闸一律降级 warning——权威判定在
+            // executeRuleSaveWrite 的回读差异放宽（carried 精确 diff，错拼仍被拦）。
             // Ticket 113: warning-severity findings ride the payload but never gate.
             if (blockers.some((blocker) => blocker.severity !== "warning"))
                 throw new ToolRefusalError({ status: "refused", blocker: "rule-graph-validation-failed", message: "nodeGraph 未过出门前校验（dry lint）；按 validation 逐项修正，校验器不猜不改", validation: blockers });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stalfh233/omc-cli",
-  "version": "0.4.49",
+  "version": "0.4.51",
   "description": "CloudPivot 8.6 configuration capability CLI — governed, fail-closed, coverage-manifest bounded.",
   "type": "module",
   "bin": {