@stalfh233/omc-cli 0.4.97 → 0.4.99

package/dist/capability-overview.js

@@ -231,7 +231,12 @@ export const CAPABILITY_CUES = Object.freeze({
     onlinejs: ["在线js", "脚本", "联动", "onload", "onvalidate"],
     bizservice: ["集成", "接口", "服务", "回调", "对接", "外部系统", "datasql", "restful"],
     report: ["报表", "图表", "看板", "bi", "dashboard"],
-    data: ["运行数据", "提交数据", "保存记录", "查记录"],
+    // r18 (2026-10-26): "造数据 / 造测试单据 / 录数据" is the RUN-DATA capability, but
+    // the goal usually also says 子表/明细 (field cues) — without these compound
+    // cues the router sent the probe to `field` in read mode (write:false), so it
+    // never reached data.submit. Compound (not bare 数据) to avoid stealing
+    // ordinary model/field asks that merely mention data.
+    data: ["运行数据", "提交数据", "保存记录", "查记录", "造数据", "测试数据", "测试单据", "造单据", "造单", "录数据", "填数据", "模拟数据", "业务数据", "造几条", "造两张", "造几张", "验数据"],
 });
 /**
  * Boundary cues — authored alongside CAPABILITY_CUES (same runtime authority).

package/dist/compute.js

@@ -212,8 +212,27 @@ export async function cmdCompute(args) {
     // data.save / data.submit / data.update never refresh the target field, no
     // matter how correct the formula is. Say so in the receipt instead of letting
     // the caller believe the write took effect (r12 believed it; r16 disproved it).
+    // r18: the dry-run receipt showed only an optionsSummary hash, so the probe
+    // could not tell whether `{items.qty} * {items.price}` means per-row or
+    // aggregate-after-multiply — a semantic difference that changes the answer.
+    // Echo the exact compiled formula (and its editor twin) on the dry-run face.
+    const compiled = !apply
+        ? (() => {
+            const stitch = createArgs.options?.shortTextStitch;
+            if (typeof stitch !== "string")
+                return undefined;
+            try {
+                const parsed = JSON.parse(stitch);
+                return { formula: parsed.formula ?? null, editorText: parsed.editorText ?? null, editorMark: parsed.editorMark ?? null };
+            }
+            catch {
+                return undefined;
+            }
+        })()
+        : undefined;
     const withWarning = apply && classified.status === "ok" ? { ...result, ...computeExecutionNotice() } : result;
-    writeEnvelope(envelope(classified.status, withWarning, request, classified.error));
+    const withCompiled = compiled ? { ...withWarning, compiledFormula: compiled } : withWarning;
+    writeEnvelope(envelope(classified.status, withCompiled, request, classified.error));
     return exitCode;
 }
 //# sourceMappingURL=compute.js.map

package/dist/field-families.js

@@ -954,6 +954,43 @@ export function assertFieldOptionsAllowed(type, options, schemaCode) {
                 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({<目标模型>.<字段>})", calculateType:"SUM", queryConditions:[[…]]}（FormulaProcessor.executeMainAggregation + AggregationFormula）');
+                // r18b (2026-10-26 live): LARGE/SMALL take a position argument and the
+                // platform evaluates the FORMULA, so `LARGE({col})` (no k) throws
+                // NumberFormatException internally and the target write answers 50000.
+                const calcType = typeof agg.calculateType === "string" ? agg.calculateType.toUpperCase() : "";
+                if (["LARGE", "SMALL"].includes(calcType) && !/(LARGE|SMALL)\s*\(\s*[^,()]+\s*,/.test(String(agg.formula)))
+                    throw new ToolRefusalError({
+                        status: "refused",
+                        blocker: "aggregation-large-missing-k",
+                        schemaCode: schemaCode ?? null,
+                        calculateType: calcType,
+                        formula: String(agg.formula),
+                        message: `${calcType} 必须带位置参数 k：写成 ${calcType}({<来源模型>.<数值列>},<k>)（k=1 是最大/最小）。` +
+                            `缺 k 时平台内部抛 NumberFormatException（日志可见），目标模型写入一律 50000（r18b 真机）。` +
+                            `真机验证：LARGE({src.amt},2) 对 10/30/20 返回 20；SMALL({src.amt},1) 返回 10。`,
+                    });
+                // UNION concatenates DISTINCT text values ("去重后拼接文本"), so a numeric
+                // resultType makes the aggregation parse text as a number and the write
+                // 50000s. Text result types: SHORT_TEXT(0) / LONG_TEXT(1).
+                if (calcType === "UNION" && ![0, 1].includes(Number(agg.resultType ?? 2)))
+                    throw new ToolRefusalError({
+                        status: "refused",
+                        blocker: "aggregation-union-result-type",
+                        schemaCode: schemaCode ?? null,
+                        resultType: Number(agg.resultType ?? 2),
+                        message: `UNION 是「去重后拼接文本」，resultType 必须是文本类型（0=SHORT_TEXT / 1=LONG_TEXT；顶层 formulaConfig.resultType 决定）。` +
+                            `用数值 resultType 时平台把拼接结果按数字解析 → NumberFormatException → 目标写入 50000（r18b 真机：resultType:2 失败，0 成功，读回 "P1"）。`,
+                    });
+                if (String(agg.dataItemCode).includes("."))
+                    throw new ToolRefusalError({
+                        status: "refused",
+                        blocker: "aggregation-data-item-not-scalar",
+                        schemaCode: schemaCode ?? null,
+                        dataItemCode: String(agg.dataItemCode),
+                        message: `聚合数据项 ${String(agg.dataItemCode)} 带点号：平台只接受**来源模型的主表标量列 code**（不带 schema 前缀）。` +
+                            `写成 <子表>.<子列> 会在 field.publish 回 309004「使用的聚合数据项不存在」（r18 真机）。` +
+                            `要汇总子表列：先在来源主模型上物化一个数值字段（门户计算规则或写入方维护），再聚合那个标量列。`,
+                    });
                 if (schemaCode !== undefined && aggregationTargetsOwnSchema(schemaCode, String(agg.schemaCode)))
                     throw new ToolRefusalError({
                         status: "refused",

package/dist/goal-routes.js

@@ -13,7 +13,7 @@ import { listSkills, readSkillSection } from "./skills.js";
 const SCOUT_CUES = ["能不能", "能不能够", "能否", "是否支持", "支持吗", "支持不支持", "可不可以", "有没有办法", "有没有可能", "怎么实现", "如何实现", "怎么写", "怎么配置"];
 const MODIFY_CUES = ["修改", "调整", "更新", "重命名", "改名", "编辑", "删除", "去掉", "移除", "改为", "改成"];
 const READ_CUES = ["查看", "读回", "盘点", "现状", "列出", "有哪些", "有没有", "检查", "审计", "导出", "只读", "看看", "看下", "查一下", "查询一下", "查一查", "梳理", "清点", "给我一份", "哪些", "是什么", "是否", "是否正确", "现有", "已有"];
-const BUILD_CUES = ["新建", "创建", "搭建", "从零", "从无到有", "做", "建", "加", "实现", "生成", "新增", "保存", "启用", "录入", "添加"];
+const BUILD_CUES = ["新建", "创建", "搭建", "从零", "从无到有", "做", "建", "加", "实现", "生成", "新增", "保存", "启用", "录入", "添加", "造", "填报", "打卡", "录"];
 /** Whole-application asks — a single-model atom is the wrong shape for these. */
 const WHOLE_APP_CUES = ["应用", "系统", "整套", "从零", "从无到有", "端到端", "一条龙", "一整套", "业务应用", "平台"];
 function looksWholePackage(goal, capabilityCount) {
@@ -122,6 +122,10 @@ function capabilityScores(registry, goal) {
 const DEFAULT_LADDER_RECIPES = {
     businessrule: { tool: "rule.save", recipe: "business-rule-branch-conditional" },
     datarule: { tool: "datarule.create", recipe: "field-compute-rule" },
+    // r18: a "造数据 / 录测试单据" ask reached the `data` capability but had no
+    // runnable shape — the probe had to fetch `describe data.submit --example`
+    // itself. These lane defaults give every ladder step a copyable command.
+    data: { tool: "data.submit", recipe: "plain-data-submit" },
 };
 function defaultRecipeFor(registry, capabilityId, lane) {
     const wanted = DEFAULT_LADDER_RECIPES[capabilityId];
@@ -609,6 +613,13 @@ export function goalRoute(registry, goal) {
             route: {
                 ...(whole ? { primary: "intent", atomicSupplement } : { ladder }),
                 ...routeReads(readSections),
+                // r18: when a step already carries a goal-matched recipe, the generic
+                // first section ("3. Draft template") is noise — the probe read it and
+                // got nothing. Say that the recipe command is the answer and the
+                // sections are only a fallback.
+                ...(ladder.some((step) => step.recipe)
+                    ? { readHint: "已命中配方：先跑 firstCommands 里的 `omc describe … --example …` 取形状；下面的 readSections 只是补充，不必先读（确实需要时用 `omc help <topic> --section \"<节>\"`，按 readMore 逐节补）。" }
+                    : {}),
                 // Each ladder step already carried a runnable recipe command, but it sat
                 // buried at `ladder[i].recipe.command` behind a readiness line — r14's
                 // probe reported "ladder 本身没给可直接跑的命令" and hand-built the rule

package/dist/lanes/field.js

@@ -141,6 +141,21 @@ function assertNameI18nArg(nameI18n) {
     if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
         refuse("JSON 解析结果不是对象");
 }
+/**
+ * r18 (2026-10-26 live): aggregating a CHILD-TABLE schema (`schemaCode:"items"`)
+ * publishes fine but makes the TARGET model unwritable — every data.submit /
+ * data.update answers `40000 调用数据库发生异常` with no detail (the probe spent
+ * ~40 calls bisecting it). The child schema also has no parent-document column,
+ * so matching by the parent's document number can never work: even when the
+ * write goes through the value is always 0.
+ *
+ * Child schemas are recognizable from their field list: they alone carry the
+ * system columns `parentId`（子表业务对象父类ID）and `sortKey`（子表排序号）.
+ */
+function childSchemaCodes(rows) {
+    const codes = new Set(rows.map((row) => String(row.code ?? row.propertyCode ?? "")));
+    return codes.has("parentId") && codes.has("sortKey");
+}
 /**
  * r17 (2026-10-25, live + decompiled A/B): a FORMULA field CANNOT aggregate its
  * own model's child table. `BizPropertyManagerImpl.publishFormula` rewrites
@@ -184,6 +199,43 @@ function assertNoSelfSchemaAggregation(args, published) {
         message: aggregationSelfSchemaMessage(target, args.schemaCode),
     });
 }
+/**
+ * The async half of the aggregation gate: a FOREIGN child schema cannot be
+ * detected syntactically, so read the target's field list once (only for
+ * AGGREGATION) and refuse when it carries the child-schema system columns.
+ */
+async function assertNoChildSchemaAggregation(session, schemaCode, propertyType, options) {
+    const resolved = typeof propertyType === "number" ? propertyType : FIELD_PROPERTY_TYPES[String(propertyType)];
+    if (resolved !== FIELD_PROPERTY_TYPES.FORMULA)
+        return;
+    const config = decodeJsonObjectColumn(options.formulaConfig, { invalid: "undefined", array: "reject", object: "reject" });
+    if (!config || config.formulaType !== "AGGREGATION" || typeof config.aggregation !== "string")
+        return;
+    const agg = decodeJsonObjectColumn(config.aggregation, { invalid: "undefined", array: "reject", object: "reject" });
+    const target = typeof agg?.schemaCode === "string" ? agg.schemaCode.trim() : "";
+    if (!target)
+        return;
+    let rows;
+    try {
+        rows = wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: target, isPublish: "true" } })).data);
+    }
+    catch {
+        return;
+    }
+    if (!childSchemaCodes(rows))
+        return;
+    throw new ToolRefusalError({
+        status: "refused",
+        blocker: "aggregation-target-is-child-schema",
+        schemaCode,
+        aggregationSchemaCode: target,
+        message: `聚合目标 ${target} 是**子表 schema**（字段清单里带 parentId/sortKey 系统列）。` +
+            `平台允许发布，但目标模型从此**整个不可写**：data.submit/data.update 一律回 40000「调用数据库发生异常」且无明细（r18 真机，二分 40 次调用才定位）。` +
+            `而且子表 schema 没有父单单号列，按父单匹配恒为 0——即使不报错也算不出值。` +
+            `正确做法：聚合**来源模型的主表标量列**。需要子表合计时，先在来源主模型物化一个数值字段` +
+            `（门户计算规则 / 写入方维护），再用 AGGREGATION 聚合该标量。配方：omc describe field.create --example formula-aggregation-cross-model。`,
+    });
+}
 export function registerFieldLane(tools) {
     tools.push(defineTool({
         name: "field.list",
@@ -344,6 +396,7 @@ export function registerFieldLane(tools) {
         // One seam owns field-change normalization, every reproduced gate, and the
         // wire body (src/field-change.ts), so configure_model and intent share it.
         assertNoSelfSchemaAggregation(args, published);
+        await assertNoChildSchemaAggregation(session, args.schemaCode, args.propertyType, args.options ?? {});
         const prepared = prepareFieldChange(args);
         let performed;
         try {
@@ -437,6 +490,7 @@ async function runFieldUpdate(session, args) {
             .then((response) => wireRows(response.data))
             .catch(() => []);
         assertNoSelfSchemaAggregation({ schemaCode: args.schemaCode, propertyType: record.type ?? record.propertyType, options: args.options }, publishedRows);
+        await assertNoChildSchemaAggregation(session, args.schemaCode, record.type ?? record.propertyType, args.options);
     }
     const update = {
         schemaCode: args.schemaCode,

package/dist/lanes/runtime-data-contract.js

@@ -40,7 +40,7 @@ export function dataSubmitDescription() {
         `就地语义：${wire.submitInPlace}；无流程 readback 必须确认 objectId 与传入 bizObjectId 相同；无 bizObjectId 的 workflowCode 新建单 → PROCESSING + workflowInstanceId，无流程 → 该行 COMPLETED。`,
         `既有草稿发起流程的唯一支持形状是两段式：先 data.save 带 workflowCode 暂存（${wire.workflowDraftSave}），再以返回的 workItemId 提交。`,
         `仅无 workflowCode/workItemId/workflowInstanceId 且无 bizObjectId 时保留 save→submit 便捷链（新建记录）；只要存在 workItemId 或 workflowInstanceId 就 fail-closed 拒绝（blocker submit-biz-object-id-required），零 runtime/form/submit wire。`,
-        `formType 自动判定：无任何 workflowCode/workItemId/workflowInstanceId 时**先按模型自动判定**——GET workflow/isworkflow?schemaCode=true 则用 workflow/getWorkflow 解析已发布流程码并**发起流程**（formType="${wire.formTypeWorkflow}"，自动先 GET getReplayToken 注入 replayToken，否则 ${wire.replayTokenErrcode} 频繁重复提交）；模型无流程 → "${wire.formTypeNoWorkflow}"（无流程提交，走 live 已证链 ${wire.submitChain}；单发新建对象会 ${wire.typeCastErrcode}，bizObject 勿带字符串 status）或 workItemId+workflowInstanceId（审批待办，agree 通过/驳回，**必须带 bizObjectId 指向在途单据**，否则引擎 NPE ${wire.approvalNpeErrcode}）→ "${wire.formTypeWorkflow}"。即「无流程直接提交、有流程发起流程」，不再把有流程模型的新建数据落成游离 sheet 行。`,
+        `formType 自动判定：无任何 workflowCode/workItemId/workflowInstanceId 时**先按模型自动判定**——GET workflow/isworkflow?schemaCode=true 则用 workflow/getWorkflow 解析已发布流程码并**发起流程**（formType="${wire.formTypeWorkflow}"，自动先 GET getReplayToken 注入 replayToken，否则 ${wire.replayTokenErrcode} 频繁重复提交）；模型无流程 → "${wire.formTypeNoWorkflow}"（无流程提交，走 live 已证链 ${wire.submitChain}；单发新建对象会 ${wire.typeCastErrcode}，bizObject 勿带字符串 status）或 workItemId+workflowInstanceId（审批待办，agree **顶层**通过/驳回（approval 对象里放 agree 会被静默忽略并按通过处理），**必须带 bizObjectId 指向在途单据**，否则引擎 NPE ${wire.approvalNpeErrcode}）→ "${wire.formTypeWorkflow}"。即「无流程直接提交、有流程发起流程」，不再把有流程模型的新建数据落成游离 sheet 行。`,
         "根因提示（环境相关，ticket 78 观测）：**某些环境**里模型所在应用未发布时运行时提交稳定 50000，工具会反推并拒 app-not-published。该根因非普遍规律（见 data.save 的同条提示与 docs/issues/omc-cli-findings-2026-09-19.md B17）——遇 50000 先只读核对再判断。",
         "Pass `sheetCode` explicitly when the model has multiple sheets; otherwise the default-form sheetCode is resolved from bizsheet/get.",
         `计算字段：${wire.formulaFieldNote}`,

package/dist/lanes/runtime-data.js

@@ -598,6 +598,65 @@ export function assertRuntimeFieldValueShapes(meta, formData, childCodes, contex
         }
     }
 }
+/**
+ * r18 (2026-10-26 live): `errcode 40000 调用数据库发生异常` carries NO detail and
+ * `omc-refusals` had nothing for it. A probe burned ~40 calls bisecting it:
+ * the cause was an AGGREGATION field whose `schemaCode` pointed at a CHILD-TABLE
+ * schema — publish succeeds, then every write on that model 40000s. A FORMULA
+ * field whose config cannot serialize does the same.
+ *
+ * Metadata is read ONLY on failure (zero cost on the success path). The refusal
+ * names the model's FORMULA/AGGREGATION fields so the caller bisects the right
+ * thing instead of guessing at forms/permissions.
+ */
+async function diagnoseDbException(session, schemaCode, error) {
+    // Non-40000 errors fall through untouched (callers keep their own branches).
+    if (!(error instanceof WireError && error.kind === "business" && error.errcode === 40000))
+        return false;
+    let rows = [];
+    try {
+        rows = wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode, isPublish: "true" } })).data);
+    }
+    catch {
+        // metadata unavailable: still explain what 40000 means
+    }
+    const formulaFields = [];
+    for (const row of rows) {
+        if (Number(row.propertyType ?? row.type) !== 100)
+            continue;
+        let formulaType;
+        let aggregationSchemaCode;
+        if (typeof row.options === "string" && row.options) {
+            try {
+                const options = JSON.parse(row.options);
+                const config = typeof options.formulaConfig === "string" ? JSON.parse(options.formulaConfig) : undefined;
+                if (typeof config?.formulaType === "string")
+                    formulaType = config.formulaType;
+                if (typeof config?.aggregation === "string") {
+                    const agg = JSON.parse(config.aggregation);
+                    if (typeof agg.schemaCode === "string")
+                        aggregationSchemaCode = agg.schemaCode;
+                }
+            }
+            catch {
+                formulaType = "unparsable-formulaConfig";
+            }
+        }
+        formulaFields.push({ code: String(row.code ?? row.propertyCode ?? ""), ...(formulaType ? { formulaType } : {}), ...(aggregationSchemaCode ? { aggregationSchemaCode } : {}) });
+    }
+    throw new ToolRefusalError({
+        status: "refused",
+        blocker: "runtime-write-db-exception",
+        schemaCode,
+        errcode: 40000,
+        formulaFields,
+        message: `平台回 40000「调用数据库发生异常」——这是**无明细的掩码**，不是表单/权限问题（r18 真机）。` +
+            `本模型上的公式字段：${formulaFields.length > 0 ? formulaFields.map((field) => `${field.code}(${field.formulaType ?? "?"}${field.aggregationSchemaCode ? `→${field.aggregationSchemaCode}` : ""})`).join("、") : "（读不到 field.list，或没有 FORMULA 字段）"}。` +
+            `最常见原因：**AGGREGATION 字段的 schemaCode 指向子表 schema** —— 平台允许发布，但该模型从此整个不可写。` +
+            `其次是 FORMULA 的 formulaConfig 无法序列化。` +
+            `定位：依次禁用/删除可疑公式字段再写一次（可逆）；形状见 omc describe field.create --example formula-aggregation-cross-model。`,
+    });
+}
 /** Runtime business-object data keyed by field code. */
 export function registerRuntimeDataLane(tools) {
     tools.push(defineTool({
@@ -949,15 +1008,22 @@ export function registerRuntimeDataLane(tools) {
             // isStartWf branch runs verifyReplay; the instance is DRAFT only when
             // data carries sequenceStatus DRAFT (an empty default builds PROCESSING).
             const replayToken = await getReplayToken(session);
-            const performed = await runtimeWriteWithAppMapping(session, args.schemaCode, 50000, "data.save 运行时写稳定失败（50000）", () => wireCall(session, {
-                path: ENDPOINTS.runtimeFormSave,
-                method: "POST",
-                body: {
-                    workflowCode: args.workflowCode,
-                    ...(replayToken ? { replayToken } : {}),
-                    bizObject: { schemaCode: args.schemaCode, sheetCode, data: { ...formData, id: objectId, sequenceStatus: "DRAFT" } },
-                },
-            }), formData, args.workflowCode);
+            let performed;
+            try {
+                performed = await runtimeWriteWithAppMapping(session, args.schemaCode, 50000, "data.save 运行时写稳定失败（50000）", () => wireCall(session, {
+                    path: ENDPOINTS.runtimeFormSave,
+                    method: "POST",
+                    body: {
+                        workflowCode: args.workflowCode,
+                        ...(replayToken ? { replayToken } : {}),
+                        bizObject: { schemaCode: args.schemaCode, sheetCode, data: { ...formData, id: objectId, sequenceStatus: "DRAFT" } },
+                    },
+                }), formData, args.workflowCode);
+            }
+            catch (error) {
+                await diagnoseDbException(session, args.schemaCode, error);
+                throw error;
+            }
             const vo = (performed.data ?? {});
             const returnedId = typeof vo.objectId === "string" && vo.objectId ? vo.objectId : typeof vo.bizObjectId === "string" && vo.bizObjectId ? vo.bizObjectId : objectId;
             const workflowInstanceId = typeof vo.workflowInstanceId === "string" ? vo.workflowInstanceId : null;
@@ -992,11 +1058,18 @@ export function registerRuntimeDataLane(tools) {
                 readback: { authoritative: projectReadbackRecord(normalizeLoadedRecord((readbackData ?? {})), args), sequenceStatus, expectedSequenceStatus: "DRAFT" },
             };
         }
-        const performed = await runtimeWriteWithAppMapping(session, args.schemaCode, 50000, "data.save 运行时写稳定失败（50000）", () => wireCall(session, {
-            path: ENDPOINTS.runtimeFormSave,
-            method: "POST",
-            body: { bizObject: { schemaCode: args.schemaCode, sheetCode, data: formData } },
-        }), formData);
+        let performed;
+        try {
+            performed = await runtimeWriteWithAppMapping(session, args.schemaCode, 50000, "data.save 运行时写稳定失败（50000）", () => wireCall(session, {
+                path: ENDPOINTS.runtimeFormSave,
+                method: "POST",
+                body: { bizObject: { schemaCode: args.schemaCode, sheetCode, data: formData } },
+            }), formData);
+        }
+        catch (error) {
+            await diagnoseDbException(session, args.schemaCode, error);
+            throw error;
+        }
         const bizObjectId = performed.data?.bizObjectId ?? performed.data?.objectId ?? performed.data;
         let readbackData = null;
         if (typeof bizObjectId === "string" && bizObjectId) {
@@ -1090,14 +1163,21 @@ export function registerRuntimeDataLane(tools) {
             });
         }
         const formData = (await prepareRuntimeFormData(session, args.schemaCode, args.formData, { isUpdate: true })).formData;
-        const performed = await wireCall(session, {
-            path: ENDPOINTS.runtimeFormSave,
-            method: "POST",
-            // Live-proven shape: BizObjectModel.getId() reads data["id"], so the
-            // target id MUST travel inside `data`; a top-level bizObject.id is
-            // ignored and the platform silently creates a new row.
-            body: { bizObject: { schemaCode: args.schemaCode, sheetCode, data: { ...formData, id: args.bizObjectId } } },
-        });
+        let performed;
+        try {
+            performed = await wireCall(session, {
+                path: ENDPOINTS.runtimeFormSave,
+                method: "POST",
+                // Live-proven shape: BizObjectModel.getId() reads data["id"], so the
+                // target id MUST travel inside `data`; a top-level bizObject.id is
+                // ignored and the platform silently creates a new row.
+                body: { bizObject: { schemaCode: args.schemaCode, sheetCode, data: { ...formData, id: args.bizObjectId } } },
+            });
+        }
+        catch (error) {
+            await diagnoseDbException(session, args.schemaCode, error);
+            throw error;
+        }
         const performedData = (performed.data ?? {});
         const returnedId = typeof performedData.objectId === "string" ? performedData.objectId : typeof performedData.bizObjectId === "string" ? performedData.bizObjectId : args.bizObjectId;
         const readbackData = await loadExistingBizObject(session, args.schemaCode, sheetCode, returnedId);
@@ -1210,6 +1290,27 @@ export function registerRuntimeDataLane(tools) {
                     `而错误里不会说是哪一个。要么给出真实 id，要么整个省略该键（省略 ≠ 传空串）。`,
             });
         const hasWorkItem = typeof args.workItemId === "string" && args.workItemId.trim().length > 0;
+        // r18b: pure shape check — run before any read/wire so a wrong-result
+        // payload never costs a round trip.
+        if (args.approval && typeof args.approval === "object") {
+            const misplaced = args.approval;
+            if (misplaced.agree !== undefined)
+                throw new ToolRefusalError({
+                    status: "refused",
+                    blocker: "submit-approval-agree-misplaced",
+                    schemaCode: args.schemaCode,
+                    message: `approval.agree 不生效：平台只读**顶层** agree（true=通过 / false=驳回）。approval 对象里放 agree 会被**静默忽略并按通过处理**` +
+                        `（r18b 真机：approval:{agree:false} 仍写入 result=APPROVE 并把流程走完）。改成顶层参数 {"agree":false,...}。`,
+                });
+            if (misplaced.opinion !== undefined)
+                throw new ToolRefusalError({
+                    status: "refused",
+                    blocker: "submit-approval-opinion-misplaced",
+                    schemaCode: args.schemaCode,
+                    message: `approval.opinion 不是平台键，会被静默丢弃（r18b 真机：意见不进 h_biz_comment，content 为 NULL）。` +
+                        `审批意见（BizCommentModel）用 **approval.content**；附件 approval.resources；下一步审批人 approval.relUsers。`,
+                });
+        }
         const hasInstance = typeof args.workflowInstanceId === "string" && args.workflowInstanceId.trim().length > 0;
         const targetObjectId = typeof args.bizObjectId === "string" && args.bizObjectId.trim() ? args.bizObjectId.trim() : null;
         if ((hasWorkItem || hasInstance) && !targetObjectId) {
@@ -1424,6 +1525,7 @@ export function registerRuntimeDataLane(tools) {
             }), undefined, hasWorkflowCode ? explicitWorkflowCode : undefined);
         }
         catch (error) {
+            await diagnoseDbException(session, args.schemaCode, error);
             // r16 P4: 100005 is SYS_REPLAY_ERROR「频繁重复提交！」(ErrorCode.java:68 —
             // the same numeric code as TEST_CONNECTION_FAIL, so only the text
             // separates them). The platform rate-limits per WORK ITEM, so a different
@@ -1607,6 +1709,15 @@ export function registerRuntimeDataLane(tools) {
                 // SEPARATE concern from server-side business rules (which DO run on
                 // submit) — name that so `portalRulesExecuted:false` is not misread as
                 // "no rule ran" (dogfood R2).
+                // r18b: an approval submit that omits `agree` is treated as APPROVE by
+                // the platform (`agree: args.agree !== false`). That default is right
+                // for the portal button, but for an API caller "I forgot the flag" and
+                // "I approve" must not look identical in the receipt.
+                ...(hasWorkItem && args.agree === undefined
+                    ? {
+                        approvalNote: "本次是审批提交但未传 agree——平台按**通过**处理（顶层 agree 缺省 true）。要驳回必须显式 agree:false；approval.agree 不生效。",
+                    }
+                    : {}),
                 portalRulesExecuted: false,
                 portalRulesNote: "portalRulesExecuted 只指门户客户端的必填/控件校验未在 REST 提交时执行；服务端业务规则（含流程 end 规则）照常运行。",
                 requiredFields: validation.requiredFields,

package/dist/model-scaffold.js

@@ -108,11 +108,50 @@ export async function cmdModelScaffold(args) {
         ...(environment !== undefined ? { environment } : {}),
     };
     const plan = describeScaffoldPlan(options);
+    // r18: run the field-family preflight even in DRY-RUN. It is zero-wire
+    // (`field.create --dry-run` runs only the local capability gate), and the
+    // probe's first attempt — NUMERICAL without options.scale — passed the old
+    // plan-only dry-run and would have half-built a model on --apply.
+    const preflightProblems = [];
+    const preflightTargets = [
+        ...fields.filter((field) => scaffoldChildrenOf(field).length === 0),
+        ...fields.filter((field) => scaffoldChildrenOf(field).length > 0),
+    ];
+    {
+        for (const field of preflightTargets) {
+            const probe = await runToolCall("field.create", {
+                args: scaffoldFieldArgs(code, field),
+                requestId: request,
+                dryRun: true,
+                ...(environment !== undefined ? { environment } : {}),
+                print: () => undefined,
+            });
+            const status = String(probe.result.status ?? "ok");
+            if (probe.exitCode !== 0 || (status !== "dry-run" && status !== "ok")) {
+                preflightProblems.push({ code: field.code, message: refusalText(probe.result) });
+            }
+        }
+        if (preflightProblems.length > 0) {
+            writeEnvelope(envelope("error", {
+                status: "refused",
+                blocker: "scaffold-preflight-failed",
+                model: code,
+                written: false,
+                failed: preflightProblems.length,
+                preflightProblems,
+                message: `有 ${preflightProblems.length} 个字段的预检没过，**尚未写入任何东西**。` +
+                    `按 message 改 --fields 后重跑（常见：NUMERICAL 缺 options.scale、文本/数值字段用了自定义键名）。` +
+                    `--fields 的每一项就是 field.create 的参数（形状见 omc describe field.create），子表列用 subFields（childFields 是别名）。`,
+            }, request, { code: "policy-refused", message: "字段形状预检未通过（未写入）", retryable: false }));
+            return CLI_EXIT_CODES.policyRefused;
+        }
+    }
     if (!apply) {
         writeEnvelope(envelope("ok", {
             status: "dry-run",
             ...plan,
-            note: "dry-run 只列计划；--apply 依次执行 建模型 → 建字段 → 建子列 → 发布字段 → 发布表单。",
+            preflight: { checked: fields.length, passed: true },
+            note: "dry-run 只列计划；已对每个字段跑过本地形状预检（零 wire）。--apply 依次执行 建模型 → 建字段 → 建子列 → 发布字段 → 发布表单。",
         }, request));
         return CLI_EXIT_CODES.ok;
     }
@@ -138,43 +177,7 @@ export async function cmdModelScaffold(args) {
         return { ok: outcome.exitCode === 0, result };
     };
     const lastSummaries = [];
-    // 0) 前置校验：把每个字段先跑一次 dry-run（走完整字段族 preflight，不写库）。
-    // r13 真机：`NUMERICAL` 少 options.scale 时，前两个字段已经建好了才在第 3 个
-    // 报错，留下一个半成品模型要手工清。半成品比慢一点贵得多。
-    // 子列不在这里校验：它们的目标 schema（子表）此刻还不存在，dry-run 会误报。
-    const preflightTargets = [
-        ...fields.filter((field) => scaffoldChildrenOf(field).length === 0),
-        ...fields.filter((field) => scaffoldChildrenOf(field).length > 0),
-    ];
-    const preflightProblems = [];
-    for (const field of preflightTargets) {
-        const probe = await runToolCall("field.create", {
-            args: scaffoldFieldArgs(code, field),
-            requestId: request,
-            dryRun: true,
-            ...(environment !== undefined ? { environment } : {}),
-            print: () => undefined,
-        });
-        const status = String(probe.result.status ?? "ok");
-        if (probe.exitCode !== 0 || (status !== "dry-run" && status !== "ok")) {
-            preflightProblems.push({ code: field.code, message: refusalText(probe.result) });
-        }
-    }
-    if (preflightProblems.length > 0) {
-        const result = {
-            status: "refused",
-            blocker: "scaffold-preflight-failed",
-            model: code,
-            // Nothing was written — that is the point.
-            written: false,
-            failed: preflightProblems.length,
-            preflightProblems,
-            message: `有 ${preflightProblems.length} 个字段的 dry-run 预检没过，**尚未写入任何东西**。` +
-                `按下面的 message 改 --fields 后重跑（常见：NUMERICAL 缺 options.scale、SELECTION/RADIO 缺 choices、CHILD_TABLE 缺 subFields）。`,
-        };
-        writeEnvelope(envelope("refused", result, request, { code: "policy-refused", message: String(result.message), retryable: false }));
-        return CLI_EXIT_CODES.policyRefused;
-    }
+    // 0) 字段形状预检已在上面的 dry-run 分支前完成（零 wire）；这里只记录。
     steps.push({ step: "preflight", status: "ok", detail: { checked: preflightTargets.length, wrote: false } });
     // 1) 模型：已存在是常态（补建场景），不是失败。
     const created = await call("model.create", {

package/dist/recipes/field.js

@@ -253,12 +253,13 @@ const formulaAggregationCrossModel = Object.freeze({
     preconditions: [
         "**只能汇总「别的模型」**：同模型（含自己的子表）聚合在 field.publish 必抛 305003（平台 publishFormula 把相对码改写成子表父模型 = 本模型，checkCycleOfAggregation:1032 判成环）。工具已写前拒绝 `aggregation-self-schema-cycle`。",
         "目标字段用 FORMULA(100)（不是普通字段 + 计算规则——type2 计算规则在 REST 路径永不执行）。",
-        "`schemaCode` 是被汇总的**来源模型**；`dataItemCode` 是来源模型的列；`queryConditions` **不能为空**，否则反向过滤器为空、找不到要回算的目标行（真机：空条件时 recalc 日志照常打印但目标字段恒为 0）。",
+        "`schemaCode` 是被汇总的**来源模型**；`dataItemCode` 是来源模型的**主表标量列**（不带 schema 前缀）；`queryConditions` **不能为空**，否则反向过滤器为空、找不到要回算的目标行（真机：空条件时 recalc 日志照常打印但目标字段恒为 0）。",
+        "**不要指向子表 schema**（r18 2026-10-26 真机）：`schemaCode:\"<子表>\"` 能发布，但目标模型从此**整个不可写** —— `data.submit`/`data.update` 一律回 40000「调用数据库发生异常」且无明细；而且子表 schema 没有父单单号列，按父单匹配恒为 0。`dataItemCode` 写成 `<子表>.<子列>` 则在 publish 直接 309004「使用的聚合数据项不存在」。要汇总子表：先在来源**主模型**上物化一个数值字段（门户计算规则或写入方维护），再聚合该标量。OMC 已写前拒绝 `aggregation-target-is-child-schema` / `aggregation-data-item-not-scalar`。",
     ],
     conditionalRequirements: [
         "**DYNAMIC 条件的两个 code 分属两侧，写反了就静默 0**：`propertyCode` = **来源模型**的字段（这里是 r17_c.nm），`currentPropertyCode` = **目标模型**的字段（这里是 r17_d.srcNo）。语义 = 「来源行的 nm 等于本目标行的 srcNo」。",
         "`propertyType`/`currentPropertyType` 是 BizPropertyType 的**整数码**（0=SHORT_TEXT 2=NUMERICAL 9=WORK_SHEET…），`operatorType` 是 OperatorType 的**整数码**（1=EQ 6=ITEQ 9=IS_NULL 10=IS_NOT_NULL…）。写名字会被 ObjectMapperUtils 抛 json processing exception 并掩码成 305003；工具会自动转码。",
-        "`calculateType` 是**字符串**（SUM/COUNT/COUNTIF/SUMIF/AVG/MAX/MIN/LARGE/SMALL/UNION），不是枚举 code。",
+        "`calculateType` 是**字符串**（SUM/COUNT/COUNTIF/SUMIF/AVG/MAX/MIN/**LARGE/SMALL/UNION**），不是枚举 code。r18b 真机三种特殊算法：LARGE/SMALL **必须带位置参数** `LARGE({<来源>.<列>},2)`（缺 k → 平台 NumberFormatException → 目标写入 50000）；**UNION 是文本拼接**，顶层 `resultType` 必须是 0/LONG_TEXT=1（写 2 会 50000，读回是去重串，如单号本身）；SUM/AVG/MAX/MIN/COUNT 用 resultType:2。",
         "发布后平台会**自动生成一条 t100 CALCULATE_RULE 镜像行**（h_biz_data_rule，propertyCode=字段 code），它是回算触发的前置条件，别手动删。",
         "**回算时机（r17b 2026-10-26 真机完整行为图谱）**：① 目标行**自己 submit** 时镜像规则一定算（最可靠，不依赖事件）；② 来源行 submit/update/delete 触发 `RollUpEventListener`→`FormulaPropertySupport` 事件回算——FIXED+DYNAMIC 混用、多组 OR、COUNTIF/MAX、子表行级条件（propertyCode 带 `.`）都验证过，DELETE 也会回算；③ ⚠️ 事件回算**只在目标模型发布后的几分钟内可靠**，之后静默停止（源端数据变了目标字段不更新、无报错）——重新 `field.publish --force` 目标模型即可恢复。定时巡检/对账场景务必重发或依赖目标行写入路径。",
     ],

package/dist/recipes/runtime-data.js

@@ -48,7 +48,9 @@ const workflowSubmit = Object.freeze({
     tool: "data.submit",
     args: { environment, schemaCode: model, workflowCode: "<workflow.code>", bizObjectId: "<data.save.performed.bizObjectId>", workflowInstanceId: "<data.save.performed.workflowInstanceId>", workItemId: "<data.save.performed.workItemId>", formData: { name: "recipe draft" } },
     preconditions: ["同一 recipe 的 data.save 已成功并读回 DRAFT；workflowInstanceId/workItemId/bizObjectId 均非空"],
-    conditionalRequirements: ["workItemId 或 workflowInstanceId 出现时必须传 bizObjectId；身份只能复制 data.save 的 authoritative readback"],
+    conditionalRequirements: [
+        "workItemId 或 workflowInstanceId 出现时必须传 bizObjectId；身份只能复制 data.save 的 authoritative readback",
+    ],
     priorToolReferences: [
         { tool: "data.save", args: { environment, schemaCode: model, workflowCode: "<workflow.code>", formData: { name: "recipe draft" } }, purpose: "提供三个环境生成的提交身份" },
         { tool: "workitem.list", args: { environment }, purpose: "当 data.save 未直接返回 workItemId 时按 workflowInstanceId 解析待办" },

package/package.json

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

package/skills/omc-business-configuration.md

@@ -154,8 +154,9 @@ rules:
 - **「聚合计算」是字段能力，不是规则节点**：FORMULA(计算公式)字段的 `options.formulaConfig.formulaType="AGGREGATION"` 就是 UI 里的「配置方式 → 聚合计算」。**只能汇总另一个模型**（跨模型），**同模型/自己的子表会 305003**（`field.publish` 时 `publishFormula` 把相对码改写成子表父模型 = 本模型，`checkCycleOfAggregation:1032` 判成环；工具已写前拒绝 `aggregation-self-schema-cycle`）。可直接抄 `omc describe field.create --example formula-aggregation-cross-model`。形状：
   `options = {persistent:true, formulaConfig: JSON字符串({resultType:2, formulaType:"AGGREGATION", aggregation: JSON字符串({schemaCode:"<来源模型>", dataItemCode:"<来源列>", calculateType:"SUM", formula:"SUM({<来源模型>.<列>})", queryConditions:[[{propertyCode:"<来源模型字段>", currentPropertyCode:"<目标模型字段>", operatorType:1, valueType:"DYNAMIC"}]]})})}`。
   - **`queryConditions` 不能为空**：它是反向过滤器的唯一输入，空数组时回算日志照打但目标字段恒 0（r17 实测）。
+  - **聚合目标必须是来源主表的标量列**（r18 2026-10-26 真机）：`aggregation.schemaCode` 指向**子表 schema** 时能发布，但目标模型从此整个不可写（`data.submit`/`data.update` 全回 40000 无明细），且子表无父单单号列、匹配恒 0；`dataItemCode` 写 `<子表>.<子列>` 则 publish 回 309004。要子表合计：先在来源主模型物化一个数值字段，再聚合该标量。
   - **DYNAMIC 条件的两个 code 分属两侧，写反了静默 0**：`propertyCode` = 来源模型字段，`currentPropertyCode` = 目标模型字段；语义「来源行的 X 等于本目标行的 Y」。
-  - **`propertyType`/`currentPropertyType`（BizPropertyType）与 `operatorType`（OperatorType）必须写整数**——两者都是 `@JsonCreator get(int)`：propertyType 0=SHORT_TEXT 2=NUMERICAL 3=DATE 9=WORK_SHEET…；operatorType 1=EQ 2=NEQ 3=GT 4=IT（小于）5=GTEQ 6=ITEQ（小于等于）9=IS_NULL 10=IS_NOT_NULL…。写名字会被 `ObjectMapperUtils` 抛 json processing exception，再被死循环校验掩码成 305003（工具接受名字并自动转码）。`calculateType` 相反，是**字符串**（SUM/COUNT/COUNTIF/SUMIF/AVG/MAX/MIN/LARGE/SMALL/UNION）。
+  - **`propertyType`/`currentPropertyType`（BizPropertyType）与 `operatorType`（OperatorType）必须写整数**——两者都是 `@JsonCreator get(int)`：propertyType 0=SHORT_TEXT 2=NUMERICAL 3=DATE 9=WORK_SHEET…；operatorType 1=EQ 2=NEQ 3=GT 4=IT（小于）5=GTEQ 6=ITEQ（小于等于）9=IS_NULL 10=IS_NOT_NULL…。写名字会被 `ObjectMapperUtils` 抛 json processing exception，再被死循环校验掩码成 305003（工具接受名字并自动转码）。`calculateType` 相反，是**字符串**（SUM/COUNT/COUNTIF/SUMIF/AVG/MAX/MIN/LARGE/SMALL/UNION）；LARGE/SMALL 必须带 k（`LARGE({来源.列},2)`），UNION 是文本拼接、resultType 必须是 0/1。
   - **回算时机（r17b 2026-10-26 完整行为图谱）**：① 目标行**自己 submit** 时镜像规则一定算（最可靠）；② 来源行 submit/update/**delete** 触发 `RollUpEventListener`→`FormulaPropertySupport` 事件回算（FIXED+DYNAMIC 混用、多组 OR、COUNTIF/MAX、子表行级条件都验过）；③ ⚠️ 事件回算**只在目标模型发布后几分钟内可靠**，之后静默停止（无报错）——`field.publish --force` 目标模型恢复。发布后平台自动生成 t100 `CALCULATE_RULE` 镜像行，别删。r17 真机：目标行 srcNo=C1、来源 C1 行 amt=100 → 读 100；再提交一条 C1/amt=5 → 读 105。
   - **普通数值字段 + 计算规则（type2）不能替代**：REST 路径永不执行（`CalculateHandler.java:50` 的 `forceExecuteCalculateRule` 从不置真），门户里才算。
 - **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`）。

package/skills/omc-refusals.md

@@ -62,6 +62,14 @@ condition/expression/query shape is off. Compare against
 `omc describe <tool> --example …` and the node-graph prose, then re-save.
 Escalate to 二开 **only** for a real `capability-out-of-coverage` (§2).
 
+`40000 调用数据库发生异常` is the **most opaque** shape code — no detail at all.
+Line up the model's field-level config first: an `AGGREGATION` FORMULA field whose
+`aggregation.schemaCode` points at a **child-table schema** publishes fine and then
+makes every `data.submit`/`data.update` on that model 40000 (r18 2026-10-26 live;
+bisect by deleting/disabling the suspect formula field, which is reversible).
+`omc` now answers `runtime-write-db-exception` and lists the model's formula
+fields; the fix is to aggregate a MAIN-table scalar column instead.
+
 ## 4. Readback mismatch — the write landed but does not match
 
 `*-readback-failed`, `*-readback-mismatch`, `cleanup-absence-readback`,

package/skills/omc-write-hazards.md

@@ -97,6 +97,16 @@ omc call field.publish --env local --args '{"schemaCode":"expense"}'
 
 - **同一 `<env>` 的写调用必须串行发起**：`write-lock-held` 不只在"并行重放失败请求"时出现，也会在**并行发起两个无关写**时触发（实测：并行两条 `dictionary.save`、并行 `field.update`+`field.publish` 各失败一次）。读可并行，写不要。
 
+## 审批提交的真实形状（r18b 2026-10-26 真机，1.1.25）
+
+| 参数 | 位置 | 语义 |
+|---|---|---|
+| `agree` | **顶层** | true=通过 / false=驳回；**缺省=true**（驳回后实例仍 PROCESSING，别当成功） |
+| `approval.content` / `relUsers` / `resources` | approval 对象 | 意见 / 下一步审批人 / 附件 |
+| `approval.agree`、`approval.opinion` | — | **静默忽略**（真机：agree:false 仍 APPROVE 且走完流程；opinion 不落库）。OMC 已写前拒绝 |
+
+链：`data.save`(draft→workItemId) → `data.submit`(顶层 agree) → 下一级待办。验收看 `sequenceStatus`。
+
 ## 计算规则（datarule）的取值时机
 
 - **字段计算规则（`datarule.create` `dataRuleType:2`）在 REST 路径上不会执行、也不会回填**（r17 2026-10-25 复核，AI-Platform 1.1.25）：
@@ -112,6 +122,13 @@ omc call field.publish --env local --args '{"schemaCode":"expense"}'
   **回算可靠性（重要）**：① 目标行**自己 submit** 时镜像规则一定算（最可靠）；② 来源行 submit/update/delete 的事件回算**只在目标模型发布后几分钟内可靠**，之后静默停止（无报错，源变了目标不更新）——重新 `field.publish --force` 目标模型恢复。验收：发布后立刻改来源行并读目标字段；长期对账别依赖事件回算。
 - **同模型（含自己的子表）聚合不可用**：`field.publish` 必抛 305003 —— `publishFormula` 把相对码改写成子表父模型（= 本模型），
   `checkCycleOfAggregation:1032` 判成环。与 payload 无关，8.6.26 与 1.1.25 代码相同。OMC 已写前拒绝 `aggregation-self-schema-cycle`。
+- **聚合必须指向来源主表的标量列**（r18/r18b 真机）：`schemaCode` 指向**子表 schema** 能发布，但目标模型从此整个不可写
+  （写入一律 `40000`，无明细），且子表无父单单号列、匹配恒 0；`dataItemCode` 写 `<子表>.<子列>` 则 publish 回 309004。
+  要子表合计：先在来源主表物化一个数值字段，再聚合该标量。写前拒绝：`aggregation-target-is-child-schema` / `aggregation-data-item-not-scalar`。
+- **`40000` 无明细时**先怀疑字段级配置（上面的聚合、公式序列化），用「删/禁一个公式字段再写一次」二分，别从表单/权限查。
+  OMC 会转成 `runtime-write-db-exception` 并列出该模型的公式字段。
+- **`LARGE/SMALL` 必须带 k**：`LARGE({来源.列},2)`（缺 k → NumberFormatException → 写入 50000）；
+  **`UNION` 是文本拼接**，顶层 `resultType` 必须 0/1（写 2 会 50000）。拒绝：`aggregation-large-missing-k` / `aggregation-union-result-type`。
 - **区别：`FORMULA`（计算公式，`propertyType:100`）字段的 EXPRESSION 模式仍只在前端算** —— API 写入不回填。
 
 ## 规则与业务集成