@stalfh233/omc-cli 0.4.71 → 0.4.73

package/dist/artifacts.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
-import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, relative, resolve } from "node:path";
 export const CLI_DEFAULT_OUTPUT_BYTES = 64 * 1024;
 export const CLI_MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
@@ -13,8 +13,30 @@ function ensureRoot(root) {
     mkdirSync(resolved, { recursive: true, mode: 0o700 });
     return resolved;
 }
+const PRUNE_STAMP = ".prune-stamp";
+const PRUNE_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const PRUNE_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+/**
+ * Opportunistic hygiene: at most once per day, drop artifacts untouched for a
+ * week and enforce the size budget. Hooked into createArtifact so a long-running
+ * project never needs a manual sweep; the stamp keeps the scan off the hot path
+ * (one readdir per day, not per call).
+ */
+function maybeAutoPrune(resolvedRoot) {
+    const stampPath = join(resolvedRoot, PRUNE_STAMP);
+    try {
+        if (existsSync(stampPath) && Date.now() - statSync(stampPath).mtimeMs < PRUNE_INTERVAL_MS)
+            return;
+        pruneArtifacts(resolvedRoot, { olderThanMs: PRUNE_AGE_MS });
+        writeFileSync(stampPath, `${new Date().toISOString()}\n`, { mode: 0o600 });
+    }
+    catch {
+        // Hygiene is best-effort: never fail a write because cleanup did.
+    }
+}
 export function createArtifact(root, content) {
     const resolvedRoot = ensureRoot(root);
+    maybeAutoPrune(resolvedRoot);
     const artifactId = randomUUID();
     const path = artifactPath(resolvedRoot, artifactId);
     const bytes = typeof content === "string" ? Buffer.from(content, "utf8") : content;
@@ -116,4 +138,57 @@ export function assertSafeInputPath(root, candidate, label) {
     }
     return normalized;
 }
+export function pruneArtifacts(root, options = {}) {
+    const resolvedRoot = resolve(root);
+    if (!existsSync(resolvedRoot))
+        return { removed: 0, freedBytes: 0, kept: 0, keptBytes: 0 };
+    const now = options.now ?? Date.now();
+    const olderThanMs = options.olderThanMs;
+    const maxBytes = options.maxBytes ?? 256 * 1024 * 1024;
+    const entries = [];
+    let keptBytes = 0;
+    let removed = 0;
+    let freedBytes = 0;
+    const removePair = (path, size) => {
+        try {
+            rmSync(path, { force: true });
+            rmSync(`${path}.sha256`, { force: true });
+            removed += 1;
+            freedBytes += size;
+        }
+        catch { /* best effort */ }
+    };
+    for (const name of readdirSync(resolvedRoot)) {
+        if (!/^[a-f0-9-]{36}\.artifact$/u.test(name))
+            continue;
+        const path = join(resolvedRoot, name);
+        let stat;
+        try {
+            stat = lstatSync(path);
+        }
+        catch {
+            continue;
+        }
+        if (stat.isSymbolicLink() || !stat.isFile())
+            continue;
+        if (olderThanMs !== undefined && now - stat.mtimeMs > olderThanMs) {
+            removePair(path, stat.size);
+            continue;
+        }
+        entries.push({ path, size: stat.size, mtimeMs: stat.mtimeMs });
+        keptBytes += stat.size;
+    }
+    // Budget sweep: oldest first until the store fits.
+    if (keptBytes > maxBytes) {
+        entries.sort((left, right) => left.mtimeMs - right.mtimeMs);
+        for (const entry of entries) {
+            if (keptBytes <= maxBytes)
+                break;
+            removePair(entry.path, entry.size);
+            keptBytes -= entry.size;
+        }
+    }
+    const kept = entries.filter((entry) => existsSync(entry.path)).length;
+    return { removed, freedBytes, kept, keptBytes };
+}
 //# sourceMappingURL=artifacts.js.map

package/dist/bench/evals.js

@@ -76,6 +76,11 @@ const GOLDEN_CASES = [
         async run(harness) {
             await call(harness, "model.create", { name: "金轨迹回填源", code: "omc_mcp_gd2" });
             await call(harness, "model.create", { name: "金轨迹回填目标", code: "omc_mcp_gp" });
+            // The platform's rule self-check resolves UPDATE targets against the
+            // TARGET model's PUBLISHED fields; an unseeded target would 550018 here
+            // and never exercise the DYNAMIC wire this case exists to pin.
+            await call(harness, "field.create", { schemaCode: "omc_mcp_gp", code: "latestPeriod", name: "最近申报期", propertyType: "SHORT_TEXT" });
+            await call(harness, "field.publish", { schemaCode: "omc_mcp_gp" });
             harness.fake.seedDataRow("omc_mcp_gp", { latestPeriod: "" }, "omc_mcp_gp_row");
             await call(harness, "rule.save", {
                 schemaCode: "omc_mcp_gd2",
@@ -107,6 +112,9 @@ const GOLDEN_CASES = [
         async run(harness) {
             await call(harness, "model.create", { name: "金轨迹固定值源", code: "omc_mcp_gf2" });
             await call(harness, "model.create", { name: "金轨迹固定值目标", code: "omc_mcp_gf" });
+            await call(harness, "field.create", { schemaCode: "omc_mcp_gf", code: "state", name: "状态", propertyType: "SHORT_TEXT" });
+            await call(harness, "field.create", { schemaCode: "omc_mcp_gf", code: "count", name: "次数", propertyType: "NUMERICAL", options: { scale: 0 } });
+            await call(harness, "field.publish", { schemaCode: "omc_mcp_gf" });
             harness.fake.seedDataRow("omc_mcp_gf", { state: "old", count: 0 }, "omc_mcp_gf_row");
             await call(harness, "rule.save", {
                 schemaCode: "omc_mcp_gf2",

package/dist/cli.js

@@ -16,7 +16,7 @@ import { CLI_EXIT_CODES, classifyResult, envelope, errorEnvelope, requestId } fr
 import { configureOutput, humanSummary, stripOutputFlags, writeEnvelope } from "./cli-output.js";
 import { beginUsage, completeUsage, recordUsageOutput, usageReport } from "./usage-log.js";
 import { artifactFetchHint, artifactRoot, boundResult, emitInvalid, emitResult, emitTransportResult, outputBudget, readArtifact, withTransport, } from "./command-transport.js";
-import { CLI_DEFAULT_OUTPUT_BYTES, assertSafeOutputPath } from "./artifacts.js";
+import { CLI_DEFAULT_OUTPUT_BYTES, assertSafeOutputPath, pruneArtifacts } from "./artifacts.js";
 import { resolve } from "node:path";
 import { buildToolRegistry } from "./tools.js";
 import { acquireWriteLock } from "./write-lock.js";
@@ -437,6 +437,22 @@ function projectJsonPath(value, path) {
     }
     return { missed: false, value: current };
 }
+function parseDurationMs(text) {
+    const match = /^\s*(\d+)\s*(ms|s|m|h|d|w)?\s*$/u.exec(text);
+    if (!match)
+        return undefined;
+    const amount = Number(match[1]);
+    const unit = match[2] ?? "d";
+    const factor = unit === "ms" ? 1 : unit === "s" ? 1000 : unit === "m" ? 60_000 : unit === "h" ? 3_600_000 : unit === "d" ? 86_400_000 : 604_800_000;
+    return amount * factor;
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+}
 async function cmdArtifactGet(id, transport, options = {}) {
     try {
         const artifact = readArtifact(artifactRoot(), id);
@@ -1071,7 +1087,34 @@ async function main() {
     rollbackCommand.command("apply <ref>").option("--env <environment>").option("--environment <environment>").option("--confirm-production").action(async (ref, options) => {
         commandExitCode = await withTransport(options, "rollback apply", (transport) => cmdRollbackApply(ref, { environment: options.env ?? options.environment, confirmProduction: options.confirmProduction === true }, transport));
     });
-    command.command("artifact").command("get <id>").option("--jq <path>").option("--path-only").option("--summary").option("--keys [a,b]").option("--max-output-bytes <bytes>").action(async (id, options) => {
+    const artifactCommand = command.command("artifact");
+    artifactCommand.command("prune").option("--older-than <duration>", "删除超过该时长的读回产物（如 7d/12h/30m）").option("--max-bytes <bytes>", "产物目录预算；超出时按最旧优先删除").option("--json").action((options) => {
+        // Machine-global store: oversized readbacks pile up (504 files / 3.4 MB
+        // after one sandbox round). Pruning is deterministic and safe to run at
+        // any time — it only removes this store's own artifact files.
+        const olderThanMs = options.olderThan === undefined ? undefined : parseDurationMs(options.olderThan);
+        if (options.olderThan !== undefined && olderThanMs === undefined) {
+            console.error("用法：omc artifact prune [--older-than 7d] [--max-bytes 268435456] [--json]");
+            commandExitCode = CLI_EXIT_CODES.invalidInput;
+            return;
+        }
+        const maxBytes = options.maxBytes === undefined ? undefined : Number(options.maxBytes);
+        if (options.maxBytes !== undefined && (!Number.isFinite(maxBytes) || Number(maxBytes) < 0)) {
+            console.error("--max-bytes 必须是非负整数");
+            commandExitCode = CLI_EXIT_CODES.invalidInput;
+            return;
+        }
+        const result = pruneArtifacts(artifactRoot(), {
+            ...(olderThanMs !== undefined ? { olderThanMs } : {}),
+            ...(maxBytes !== undefined ? { maxBytes } : {}),
+        });
+        if (options.json)
+            process.stdout.write(JSON.stringify({ ok: true, ...result }, null, 2) + "\n");
+        else
+            console.error(`已清理 ${result.removed} 个读回产物，释放 ${formatBytes(result.freedBytes)}；保留 ${result.kept} 个（${formatBytes(result.keptBytes)}）`);
+        commandExitCode = CLI_EXIT_CODES.ok;
+    });
+    artifactCommand.command("get <id>").option("--jq <path>").option("--path-only").option("--summary").option("--keys [a,b]").option("--max-output-bytes <bytes>").action(async (id, options) => {
         commandExitCode = await withTransport(options, request, (transport) => cmdArtifactGet(id, transport, { ...(options.jq ? { jq: options.jq } : {}), pathOnly: options.pathOnly === true, summary: options.summary === true || options.keys === true, ...(typeof options.keys === "string" ? { keys: options.keys } : {}) }));
     });
     command.command("bench").option("--live-sample").option("--env <environment>").action(async (options) => { commandExitCode = await cmdBench([...(options.liveSample ? ["--live-sample"] : []), ...(options.env ? ["--env", options.env] : [])]); });

package/dist/field-families.js

@@ -672,6 +672,59 @@ function refuseFieldOptions(reason, message) {
     };
     throw new ToolRefusalError({ status: "refused", blocker: "capability-out-of-coverage", citation });
 }
+/**
+ * Aggregation query conditions are deserialized by Jackson into Java enums that
+ * are FIXED-ORDINAL (`BizPropertyType`, `OperatorType`): both must be written as
+ * their INTEGER code. A name (“NUMERICAL”/“GTEQ”) makes bizproperty/publish
+ * answer 50000 with `InvalidFormatException: Cannot deserialize value of type
+ * int from String` (live 2026-10-22, 1.1.25 scratch model). The portal UI writes
+ * ints, so accept the readable names and normalize them to the wire code —
+ * exactly the kind of adapter this lane already performs for `name_i18n`.
+ */
+const AGGREGATION_OPERATOR_CODES = Object.freeze({
+    EQ: 1, NEQ: 2, GT: 3, IT: 4, GTEQ: 5, ITEQ: 6,
+    CONTAINS: 7, NOT_CONTAINS: 8, IS_NULL: 9, IS_NOT_NULL: 10,
+    OF: 11, NOT_OF: 12, HAVE: 13, NOT_HAVE: 14,
+    IN: 15, NOT_IN: 16, BETWEEN: 17, NOT_BETWEEN: 18,
+    CONTAINS_ALL: 19, NOT_CONTAINS_ALL: 20, CONTAINS_ANY: 21,
+    NOT_CONTAINS_ANY: 22, EQ_ANY: 23, NOT_EQ_ANY: 24,
+});
+function normalizeAggregationFormula(agg) {
+    const groups = agg.queryConditions;
+    if (groups === undefined)
+        return agg;
+    if (!Array.isArray(groups) || groups.some((group) => !Array.isArray(group)))
+        refuseFieldOptions("AGGREGATION aggregation.queryConditions is not an array of arrays", "rejected: aggregation.queryConditions 形状必须是 [[{propertyCode,propertyType(int),operatorType(int),propertyValue,valueType}],…]（条件组）");
+    const normalized = groups.map((group) => group.map((leaf) => {
+        if (!leaf || typeof leaf !== "object" || Array.isArray(leaf))
+            refuseFieldOptions("AGGREGATION queryConditions leaf is not an object", "rejected: aggregation.queryConditions 每个条件必须是对​象");
+        const record = { ...leaf };
+        for (const key of ["propertyType", "currentPropertyType"]) {
+            const value = record[key];
+            if (value === undefined || value === null)
+                continue;
+            const code = typeof value === "number" ? value : FIELD_PROPERTY_TYPES[String(value).toUpperCase()];
+            if (typeof code !== "number" || !Number.isInteger(code))
+                refuseFieldOptions(`AGGREGATION queryConditions.${key} ${JSON.stringify(value)} is not a numeric BizPropertyType code`, `rejected: 聚合条件的 ${key} 必须是**整数**属性类型编码（Jackson 按 int 反序列化，传 "NUMERICAL" 会让 publish 50000）；可用名字：${Object.keys(FIELD_PROPERTY_TYPES).join("、")}`);
+            record[key] = code;
+        }
+        const operator = record.operatorType;
+        if (operator !== undefined && operator !== null) {
+            const code = typeof operator === "number" ? operator : AGGREGATION_OPERATOR_CODES[String(operator).toUpperCase()];
+            if (typeof code !== "number" || !Number.isInteger(code) || code < 1 || code > 24)
+                refuseFieldOptions(`AGGREGATION queryConditions.operatorType ${JSON.stringify(operator)} is not an OperatorType code`, `rejected: 聚合条件的 operatorType 必须是整数 1–24（或名字：${Object.keys(AGGREGATION_OPERATOR_CODES).join("、")}）；传 "GTEQ" 会让 publish 50000`);
+            record.operatorType = code;
+        }
+        if (record.valueType === undefined)
+            record.valueType = "FIXED";
+        if (!["FIXED", "DYNAMIC"].includes(String(record.valueType)))
+            refuseFieldOptions(`AGGREGATION queryConditions.valueType ${JSON.stringify(record.valueType)} is not FIXED/DYNAMIC`, 'rejected: 聚合条件的 valueType 只能是 "FIXED" 或 "DYNAMIC"');
+        if (record.propertyValue !== undefined && typeof record.propertyValue !== "string")
+            record.propertyValue = String(record.propertyValue);
+        return record;
+    }));
+    return { ...agg, queryConditions: normalized };
+}
 /** FORMULA formulaConfig decode; policy: string-only face, must parse to a non-array object. */
 function parseOptionsObject(value) {
     return decodeJsonObjectColumn(value, { invalid: "undefined", array: "reject", object: "reject" });
@@ -843,7 +896,12 @@ export function assertFieldOptionsAllowed(type, options, schemaCode) {
             else {
                 const agg = parseOptionsObject(config.aggregation);
                 if (!agg || !isNonEmptyString(agg.schemaCode) || !isNonEmptyString(agg.dataItemCode) || !isNonEmptyString(agg.formula))
-                    refuseFieldOptions("AGGREGATION aggregation is missing schemaCode/dataItemCode/formula", 'rejected: aggregation 形状 {schemaCode:"<子表schemaCode>", dataItemCode:"<子表字段code>", formula:"SUM({<子表schemaCode>.<子表字段code>})", calculateType?:.., queryConditions?:[]}（FormulaProcessor.executeMainAggregation + AggregationFormula）');
+                    refuseFieldOptions("AGGREGATION aggregation is missing schemaCode/dataItemCode/formula", 'rejected: aggregation 形状 {schemaCode:"<目标模型schemaCode>", dataItemCode:"<目标字段code>", formula:"SUM({<目标模型>.<字段>})", calculateType:"SUM", queryConditions:[[…]]}（FormulaProcessor.executeMainAggregation + AggregationFormula）');
+                const normalizedAgg = normalizeAggregationFormula(agg);
+                if (normalizedAgg !== agg) {
+                    config.aggregation = JSON.stringify(normalizedAgg);
+                    options.formulaConfig = JSON.stringify(config);
+                }
             }
         }
         else if (!isNonEmptyString(config.expression)) {

package/dist/lanes/rule-graph.js

@@ -615,6 +615,55 @@ export function graphGeometryNeedsLayout(nodesInput, routesInput) {
     const boxes = nodes.map(boxOf);
     return boxes.some((a, ai) => boxes.some((b, bi) => bi > ai && a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height));
 }
+/**
+ * System persistence nodes belong to the TOOL, never to the caller.
+ *
+ * `SYSTEM_CREATE/SYSTEM_UPDATE/SYSTEM_DELETE` are the platform's trigger-row
+ * persistence nodes: the correct one is a function of the rule code
+ * (Create→SYSTEM_CREATE, …) and its position is a function of the action nodes.
+ * A caller who hand-writes one can only get it wrong:
+ *
+ *  - wrong type inside a preset rule → data.submit 50000 (live 2026-09-25);
+ *  - any type inside a CUSTOM rule bound to a workflow event → the end/cancel
+ *    agenda has no serializable current object and every run throws
+ *    `Object <id> is not serialized` (live 2026-10-22, r8: 33 occurrences,
+ *    nothing written, every step still reported DELIVERED);
+ *  - right type but wrong seat → the merged result is persisted before the
+ *    action writes it (ASSIGN/BIZ_ACTION must precede the system node).
+ *
+ * So strip whatever the caller supplied and let `injectDefaultSystemNode` place
+ * the one platform default (preset rules only). Routes through the stripped
+ * node are bridged pre→post so the chain stays connected.
+ */
+export function stripCallerSystemNodes(nodesInput, routesInput) {
+    const nodes = asRecordArray(parseMaybeJson(nodesInput));
+    const routes = asRecordArray(parseMaybeJson(routesInput));
+    const systemTypes = new Set(["SYSTEM_CREATE", "SYSTEM_UPDATE", "SYSTEM_DELETE"]);
+    const stripped = nodes
+        .filter((node) => systemTypes.has(String(node.nodeType ?? "")))
+        .map((node) => String(node.nodeCode ?? ""));
+    if (stripped.length === 0)
+        return { nodes, routes, stripped };
+    let nextRoutes = routes;
+    for (const code of stripped) {
+        const incoming = nextRoutes.filter((route) => String(route.postNode ?? "") === code).map((route) => String(route.preNode ?? ""));
+        const outgoing = nextRoutes.filter((route) => String(route.preNode ?? "") === code).map((route) => String(route.postNode ?? ""));
+        nextRoutes = nextRoutes.filter((route) => String(route.preNode ?? "") !== code && String(route.postNode ?? "") !== code);
+        for (const pre of incoming)
+            for (const post of outgoing)
+                nextRoutes.push({ preNode: pre, postNode: post });
+    }
+    // Collapse duplicate edges produced by bridging (same endpoints + condition).
+    const seen = new Set();
+    nextRoutes = nextRoutes.filter((route) => {
+        const key = `${String(route.preNode ?? "")}->${String(route.postNode ?? "")}#${JSON.stringify(route.routeCondition ?? null)}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    return { nodes: nodes.filter((node) => !systemTypes.has(String(node.nodeType ?? ""))), routes: nextRoutes, stripped };
+}
 /**
  * The single rule-graph normalization used by BOTH the write preflight and the
  * executor, so preview and execute validate the SAME prepared graph (CFG-02
@@ -632,10 +681,20 @@ export function graphGeometryNeedsLayout(nodesInput, routesInput) {
  * in `warnings` (never gating) so the caller can replace it with a domain name.
  */
 export function prepareRuleGraph(ruleCode, graph, customTrigger, schemaCode) {
-    const injected = injectDefaultSystemNode(ruleCode, graph.nodes ?? graph.node, graph.routes ?? graph.route);
+    const warnings = [];
+    // The caller never owns a persistence node (see stripCallerSystemNodes).
+    const stripped = stripCallerSystemNodes(graph.nodes ?? graph.node, graph.routes ?? graph.route);
+    for (const nodeCode of stripped.stripped)
+        warnings.push({
+            code: "rule-graph-system-node-tool-owned",
+            nodeCode,
+            key: "nodes",
+            severity: "warning",
+            message: `已忽略调用方传入的系统持久化节点 ${nodeCode}：SYSTEM_CREATE/SYSTEM_UPDATE/SYSTEM_DELETE 由工具按规则类型注入，手写只会错配类型或位置（预置规则错配 → submit 50000；自定义规则/流程事件 → Object is not serialized 且静默不生效）`,
+        });
+    const injected = injectDefaultSystemNode(ruleCode, stripped.nodes, stripped.routes);
     let finalNodes = injected.nodes;
     let finalRoutes = injected.routes;
-    const warnings = [];
     // SCHEDULER ⇒ TIMING_TASK: the platform dispatches a schedule ONLY when the
     // RULE ROW's bizRuleType = 2 (BizRuleScheduling.java:202-205; see
     // lanes/businessrule-contract.ts:42). A caller who authors a SCHEDULER node but
@@ -733,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 ?? "");
@@ -864,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,
@@ -1115,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 ?? "");
@@ -1451,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 未提交的行不会被回写。`,

package/dist/lanes/workflow.js

@@ -913,7 +913,15 @@ function activityCodeOf(record) {
   * change still mints a collision-free fresh code. Returns the rewritten
   * activities plus the original→final code map for route remapping.
   */
-function reconcileCallerActivityCodes(callerActivities, draftActivities) {
+function reconcileCallerActivityCodes(callerActivities, draftActivities, options = {}) {
+    // 8.6 pins activityType on an existing code (live 2026-09-23), so a retype
+    // there needs a fresh code. AI-Platform 1.1.x does NOT pin it: a raw
+    // workflow/update that keeps the code and changes activityType returns
+    // errcode 0 and the draft reads back with the new type (live 2026-10-21,
+    // 1.1.25, END→PARTICIPANT in place). Minting `_2` there is OMC's own
+    // invention and churns every downstream reference (routes, buttons, logs),
+    // so only the pinned family mints.
+    const mintOnTypeChange = options.mintOnTypeChange !== false;
     const draftByCode = new Map(draftActivities.map((activity) => [String(activity.activityCode ?? ""), activity]));
     const used = new Set(draftActivities.map((activity) => String(activity.activityCode ?? "")));
     const codeMap = new Map();
@@ -941,7 +949,7 @@ function reconcileCallerActivityCodes(callerActivities, draftActivities) {
             // the designer's own rename posts exactly that and activityName stays
             // the first-created value). Only a TYPE change still needs a fresh code
             // (activityType is pinned for existing codes).
-            if (typeChanged) {
+            if (typeChanged && mintOnTypeChange) {
                 let suffix = 2;
                 while (used.has(`${original}_${suffix}`))
                     suffix += 1;
@@ -1229,7 +1237,7 @@ async function refuseRequiredOnChildTableFields(session, schemaCode, template, t
  * same edge). This is the "read back, then send the delta" path — without it a
  * subset silently REPLACED the whole activity list and dropped nodes.
  */
-function mergeCallerDelta(template, draft) {
+function mergeCallerDelta(template, draft, options = {}) {
     const { routes: routesRaw, activities: _raw, edges: edgesRaw, ...rest } = template;
     const routes = routesRaw ?? edgesRaw;
     const draftActivities = Array.isArray(draft.activities) ? draft.activities : [];
@@ -1258,7 +1266,7 @@ function mergeCallerDelta(template, draft) {
     // that under the same code). reconcileCallerActivityCodes keeps the code for
     // a name change and stamps name_i18n; only a type change still mints a fresh
     // code and DROPS the old node (a retype, not a rename).
-    const { activities: reconciledCaller, codeMap } = reconcileCallerActivityCodes(caller, draftActivities);
+    const { activities: reconciledCaller, codeMap } = reconcileCallerActivityCodes(caller, draftActivities, options);
     const draftByCode = new Map(draftActivities.map((activity) => [String(activity.activityCode ?? ""), activity]));
     const originalOf = new Map();
     for (const [original, final] of codeMap)
@@ -1342,7 +1350,7 @@ function mergeCallerDelta(template, draft) {
     });
     return { ...rest, activities: laidOut.activities, rules };
 }
-function normalizeWorkflowTemplate(template, draft) {
+function normalizeWorkflowTemplate(template, draft, options = {}) {
     if (template === undefined || template === null)
         return {};
     const { routes: routesRaw, activities: rawActivities, edges: edgesRaw, ...rest } = template;
@@ -1356,7 +1364,7 @@ function normalizeWorkflowTemplate(template, draft) {
     // The platform cannot rename an existing activityCode (see the reconcile
     // comment); give every changed/new node a fresh code, and remap caller routes
     // so they follow.
-    const reconciled = rawCaller ? reconcileCallerActivityCodes(rawCaller, draftActivities) : undefined;
+    const reconciled = rawCaller ? reconcileCallerActivityCodes(rawCaller, draftActivities, options) : undefined;
     const activities = reconciled?.activities;
     const codeMap = reconciled?.codeMap ?? new Map();
     const remapCode = (value) => codeMap.get(String(value ?? "")) ?? value;
@@ -1477,7 +1485,13 @@ async function mergedTemplateBody(session, schemaCode, code, template, merge = f
             workflowCode: code,
             message: `流程 ${code} 不存在（get_draft 401001 缺席）——先 workflow.create 再 update/publish`,
         });
-    const normalized = merge ? mergeCallerDelta(template, draft) : normalizeWorkflowTemplate(template, draft);
+    // Type changes are only pinned on the 8.x family (see reconcileCallerActivityCodes).
+    // Unknown versions keep the conservative 8.x behaviour (mint) — writes fail
+    // closed elsewhere, and a spurious `_2` is recoverable while a silent
+    // in-place retype on a pinned platform is not.
+    const version = session.detectedVersion();
+    const mintOnTypeChange = !(version !== undefined && version.startsWith("1."));
+    const normalized = merge ? mergeCallerDelta(template, draft, { mintOnTypeChange }) : normalizeWorkflowTemplate(template, draft, { mintOnTypeChange });
     // S29 contract: a PARTICIPANT activity requires sheetCode = the schema's
     // sheet, else validate/publish answers 401026 WORKFLOW_ACTIVITY_NO_SHEET. The
     // platform's own draft sets each participant's sheetCode to the model code;

package/dist/rule-support.js

@@ -4,9 +4,10 @@ import { ENDPOINTS } from "./endpoints.js";
 import { ToolRefusalError } from "./tool-types.js";
 import { decodeJsonColumn, JSON_COLUMN_NULL_COALESCE } from "./json-column.js";
 import { RULE_BIZ_RULE_TYPE_DESCRIPTION, RULE_CREATE_BODY, RULE_ROUTES_DESCRIPTION, ruleNodeGraphDescription, schedulerSettingDescription, } from "./lanes/businessrule-contract.js";
-import { validateRuleNodeGraph, prepareRuleGraph, PLATFORM_TRIGGER_RULE_CODES } from "./lanes/rule-graph.js";
+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).
@@ -624,10 +753,36 @@ export async function executeRuleSaveWrite(session, args) {
         : typeof schedulerInput === "string"
             ? schedulerInput
             : JSON.stringify(schedulerInput);
-    const nodeJson = typeof nodes === "string" ? nodes : JSON.stringify(nodes);
-    const routeJson = typeof routes === "string" ? routes : JSON.stringify(routes);
     const list = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
     const existing = wireRows(list.data).find((row) => row.code === args.ruleCode);
+    // Persistence nodes belong to the PLATFORM, not to us and not to the caller.
+    // The preset row already carries its own (Start → Create(SYSTEM_CREATE) →
+    // End). Copy that node verbatim instead of fabricating our own: nodeCode,
+    // nodeName, isSystemNode and geometry then always match what the designer
+    // itself writes. Only its SEAT (relative to the caller's action nodes) is
+    // ours, and the fingerprint of a hand-made replica drifting from the
+    // platform's is exactly what breaks publish later.
+    const systemSpec = DEFAULT_SYSTEM_NODE_BY_RULE_CODE[args.ruleCode];
+    if (existing?.id && systemSpec) {
+        try {
+            const baselineRow = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id: String(existing.id) } })).data;
+            const baselineNodes = parseJsonColumn(baselineRow?.node);
+            const platformNode = Array.isArray(baselineNodes)
+                ? baselineNodes.find((node) => String(node.nodeType ?? "") === systemSpec.nodeType)
+                : undefined;
+            if (platformNode) {
+                const index = nodes.findIndex((node) => String(node.nodeType ?? "") === systemSpec.nodeType);
+                if (index >= 0)
+                    nodes[index] = { ...platformNode, isSystemNode: true };
+            }
+        }
+        catch {
+            // Best-effort: the documented default keeps the chain valid if the
+            // baseline cannot be read (the save itself will report the real error).
+        }
+    }
+    const nodeJson = typeof nodes === "string" ? nodes : JSON.stringify(nodes);
+    const routeJson = typeof routes === "string" ? routes : JSON.stringify(routes);
     const schedulerField = schedulerSetting === undefined ? {} : { schedulerSetting };
     // Preset trigger rules (Create/Update/Delete/Load/GetList/Available/Cancel
     // and 流程 code) are platform-managed: their `name` is a platform default
@@ -694,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,
@@ -710,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stalfh233/omc-cli",
-  "version": "0.4.71",
+  "version": "0.4.73",
   "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.71",
+    "@stalfh233/omc-fake-platform": "0.4.73",
     "commander": "14.0.3",
-    "omc-core": "0.4.71",
+    "omc-core": "0.4.73",
     "proper-lockfile": "4.1.2",
     "write-file-atomic": "6.0.0",
     "zod": "^3.23.8",

package/skills/omc-business-configuration.md

@@ -151,7 +151,15 @@ 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 规则或流程事件规则。
+- **系统持久化节点是平台自带的，不要手写**：预置 `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…）。
 - **取 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`，别整包内联进推理。
 - **流程第一个节点必须是 `{Originator}` 填写节点**：平台 `WorkflowTemplateValidateUtility.validateStartActivity` 对「START 后直接接审批」报 401035「发起节点的参与者只能是{Originator}」，publish 回 errcode 0 但一个 ValidateMessage[] 就把模板挡在门外、不落库（真机 2026-10-21）。OMC 0.4.65 起在 `workflow.update`/`publish` 出门前拒绝（`workflow-first-activity-not-originator`）。
 - **跨模型回写的目标行必须已提交（COMPLETED）**：DRAFT 行不参与目标查询，运行 0 行命中且日志只有「查找范围不存在数据」。单跳关联字段可直接作 DYNAMIC 来源（引擎取关联对象 id）；点号路径按子表解析，`关联字段.id` / 两跳路径都不支持。
@@ -209,7 +217,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`。