@stalfh233/omc-cli 0.6.25 → 0.6.26

package/dist/capability-overview.js

@@ -349,6 +349,7 @@ const CAPABILITY_TOPICS = Object.freeze({
     "rule-lifecycle": ["app-scope", "omc-business-configuration", "omc-refusals"],
     workflow: ["omc-business-configuration", "omc-refusals"],
     onlinejs: ["omc-business-configuration", "omc-write-hazards"],
+    programming: ["omc-backend-online-coding", "omc-business-configuration", "omc-write-hazards"],
     bizservice: ["omc-business-configuration", "omc-write-hazards"],
     report: ["omc-business-configuration", "omc-write-hazards"],
     data: ["omc-business-configuration", "omc-refusals"],

package/dist/cli.js

@@ -2418,6 +2418,7 @@ async function main() {
         .option("--code <schemaCode>")
         .option("--fields <json>", "JSON 数组，每条是一个 field.create 参数（choices/字典 options 原样透传）")
         .option("--fields-json <json>")
+        .option("--fields-file <path>", "从配置根内文件读字段 JSON 数组；与 --fields 互斥")
         .option("--env <environment>")
         .option("--environment <environment>")
         .option("--no-form", "跳过表单重建")
@@ -2436,6 +2437,7 @@ async function main() {
             ...(options.code ? ["--code", options.code] : []),
             ...(options.fields !== undefined ? ["--fields", options.fields] : []),
             ...(options.fieldsJson !== undefined ? ["--fields-json", options.fieldsJson] : []),
+            ...(options.fieldsFile !== undefined ? ["--fields-file", options.fieldsFile] : []),
             ...(options.env ? ["--env", options.env] : []),
             ...(options.environment ? ["--environment", options.environment] : []),
             ...(options.form === false ? ["--no-form"] : []),

package/dist/field-add.js

@@ -17,6 +17,9 @@ import { argvValue } from "./args.js";
 import { runToolCall } from "./call.js";
 import { CLI_EXIT_CODES, classifyResult, envelope, refusalText, requestId } from "./cli-contract.js";
 import { writeEnvelope } from "./cli-output.js";
+import { assertSafeInputPath } from "./artifacts.js";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
 /**
  * 字典简写展开（r30/r36 实证：字典字段要先 names 查 id、records 取记录、
  * 再拼 optionsSet.dictionary 三段 4–5 调；`dictCode` 把它折进 field-add 一步）：
@@ -108,7 +111,9 @@ export async function cmdFieldAdd(args, contextForTest) {
     const request = requestId();
     const flag = (name) => argvValue(args, name);
     const schemaCode = flag("--schema") ?? flag("--schema-code") ?? flag("--code");
-    const fieldsJson = flag("--fields") ?? flag("--fields-json");
+    const fieldsFile = flag("--fields-file");
+    const fieldsFlag = flag("--fields");
+    const fieldsJson = fieldsFlag === "-" ? readFileSync(0, "utf8") : fieldsFlag ?? flag("--fields-json");
     const environment = flag("--env") ?? flag("--environment");
     const apply = args.includes("--apply");
     const publishForm = !args.includes("--no-form");
@@ -117,7 +122,7 @@ export async function cmdFieldAdd(args, contextForTest) {
     const conditionsJson = flag("--conditions") ?? flag("--conditions-json");
     const demoRowsJson = flag("--demo-rows") ?? flag("--demo-rows-json");
     const usage = [
-        "用法：omc field-add --schema <模型code> --fields '<JSON 数组>' [--apply]",
+        "用法：omc field-add --schema <模型code> --fields '<JSON 数组>' [--fields-file <路径>|--fields -] [--apply]",
         "  --fields 每项是一个 field.create 的参数：{\"code\",\"name\",\"propertyType\",...}（choices/字典 options 原样透传）；",
         "  字典简写：{\"dictCode\":\"<字典code>\"} 代替手拼 options.optionsSet（内部解析字典 id+启用记录，recipe 同形状）。",
         "  默认 dry-run；--apply 依次执行 建字段 → 发布字段 → 重建表单 → 列表追加列。",
@@ -125,6 +130,7 @@ export async function cmdFieldAdd(args, contextForTest) {
         "  --no-form 跳过表单重建；--no-list 跳过列表加列（默认两者都做）。",
         "  --conditions '<JSON 数组>' 列表固定过滤条件（listview.configure 契约；**整体替换**既有固定条件——要保留旧的须一并带上；不传则不动）；需 --list（默认开）。",
         "  --demo-rows '<JSON 数组>' 演示数据行（每项一份 formData，逐行 data.submit）；非幂等——重复执行会重复插行。",
+        "  --fields-file 从配置根内文件读 JSON 数组；--fields - 从 stdin 读 JSON 数组。",
     ].join("\n");
     const invalid = (message) => {
         writeEnvelope(envelope("error", {}, request, { code: "invalid-input", message: `${message}\n${usage}`, retryable: false }));
@@ -132,11 +138,23 @@ export async function cmdFieldAdd(args, contextForTest) {
     };
     if (!schemaCode)
         return invalid("--schema 必填（存量模型 code）");
-    if (fieldsJson === undefined)
-        return invalid("--fields 必填（JSON 数组）");
+    if (fieldsFile !== undefined && (fieldsFlag !== undefined || flag("--fields-json") !== undefined))
+        return invalid("--fields-file 不能与 --fields/--fields-json 同时使用");
+    let inputJson = fieldsJson;
+    if (fieldsFile !== undefined) {
+        try {
+            const root = resolve(process.env.OMC_CONFIG_HOME ?? process.cwd());
+            inputJson = readFileSync(assertSafeInputPath(root, fieldsFile, "--fields-file"), "utf8");
+        }
+        catch (error) {
+            return invalid(`--fields-file 读取失败：${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (inputJson === undefined)
+        return invalid("--fields 必填（JSON 数组；或使用 --fields-file/--fields -）");
     let fields;
     try {
-        const parsed = JSON.parse(fieldsJson);
+        const parsed = JSON.parse(inputJson);
         if (!Array.isArray(parsed) || parsed.length === 0)
             throw new Error("--fields 必须是非空 JSON 数组");
         fields = parsed;

package/dist/field-families.js

@@ -938,14 +938,14 @@ export function assertSelectionChoicesAllowed(args) {
 }
 function refuseFieldOptions(reason, message) {
     const citation = {
-        code: "capability-out-of-coverage",
+        code: "field-options-shape",
         lane: "field-families",
         capability: "field family full chain",
         status: "blocked",
         reason,
         message,
     };
-    throw new ToolRefusalError({ status: "refused", blocker: "capability-out-of-coverage", citation });
+    throw new ToolRefusalError({ status: "refused", blocker: "field-options-shape", citation });
 }
 /**
  * Aggregation query conditions are deserialized by Jackson into Java enums that

package/dist/formula-lint.js

@@ -30,6 +30,9 @@ export const FORMULA_FUNCTION_ALIASES = Object.freeze({
     STRCAT: "STRING",
     JOIN: "STRING",
 });
+export const FORMULA_LINT_CODES = new Set([
+    "formula-function-unknown", "formula-function-alias", "formula-text-plus-concat",
+]);
 const TEXT_PLUS_CONCAT = /(\{[^{}]+\}|[A-Za-z_][A-Za-z0-9_]*\s*\([^()]*\))\s*\+\s*["']|["']\s*\+\s*(\{[^{}]+\}|[A-Za-z_][A-Za-z0-9_]*\s*\()/;
 /**
  * Lint one formula string. `where` names the carrier in the caller's own terms

package/dist/lanes/businessrule-contract.js

@@ -75,6 +75,7 @@ const RULE_SAVE_DESCRIPTION = describeTool("保存业务规则（upsert）：`ru
     "**EXPRESSION 值形状**：`ruleValueType:EXPRESSION` 时 `value` 必须是 {\"formula\":\"{字段A}+{字段B}\"}（大括号裸 code）；门户设计器的 [code] 方括号式在这里不认。",
     "**幻影 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）。",
+    "**跨模型 UPDATE 三段语义（1.1.25 反编译定案）**：`inputParam`=输入源（触发行或 QUERY 上游输出，`currentSchemaDataItem` 属此侧）→ `filterCondition` 按 `targetSchemaCode` 查目标行 → `dataActions` 把输入源值写入目标行。QUERY 目标行不自动成为输入源；child fan-out 保持 fail-closed（用显式中间字段/映射/二开）。",
 ]);
 export const BUSINESSRULE_LANE_CONTRACT = Object.freeze({
     lane: LANES.businessrule,

package/dist/lanes/businessrule.js

@@ -479,6 +479,7 @@ export function registerBusinessRuleLane(tools) {
             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"),
+            allowAdvisory: z.boolean().optional().describe("调查逃生口；默认 false"),
             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 退回"),
         },
         execute: async (session, args) => executeRuleSaveWrite(session, args),

package/dist/lanes/datarule.js

@@ -481,6 +481,11 @@ export function dataRuleFormulaWarnings(dataRuleType, options) {
         return [];
     return lintFormulaText(formula, "options.shortTextStitch.formula");
 }
+function assertDataRuleFormulaLint(dataRuleType, options, allowAdvisory) {
+    const findings = dataRuleFormulaWarnings(dataRuleType, options);
+    if (findings.length > 0 && allowAdvisory !== true)
+        throw new ToolRefusalError({ status: "refused", blocker: "formula-lint-failed", validation: findings, nextCommand: "修正公式函数/字符串拼接；调查用途显式传 allowAdvisory:true", message: "公式写前校验拒绝：未知函数、平台别名或字符串 + 拼接。文本合并请使用 STRING()。" });
+}
 /** Extract the expression of a type-2 CALCULATE rule (mirrors calcExpressionShapeError's carrier choice). */
 function type2FormulaText(options) {
     const raw = typeof options.shortTextStitch === "string" ? options.shortTextStitch : typeof options.value === "string" ? options.value : undefined;
@@ -872,9 +877,11 @@ export function registerDataRuleLane(tools) {
             childRule: z.boolean().optional().describe("true=子表列规则，propertyCode 为子表列 code；主表字段忽略"),
             name: z.string().optional(),
             sortKey: z.number().int().optional(),
+            allowAdvisory: z.boolean().optional().describe("调查逃生口；默认 false"),
         },
         execute: async (session, args) => {
             assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
+            assertDataRuleFormulaLint(args.dataRuleType, args.options, args.allowAdvisory);
             assertDataRuleCheckType(args.dataRuleType, args.checkType);
             assertDataRuleTarget(args);
             const codes = dataRuleTargetCodes(args);
@@ -957,6 +964,7 @@ export function registerDataRuleLane(tools) {
             propertyCodes: propertyCodesArg,
             dataRuleType: dataRuleTypeArg,
             options: dataRuleOptionsArg,
+            allowAdvisory: z.boolean().optional().describe("调查逃生口；默认 false"),
             checkType: checkTypeArg,
             childRule: z.boolean().optional().describe("true=子表列规则，propertyCode 为子表列 code；主表字段忽略"),
             name: z.string().optional(),
@@ -964,6 +972,7 @@ export function registerDataRuleLane(tools) {
         },
         execute: async (session, args) => {
             assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
+            assertDataRuleFormulaLint(args.dataRuleType, args.options, args.allowAdvisory);
             assertDataRuleCheckType(args.dataRuleType, args.checkType);
             const id = await locateDataRuleId(session, args, "update POST");
             const before = await listDataRules(session, args.schemaCode);

package/dist/lanes/field.js

@@ -41,6 +41,61 @@ export async function modelSchemaCodes(session) {
         .map((row) => String(row.schemaCode ?? row.bizSchemaCode ?? row.code ?? ""))
         .filter((code) => code.length > 0);
 }
+function relationTypeOf(row) {
+    const value = Number(row.type ?? row.propertyType);
+    return Number.isInteger(value) ? value : undefined;
+}
+/** Semantic relation gate: the designer only offers published business fields. */
+async function assertRelationOptionsFields(session, schemaCode, propertyType, relativeCode, options) {
+    const type = typeof propertyType === "number" ? propertyType : FIELD_PROPERTY_TYPES[String(propertyType ?? "")];
+    if (type !== FIELD_PROPERTY_TYPES.WORK_SHEET && type !== FIELD_PROPERTY_TYPES.MULT_WORK_SHEET)
+        return;
+    const target = String(relativeCode ?? options.schemaCode ?? "").trim();
+    if (!target)
+        return;
+    const targetRows = wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: target, isPublish: "true" } })).data);
+    const ownRows = wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode, isPublish: "true" } })).data);
+    const business = (rows) => rows
+        .map((row) => ({ code: String(row.code ?? row.propertyCode ?? "").trim(), type: relationTypeOf(row) }))
+        .filter((row) => row.code && !SYSTEM_FIELD_CODES.has(row.code));
+    const targetFields = business(targetRows);
+    const ownFields = business(ownRows);
+    // A compatibility/fake transport may expose an empty field face even though
+    // the model exists. Empty metadata is not proof that a requested field is
+    // absent; preserve the existing relation write path rather than rejecting a
+    // valid payload on an unavailable read face.
+    if (targetRows.length === 0 || ownRows.length === 0)
+        return;
+    const candidates = targetFields.map((row) => row.code).sort();
+    const display = typeof options.displayField === "string" ? options.displayField.trim() : "";
+    if (display) {
+        const field = targetFields.find((row) => row.code === display);
+        const declaredType = options.displayFieldType === undefined ? undefined : Number(options.displayFieldType);
+        if (!field || (declaredType !== undefined && Number.isInteger(declaredType) && field.type !== undefined && field.type !== declaredType)) {
+            throw new ToolRefusalError({ status: "refused", blocker: "relation-display-field-not-found", schemaCode, relationTarget: target, displayField: display, candidates, message: `关联显示字段 ${target}.${display} 不存在于发布面或类型不兼容；请从目标模型业务字段中选择。候选：${candidates.join("、") || "（无）"}` });
+        }
+    }
+    let mappings = options.mappings;
+    if (typeof mappings === "string" && mappings) {
+        try {
+            mappings = JSON.parse(mappings);
+        }
+        catch {
+            mappings = [];
+        }
+    }
+    if (!Array.isArray(mappings))
+        return;
+    const sourceCandidates = targetFields.map((row) => row.code).sort();
+    const targetCandidates = ownFields.map((row) => row.code).sort();
+    for (const [index, row] of mappings.entries()) {
+        const source = row && typeof row === "object" ? String(row.source ?? "").trim() : "";
+        const mappedTarget = row && typeof row === "object" ? String(row.target ?? "").trim() : "";
+        if (!sourceCandidates.includes(source) || !targetCandidates.includes(mappedTarget)) {
+            throw new ToolRefusalError({ status: "refused", blocker: "relation-mapping-field-not-found", schemaCode, relationTarget: target, mappingIndex: index, source, targetField: mappedTarget, sourceCandidates, targetCandidates, message: `关联映射第 ${index + 1} 行字段不存在：source=${source || "(空)"}（目标模型候选：${sourceCandidates.join("、") || "（无）"}），target=${mappedTarget || "(空)"}（本模型候选：${targetCandidates.join("、") || "（无）"}）。请使用发布面业务字段 code。` });
+        }
+    }
+}
 async function readFieldRollback(session, args) {
     for (const published of [false, true]) {
         const row = wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: String(args.schemaCode), isPublish: String(published) } })).data).find((entry) => String(entry.code ?? entry.propertyCode) === String(args.code));
@@ -314,7 +369,11 @@ export function registerFieldLane(tools) {
                         ...(conditions.length > 0 ? { conditions } : {}),
                         ...(field.shapeWarning !== undefined ? { shapeWarning: field.shapeWarning } : {}),
                         ...(field.origin !== undefined ? { origin: field.origin } : {}),
-                        ...(args.full === true && "options" in field && field.options !== undefined ? { options: field.options, optionsPresent: true } : {}),
+                        ...(args.full === true
+                            ? ("options" in field && field.options !== undefined
+                                ? { options: field.options, optionsPresent: true }
+                                : { optionsPresent: false })
+                            : {}),
                     };
                 });
             return {
@@ -373,6 +432,11 @@ export function registerFieldLane(tools) {
                             ...(conditions.length > 0 ? { conditions } : {}),
                             ...(field.shapeWarning !== undefined ? { shapeWarning: field.shapeWarning } : {}),
                             ...(field.origin !== undefined ? { origin: field.origin } : {}),
+                            // r46a 接线（2026-11-08，r45 普查 R5a）：压缩占位行保留**标量判别键**
+                            // optionsPresent——不然 >10 行的 full 读回内联面完全看不到 presence
+                            // 信号，agent 误判「条件没写进去」（S1-G3 预言命中：通用层把「有值
+                            // 但正文外置」和「确实没有」混在一起）。正文仍在 artifact。
+                            ...(field.optionsPresent !== undefined ? { optionsPresent: field.optionsPresent } : {}),
                         };
                     }),
                     hint: "字段详情（options/subSchema）用 omc call field.list --args '{\"schemaCode\":\"...\",\"published\":true,\"code\":\"<field>\"}'",
@@ -418,6 +482,7 @@ export function registerFieldLane(tools) {
             // （cpdocs issue #8：缺键让设计器选项弹窗硬崩）。
             const targetVersion = session.detectedVersion();
             const prepared = prepareFieldChange({ ...args, ...(targetVersion ? { targetVersion } : {}) });
+            await assertRelationOptionsFields(session, args.schemaCode, prepared.propertyType, args.relativeCode, prepared.options);
             let performed;
             try {
                 performed = await wireCall(session, { path: ENDPOINTS.fieldCreate, method: "POST", body: fieldChangeWireBody(args, prepared) });
@@ -730,6 +795,7 @@ async function fieldUpdateDryRun(session, args) {
         ...(args.propertyEmpty !== undefined ? { propertyEmpty: args.propertyEmpty } : {}),
     };
     const prepared = prepareFieldUpdate(update);
+    await assertRelationOptionsFields(session, args.schemaCode, prepared.propertyType, args.relativeCode ?? record.relativeCode, prepared.options);
     const currentOptions = decodeJsonObjectColumn(record.options, { invalid: "throw", array: "accept", object: "accept" }) ?? {};
     const changes = [];
     const pushChange = (field, from, to) => {

package/dist/lanes/organization.js

@@ -554,8 +554,11 @@ export function registerOrganizationLane(tools) {
             // A 32-hex id absent from the tree may be a group created moments ago in
             // this same session; let it through and rely on the visibility backstop.
             if (!match && args.roleGroupCode) {
-                throw new ToolInputError({
+                throw new ToolRefusalError({
+                    status: "refused",
+                    blocker: "role-group-not-found",
                     message: `角色组 ${requested} 不存在。可用组：${groups.map((group) => `${group.code}（id=${group.id}，${group.name}）`).join("；")}`,
+                    candidates: groups.map((group) => ({ code: group.code, id: group.id, name: group.name })),
                 });
             }
             const roleGroupId = match?.id ?? String(requested);

package/dist/lanes/workflow.js

@@ -878,7 +878,15 @@ async function assertRoleParticipantScopes(session, body) {
         if (String(activity.activityType ?? "") !== "PARTICIPANT")
             continue;
         const participant = typeof activity.participant === "string" ? activity.participant.trim() : "";
-        const match = /^FindUserByRole\s*\(\s*[^,]+?\s*,\s*("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')\s*,\s*("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')\s*\)\s*$/.exec(participant);
+        if (/^FindUserByRole\s*\(/i.test(participant)) {
+            const strict = /^FindUserByRole\s*\(\s*\{Originator\.OU\}\s*,\s*("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')\s*,\s*("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')\s*\)\s*$/i.exec(participant);
+            if (!strict)
+                throw new ToolRefusalError({ status: "refused", blocker: "workflow-find-user-by-role-parameters-invalid", activityCode: String(activity.activityCode ?? ""), nextCommand: "使用 FindUserByRole({Originator.OU},\"<真实角色code>\",\"random\")；组织范围不得手填 id", message: `节点 ${String(activity.activityCode ?? "")} 的 FindUserByRole 参数不合法：x 必须是单一 {Originator.OU}，不得手填 id；y 必须是带引号的单一角色 code。` });
+            const order = strict[2].slice(1, -1);
+            if (!new Set(["dept", "sortKey", "random"]).has(order))
+                throw new ToolRefusalError({ status: "refused", blocker: "workflow-find-user-by-role-order-invalid", activityCode: String(activity.activityCode ?? ""), order, candidates: ["dept", "sortKey", "random"], nextCommand: "将第三参数改为 dept、sortKey 或 random", message: `FindUserByRole 第三参数 ${order} 不在允许枚举 dept/sortKey/random。` });
+        }
+        const match = /^FindUserByRole\s*\(\s*\{Originator\.OU\}\s*,\s*("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')\s*,\s*("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')\s*\)\s*$/.exec(participant);
         if (!match)
             continue;
         const quoted = match[1];
@@ -902,9 +910,7 @@ async function assertRoleParticipantScopes(session, body) {
             roleListAvailable = true;
         }
         catch {
-            // Role existence is advisory when the organization read face is unavailable.
-            // Do not turn a transient read failure into a blanket workflow write outage.
-            roleListAvailable = false;
+            throw new ToolRefusalError({ status: "refused", blocker: "workflow-participant-role-read-failed", nextCommand: "omc call org.role.list --args '{}'", message: "无法读取真实角色树，不能确认 FindUserByRole 的 role code；为避免流程静默回退发起人，已 fail-closed 拒绝写入。请恢复组织读面后重试。" });
         }
         if (roleListAvailable) {
             const byCode = new Map(listedRoles

package/dist/recipes/businessrule.js

@@ -385,6 +385,7 @@ const ruleCrossModelCreate = Object.freeze({
         "**`originatorValueType:\"DYNAMIC\"` 的 `originatorValue` 必须指向人员字段**（STAFF_SELECTOR 等）；指向文本/编号字段会致发起人错误或为空。",
         "「当前时间」不是规则的 value 类型：`ruleValueType:\"SYSTEM\"` 不会填 now（真机 2026-10-08 落 null）。要让下游日期=生成时刻，把该**日期字段的默认值**设为「当前时间」（平台 `{value:\"current\"}`），或走二开；纯规则映射填不出 now。",
         "上游是 QUERY 时 `inputParam=\"_<QUERY节点code>_output\"`（QUERY 查 N 行→CREATE 逐条生成即 N→N 扇出，真机验证支持，同/跨模型均可）；否则 `\"_input\"`。",
+        "跨模型 UPDATE 三段：`inputParam`/`currentSchemaDataItem`=输入源（触发行或 QUERY 输出）→ `filterCondition` 查 `targetSchemaCode` 目标行 → `dataActions` 写入。QUERY 目标行非隐式输入源；child fan-out 保持 fail-closed。",
         "`QUERY` 节点只能查**主模型行**：查子表 schema（`parent.child` 或子 schema 名）空条件返回 0 行、带条件 550018（真机 2026-10-08）——逐子表明细扇出才需要二开。",
         "跨模型 CREATE/UPDATE 真机验证支持（2026-09-28 / 2026-10-08）；承载规则的触发时机要对（Create 在提交时触发、Update 只在 data.update 触发、TIMING 定时触发）。",
         "**CREATE 目标是已发布流程的模型时**（2026-10-27 真机四格矩阵）：不传 startWorkflow → 建行**不发起流程**；要发起必须 startWorkflow:true + targetWorkflowCode:<该流程> + originatorValue 用户对象数组 [{\"id\":\"<userId>\",\"name\":\"<名>\"}]（传对象 {} → 触发提交 50000 expect '['；无效 id → 50000 发起人不存在）；设计器手工编辑可打开该开关，API 与设计器配置会漂移，rule.get 回读核对。",

package/dist/recipes/field.js

@@ -107,7 +107,7 @@ const numericTwoDecimals = Object.freeze({
     priorToolReferences: [{ tool: "discover_environment", args: { environment }, purpose: "确认目标模型已存在" }],
     dryRun: { supported: true, command: `omc call field.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验 propertyType/scale/治理，不创建" },
     expectedReadback: { readback: { draftFieldPresent: true }, next: ["field.publish"] },
-    refusalRecovery: [{ code: "capability-out-of-coverage", action: "NUMERICAL 必须带 options.scale；金额两位小数用 scale:2，整数用 scale:0" }, ...commonRecovery],
+    refusalRecovery: [{ code: "field-options-shape", action: "NUMERICAL 必须带 options.scale；金额两位小数用 scale:2，整数用 scale:0" }, ...commonRecovery],
     requiresEnvironmentDerivedIds: false,
 });
 const dictionarySelection = Object.freeze({

package/dist/rule-support.js

@@ -6,6 +6,7 @@ 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, DEFAULT_SYSTEM_NODE_BY_RULE_CODE } from "./lanes/rule-graph.js";
+import { FORMULA_LINT_CODES } from "./formula-lint.js";
 import { compileMethodConfigPlain } from "./bizservice-config.js";
 import { RESERVED_CODES } from "./code-rules.js";
 import { FIELD_PROPERTY_TYPES } from "./field-families.js";
@@ -757,6 +758,16 @@ export async function executeRuleSaveWrite(session, args) {
     // plain advisory.
     const lintWarnings = warningFindings.filter((blocker) => blocker.hazard !== true);
     const lintHazards = warningFindings.filter((blocker) => blocker.hazard === true);
+    const formulaWarnings = lintWarnings.filter((finding) => FORMULA_LINT_CODES.has(finding.code));
+    if (formulaWarnings.length > 0 && args.allowAdvisory !== true) {
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "formula-lint-failed",
+            validation: formulaWarnings,
+            nextCommand: "将未知函数改为平台注册函数（文本拼接使用 STRING），仅调查时显式传 allowAdvisory:true",
+            message: "公式写前校验拒绝：发现未知函数、平台别名或字符串 + 拼接。请修正公式；调查用途可显式 allowAdvisory:true（默认 fail-closed）。",
+        });
+    }
     if (blockers.some((blocker) => blocker.severity !== "warning")) {
         throw new ToolRefusalError({
             status: "refused",

package/dist/skills.js

@@ -276,6 +276,8 @@ export function readSkillSection(name, requested) {
     const matches = (heading) => {
         if (heading === normalized)
             return true;
+        if (heading.replace(/\s+`[^`]+`\s*$/, "").trim() === normalized)
+            return true;
         if (heading.replace(/[^\p{L}\p{N}]+/gu, "-").toLowerCase() === normalized)
             return true;
         if (requestedOrdinal !== undefined) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stalfh233/omc-cli",
-  "version": "0.6.25",
+  "version": "0.6.26",
   "description": "CloudPivot 8.6 configuration capability CLI — governed, fail-closed, coverage-manifest bounded.",
   "type": "module",
   "bin": {
@@ -55,7 +55,7 @@
   },
   "dependencies": {
     "commander": "14.0.3",
-    "omc-core": "0.6.25",
+    "omc-core": "0.6.26",
     "proper-lockfile": "4.1.2",
     "write-file-atomic": "6.0.0",
     "zod": "^3.23.8",
@@ -73,6 +73,6 @@
     "directory": "packages/omc-cli"
   },
   "optionalDependencies": {
-    "@stalfh233/omc-fake-platform": "0.6.25"
+    "@stalfh233/omc-fake-platform": "0.6.26"
   }
 }

package/skills/omc-playbook.md

@@ -13,6 +13,7 @@ description: 一页纸业务场景步骤清单（采购申请 / 请假审批 /
 
 1. `omc next "从零做采购申请：主子表、合计、条件审批、列表、按钮"` → `omc intent schema`
 2. `omc model-scaffold --app <app> --code <code> --name 采购申请 --fields '<JSON数组>' --apply`（字段含 `amount` NUMERICAL scale=2、`<主表code>_details` CHILD_TABLE 及 item/qty/price/lineAmount 子列；子表 code 必须全局唯一）
+3. （`model-scaffold` 已在第 2 步完成字段发布与表单发布；无需另起命令）
 4. `omc compute --schema <code> --target amount --formula 'SUM({<主表code>_details.lineAmount})' --apply`（⚠️ 只在门户算，REST 不回填）
 5. 条件审批（金额>50000 两级）：**不要** `approval-flow --condition`（无此参数）。线性先：`omc approval-flow --schema <code> --steps '经理@role:<mgr>' --steps '总监@role:<dir>' --apply`；条件分流改 `omc describe workflow.update --example workflow-conditional-branch` 后 `workflow.update`。
 6. 发起权限：`omc call workflow.addPermission --args '{"workflowCode":"<code>_wf","unitId":"<deptOrRoleId>","unitType":1}'`（这是**谁能发起**，不是行级可见范围）