@stalfh233/omc-cli 0.6.23 → 0.6.25

package/coverage/m1-coverage-manifest-v1.json

@@ -1449,6 +1449,30 @@
         "custom page body publish (custom/page/content/publish)",
         "custom page delete (custom/delete)"
       ]
+    },
+    {
+      "capability": "rule execution log search (trigger rows, optional node chains)",
+      "status": "executable",
+      "scope": "POST /api/api/launcher/domain_service_runtime/{schemaCode}/search_rule_log paged rule-execution-log search (triggerTime desc) with client-side bizObjectId row matching over inputSummaries (bounded 5-page scan) and optional query_rule_activity_log node chains for the first 3 hits; honest notes for ~5s async flush, retention cleanup, and CODING-mode absence.",
+      "version_family": "8.6",
+      "anchor_version": "8.6.26",
+      "evidence": [
+        {
+          "path": ".scratch/r43-forensic/FORENSIC-rulelog.md",
+          "anchor": "r43 源码+真机双证（DomainServiceController/RuleLogSearchAssembler/RuleLogManagerImpl + seal_apply 历史日志 + r43x 自建触发）"
+        },
+        {
+          "path": "packages/omc-cli/test/rulelog.test.ts",
+          "anchor": "contract tests"
+        }
+      ],
+      "lane": "B1-businessrule",
+      "tools": [
+        "rulelog.search"
+      ],
+      "scopes": [
+        "rule execution log search (trigger-time desc, row match client-side)"
+      ]
     }
   ]
 }

package/dist/capability-overview.js

@@ -238,8 +238,10 @@ export const CAPABILITY_CUES = Object.freeze({
         "不早于", "不能早于", "不晚于", "不能晚于", "早于今天", "晚于今天", "日期校验", "提交校验", "校验不通过", "必填校验", "正则校验", "重复校验", "长度校验"],
     // NOTE: bare "自动" was a cue (round 10 bug: "自动识别"/"自动发邮件" matched
     // businessrule and routed an UNSUPPORTED ask onto the write ladder). A business
-    // rule is named by 业务规则/触发器/规则图, not by "automatic".
-    businessrule: ["业务规则", "触发器", "规则图", "校验", "事件", "按钮", "定时任务", "定时触发", "定时器", "每天", "每日", "周期执行", "调度", "SCHEDULER", "TIMING_TASK"],
+    // rule is named by 业务规则/触发器/规则图, not by "automatic". r44fc（2026-11-08）
+    // 重犯过一次（round10 测试当场抓住）——复合词（累加/联动/审计/规则触发/自动累加）才是
+    // 规则面线索，裸「自动」永远不是。
+    businessrule: ["业务规则", "触发器", "规则图", "校验", "事件", "按钮", "定时任务", "定时触发", "定时器", "每天", "每日", "周期执行", "调度", "SCHEDULER", "TIMING_TASK", "累加", "联动", "审计", "规则触发", "自动累加", "自动回写"],
     "rule-lifecycle": ["启用规则", "停用规则", "删除规则", "规则启停", "触发规则", "执行规则", "跑规则", "按钮规则", "规则验收"],
     // r28h F1/F7: narrow org cues so "管理组织：部门/角色/角色组/用户/权限范围"
     // hits workflow (where org.* lives) instead of field→workflow. Keep them

package/dist/cli.js

@@ -2225,7 +2225,7 @@ async function main() {
         commandExitCode = CLI_EXIT_CODES.ok;
     });
     command.command("doctor").option("--environment <environment>").option("--env <environment>").option("--service <serviceCode>", "可选：体检单个业务集成服务的鉴权参数形状（掩码/占位/全 0 检出，WARN 非致命）").action(async (options) => { commandExitCode = await cmdDoctor(new ConfigStore(defaultPaths()), options.environment ?? options.env, options.service); });
-    command.command("call <tool>").option("--env <environment>", "环境名；项目白名单按当前 cwd 解析，须在含 .omc-env 的目录内运行").option("--environment <environment>").option("--args <json>").option("--args-file <path>", "从文件读参数 JSON。**必须位于配置根内**（数组批量请改用 --args-list；跨目录/系统临时文件会被拒）；免落盘用 `--args -`（stdin）").option("--args-list <json-array>", '同一工具跑 N 次（JSON 数组，每条一个 args 对象，最多 200 条）；超过上限请分批，或用 omc script 读文件。逐条执行、默认不中断，最后回 succeeded/failed 汇总。适合批量建字段等').option("--preflight", "与 --args-list 一起用：只跑参数校验 + 写前语义闸（零 wire、零写入），一次报全所有形状问题").option("--keys", "与 artifact get 的 --keys 同义（= --extract-keys）：列出本次结果 artifact 的顶层键与体积").addOption(new Option("--extract <path>", "在本次结果的 artifact 内取一个路径的值（可重复；省掉一次 artifact get）").argParser((value, previous = []) => [...previous, value]).default([])).addOption(new Option("--jq [path]", "同 --extract，并支持 [] 映射（如 items[].fields.planNo）；裸 --jq 列出结果的顶层键").argParser((value, previous = []) => [...previous, value]).default([])).option("--extract-keys", "列出本次结果 artifact 的顶层键与体积（省掉一次 artifact get --keys）").option("--max-output-bytes <bytes>", "最终 stdout 信封预算；默认 65536（投影/--jq 之后再判）；读面 diet(~2048) 独立外置 detailArtifactId，抬高本参数不会把已 diet 的大表重新内联；artifact get 内联上限 8192").option("--request-id <requestId>").option("--timeout-ms <milliseconds>").option("--wait <milliseconds>").option("--dry-run").addHelpText("after", `\n${onboardingHelp()}\n`).action(async (tool, options) => {
+    command.command("call <tool>").option("--env <environment>", "环境名；项目白名单按当前 cwd 解析，须在含 .omc-env 的目录内运行").option("--environment <environment>").option("--args <json>").option("--args-file <path>", "从文件读参数 JSON。**必须位于配置根内**（数组批量请改用 --args-list；跨目录/系统临时文件会被拒）；免落盘用 `--args -`（stdin）").option("--args-list <json-array>", '同一工具跑 N 次（JSON 数组，每条一个 args 对象，最多 200 条）；超过上限请分批，或用 omc script 读文件。逐条执行、默认不中断，最后回 succeeded/failed 汇总。适合批量建字段等').option("--preflight", "与 --args-list 一起用：只跑参数校验 + 写前语义闸（零 wire、零写入），一次报全所有形状问题").option("--keys", "与 artifact get 的 --keys 同义（= --extract-keys）：列出本次结果 artifact 的顶层键与体积").addOption(new Option("--extract <path>", "在本次结果的 artifact 内取一个路径的值（可重复；省掉一次 artifact get）").argParser((value, previous = []) => [...previous, value]).default([])).addOption(new Option("--jq [path]", "同 --extract，并支持 [] 映射（如 items[].fields.planNo）；裸 --jq 列出结果的顶层键").argParser((value, previous = []) => [...previous, value]).default([])).option("--extract-keys", "列出本次结果 artifact 的顶层键与体积（省掉一次 artifact get --keys）").option("--max-output-bytes <bytes>", "最终 stdout 信封预算；默认 65536（投影/--jq 之后再判）；读面 diet(~2048) 独立外置 detailArtifactId，抬高本参数不会把已 diet 的大表重新内联；artifact get 内联上限 8192").option("--request-id <requestId>").option("--timeout-ms <milliseconds>").option("--wait <milliseconds>", "仅 `omc call` / `omc intent apply` 支持；写锁冲突时有界排队（0=立刻拒绝）").option("--dry-run").addHelpText("after", `\n${onboardingHelp()}\n`).action(async (tool, options) => {
         const rest = [tool, ...(options.env ? ["--env", options.env] : []), ...(options.environment ? ["--environment", options.environment] : []), ...(options.args !== undefined ? ["--args", options.args] : []), ...(options.argsFile !== undefined ? ["--args-file", options.argsFile] : []), ...(options.argsList !== undefined ? ["--args-list", options.argsList] : []), ...(options.preflight ? ["--preflight"] : []), ...(Array.isArray(options.extract) ? options.extract.flatMap((path) => ["--extract", path]) : []), ...(Array.isArray(options.jq) ? options.jq.flatMap((path) => path === true ? ["--jq"] : ["--jq", path]) : []), ...(options.extractKeys ? ["--extract-keys"] : []),
             ...(options.keys ? ["--keys"] : []), ...(options.maxOutputBytes !== undefined ? ["--max-output-bytes", options.maxOutputBytes] : []), ...(options.requestId ? ["--request-id", options.requestId] : []), ...(options.timeoutMs !== undefined ? ["--timeout-ms", options.timeoutMs] : []), ...(options.wait !== undefined ? ["--wait", options.wait] : []), ...(options.dryRun ? ["--dry-run"] : [])];
         commandExitCode = await cmdCall(new ConfigStore(defaultPaths()), rest);
@@ -2254,7 +2254,7 @@ async function main() {
         .option("--env <environment>")
         .option("--environment <environment>")
         .option("--apply")
-        .addHelpText("after", "\n一条命令按依赖倒序清掉一个模型：列表视图 → 业务规则 → 计算规则 → 流程实例 → 流程 → 模型（字段/表单随模型级联）。默认 dry-run。\n业务数据：--purge-instances 删流程实例；普通业务行（无流程）不会自动带走——先 data.delete 清（sweep-all-readback 配方），再 purge，否则留孤儿数据。\n")
+        .addHelpText("after", "\n一条命令按依赖倒序清掉一个模型：列表视图 → 业务规则 → 计算规则 → 流程实例 → 流程 → 模型（字段/表单随模型级联，并级联删除流程模板 <code>_wf 及其发起权限绑定）。默认 dry-run。\n业务数据：--purge-instances 删流程实例；普通业务行（无流程）不会自动带走——先 data.delete 清（sweep-all-readback 配方），再 purge，否则留孤儿数据。\n")
         .action(async (options) => {
         const rest = ["model-purge",
             ...(options.code ? ["--code", options.code] : []),
@@ -2371,6 +2371,7 @@ async function main() {
         .option("--name <name>", "模型名")
         .option("--fields <json>", "JSON 数组，每条是一个 field.create 参数；子表加 subFields")
         .option("--fields-json <json>")
+        .option("--fields-file <path>", "从配置根内文件读字段 JSON 数组；与 --fields 互斥")
         .option("--folder <folderId>", "建在哪个应用目录（省略=默认目录）")
         .option("--app <applicationCode>")
         .option("--env <environment>")
@@ -2396,6 +2397,7 @@ async function main() {
             ...(options.name ? ["--name", options.name] : []),
             ...(options.fields !== undefined ? ["--fields", options.fields] : []),
             ...(options.fieldsJson !== undefined ? ["--fields-json", options.fieldsJson] : []),
+            ...(options.fieldsFile !== undefined ? ["--fields-file", options.fieldsFile] : []),
             ...(options.folder ? ["--folder", options.folder] : []),
             ...(options.app ? ["--app", options.app] : []),
             ...(options.env ? ["--env", options.env] : []),
@@ -2530,7 +2532,7 @@ async function main() {
             pureKeys: (options.keys === true || bareJq) && options.summary !== true, ...(typeof options.keys === "string" ? { keys: options.keys } : {}), full: options.full === true }));
     });
     command.command("bench").option("--live-sample").option("--env <environment>").action(async (options) => { commandExitCode = await cmdBench([...(options.liveSample ? ["--live-sample"] : []), ...(options.env ? ["--env", options.env] : [])]); });
-    command.command("residue <prefix>").description("跨面前缀残留扫描（model 全租户/folder/custompage；默认 deep 再查命中模型的 rule/datarule/onlinejs）——收尾「删净」一次证明，clean:true 即零残留。清理入口：omc model-purge --code <schemaCode>（按依赖倒序，默认 dry-run）。只读零写入；report 面暂停维护未扫描").option("--env <environment>", "环境名（默认按 cwd 的 .omc-env 解析）").option("--apps <codes>", "all（默认，全租户）或逗号分隔应用码").option("--no-deep", "只扫 model/folder/custompage，不深查命中模型").option("--max-output-bytes <bytes>").action(async (prefix, options) => { commandExitCode = await withTransport(options, request, (transport) => cmdResidue(prefix, { env: options.env, apps: options.apps, ...(options.deep === false ? { noDeep: true } : {}) }, transport)); });
+    command.command("residue <prefix>").description("跨面前缀残留扫描（model 全租户/folder/custompage；默认 deep 再查命中模型的 rule/datarule/onlinejs）——收尾「删净」一次证明，clean:true 即零残留。清理入口：omc model-purge --code <schemaCode>（按依赖倒序，默认 dry-run）。只读零写入；report 面暂停维护未扫描").option("--env <environment>", "环境名（默认按 cwd 的 .omc-env 解析）").option("--apps <codes>", "all（默认，全租户）或逗号分隔应用码").option("--no-deep", "只扫 model/folder/custompage，不深查命中模型").option("--all-faces", "列出全部应用×面（含 count:0；默认只回非零面+byFace/userResidues 紧凑形）").option("--max-output-bytes <bytes>").action(async (prefix, options) => { commandExitCode = await withTransport(options, request, (transport) => cmdResidue(prefix, { env: options.env, apps: options.apps, ...(options.deep === false ? { noDeep: true } : {}), ...(options.allFaces ? { allFaces: true } : {}) }, transport)); });
     const jqOption = () => new Option("--jq [path]", "路径投影（与 call --jq 同 DSL；可逗号多路径；裸 --jq 列顶层键）").argParser((value, previous = []) => [...previous, value]).default([]);
     command.command("commands").option("--json").option("--compact").option("--filter <keyword>").option("--lane <id>").option("--max-output-bytes <bytes>").addOption(jqOption()).action(async (options) => { commandExitCode = await withTransport(options, request, (transport) => cmdDiscovery("commands", transport, undefined, { json: options.json === true, compact: options.compact === true, ...(options.filter ? { filter: options.filter } : {}), ...(options.lane ? { lane: options.lane } : {}), ...(options.jq !== undefined ? { jq: options.jq } : {}) })); });
     command.command("describe <tool>").option("--full").option("--cache-ok", "允许 --full 在同会话重复读时短路为 artifact 指针（默认每次回全文）").option("--schema-only").option("--param <name>").option("--example [id]").option("--max-output-bytes <bytes>").addOption(jqOption()).action(async (tool, options) => {

package/dist/endpoints.js

@@ -108,6 +108,8 @@ export const ENDPOINTS = {
      * reacquireDataFromDb:false), so effects must be read back separately.
      */
     ruleRuntimeExecuteBase: "/api/api/launcher/domain_service_runtime",
+    ruleLogSearch: "/api/api/launcher/domain_service_runtime/{schemaCode}/search_rule_log",
+    ruleActivityLog: "/api/api/launcher/domain_service_runtime/{schemaCode}/query_rule_activity_log",
     /**
      * Form-toolbar button execution — a DIFFERENT face from the list-button one.
      * Live 2026-10-23 (1.1.25, Playwright capture of a `triggerType=FORM` button

package/dist/field-families.js

@@ -625,6 +625,8 @@ export function normalizeMappingsOption(options) {
                 const target = record.target;
                 if (typeof source !== "string" || source.trim() === "" || typeof target !== "string" || target.trim() === "")
                     mappingsError("每项的 source/target 必须是非空字符串");
+                if (source.includes(".") || target.includes("."))
+                    mappingsError("source/target 应为目标模型字段 code，不带模型前缀（不要使用 模型.字段）");
                 return { source: source.trim(), target: target.trim() };
             });
             normalized = JSON.stringify(rows);
@@ -644,6 +646,8 @@ export function normalizeMappingsOption(options) {
             }
             if (!Array.isArray(parsed) || parsed.some((row) => row === null || typeof row !== "object" || Array.isArray(row) || typeof row.source !== "string" || typeof row.target !== "string" || row.source === "" || row.target === ""))
                 mappingsError("解析结果必须是 [{source,target}] 形状（source/target 非空字符串）");
+            if (parsed.some((row) => String(row.source).includes(".") || String(row.target).includes(".")))
+                mappingsError("source/target 应为目标模型字段 code，不带模型前缀（不要使用 模型.字段）");
             normalized = JSON.stringify(parsed.map(({ source, target }) => ({ source: source.trim(), target: target.trim() })));
         }
     }

package/dist/form-support.js

@@ -1338,6 +1338,7 @@ export async function executeFormDraftWrite(session, args) {
         attributes = undefined;
     }
     let rebuildPreservedControls = [];
+    let controlsUpdated = 0;
     if (typeof view !== "string" || typeof attributes !== "string") {
         // Ticket 48: an explicit fieldCodes selection picks (and orders) the
         // scaffolded business fields; omitted scaffolds every published field.
@@ -1364,6 +1365,7 @@ export async function executeFormDraftWrite(session, args) {
         attributes = JSON.stringify(scaffold.attributes);
     }
     if (args.draftAttributesJson === undefined && typeof attributes === "string") {
+        const beforeDerived = attributes;
         attributes = propagateRelationMappings(attributes, publishedFields);
         // Ticket 69: repair/densify org-selection controls on the existing draft.
         attributes = normalizeOrgSelectorControls(attributes, publishedFields);
@@ -1374,6 +1376,16 @@ export async function executeFormDraftWrite(session, args) {
         // control even when the form already existed — a non-rebuild draft keeps
         // controls verbatim, so a later field.update never propagated (bench20).
         attributes = syncFieldDerivedControlOptions(attributes, publishedFields);
+        if (args.refreshFromFields === true && attributes !== beforeDerived) {
+            try {
+                const before = JSON.parse(beforeDerived);
+                const after = JSON.parse(attributes);
+                controlsUpdated = Object.keys(after).filter((code) => JSON.stringify(before[code]) !== JSON.stringify(after[code])).length;
+            }
+            catch {
+                controlsUpdated = 0;
+            }
+        }
     }
     // Fail-closed: a rebuild that would drop a designer formula must never reach
     // the wire. The merge above normally carries them, but it cannot when the
@@ -1428,6 +1440,7 @@ export async function executeFormDraftWrite(session, args) {
                 }
                 : {}),
             ...(args.rebuild === true && previousAttributes ? { rebuildPreservedControls } : {}),
+            ...(args.refreshFromFields === true ? { refreshFromFields: true, controlsUpdated } : {}),
             // r36（2026-11-01）：rebuild 后草稿与重建前逐字节一致时明示——rebuild 的
             // 语义就是"按已发布字段重搭"，一致通常意味着预期的新控件没进来（字段未
             // 发布/写错槽位），静默 no-op 会让"新增字段后刷新表单"看起来成功实则没变。

package/dist/goal-routes.js

@@ -973,7 +973,7 @@ export function goalRoute(registry, goal) {
             goal,
             confident: true,
             mode: whole ? "whole-package" : mode,
-            match: { kind: readish ? "read-ladder" : "ladder", ref: ordered.join("→"), capabilities: ordered },
+            match: { kind: readish ? "read-ladder" : "ladder", ref: `${ordered.join("→")}${ordered.includes("businessrule") && /累加|联动|审计|规则触发|自动累加|自动回写/.test(goal) ? "（规则面不在本阶梯）" : ""}`, capabilities: ordered },
             route: {
                 ...(whole ? { primary: "intent", atomicSupplement } : { ladder }),
                 // r28e F2（真机复现 2026-11-05）：`next "建表单布局、在线JS、表单按钮"`
@@ -1059,7 +1059,7 @@ export function goalRoute(registry, goal) {
         mode: whole ? "whole-package" : mode,
         match: {
             kind: readish ? "read-capability" : recipe ? "recipe" : "capability",
-            ref: recipe ? recipe.recipe : capabilityId,
+            ref: recipe ? recipe.recipe : `${capabilityId}${capabilityId === "businessrule" && /累加|联动|审计|规则触发|自动累加|自动回写/.test(goal) ? "（规则面不在本阶梯）" : ""}`,
             title: firstSentence(recipe ? recipe.title : route.title),
             capability: capabilityId,
             ...(recipe ? { tool: recipe.tool, recipe: recipe.recipe } : {}),

package/dist/lanes/businessrule-contract.js

@@ -72,6 +72,7 @@ const RULE_SAVE_DESCRIPTION = describeTool("保存业务规则（upsert）：`ru
     "**条件执行**：① 单分支→动作节点自身 `filterCondition`（UPDATE/DELETE/ASSIGN 的 `mainConditions`：身份匹配 DYNAMIC + 固定条件 FIXED，同叶组 AND）。② 多路分支→`BRANCH` 节点：出口叶（DataFilterCondition）键为 `{currentSchemaDataItem(左值),ruleDataConditionType(操作符),ruleValueType,value}`，出路由 `routeCondition:true` 走条件、`false` 兜底 else。**别照抄其它条件组的 targetSchemaDataItem+ruleConditionType——未知键 save+publish 过但运行时 50000（lint fail closed `rule-graph-branch-condition-keys`）**。按数据走流程流转用 `ruleConditionGroup`。",
     "**生命周期铁律（2026-09-11 live 取证）**：update 只写 DRAFT 工作行，get/list 读 PUBLISH 面因此看不到变化——必须再 `rule.enable`（publish 出新版本 + 翻 DRAFT 启用开关）才会生效；数据事件分发：DRAFT 保存不触发，submit（DRAFT→COMPLETED）触发 Create。保存 ≠ 设计器可见：readback 的 `published:false` + nextAction 标明尚未发布；传 `publish:true` 可在同一次调用内发布新版本（仅发布，启用仍走 `rule.enable`）。",
     "**BizMethod 绑定（ticket 35/96）**：BIZ_ACTION / GET_LIST(BIZ_SERVICE) 的 methodMapping 须逐键对 8.6.26 DTO（codeType int 0=CONST/1=PROPERTY…；非语义键原样透传）；写前 wire 校验服务+方法真实存在（get_by_code + list_by_service_code），悬空即 refused `rule-graph-bizmethod-unresolved`——平台只拦服务不拦方法，绝不用注册壳冒充已发布 BizMethod；RESTFUL/DATA_SQL 方法必须带适配器必需 configJson 键，只有名字/参数面的注册壳 refused `rule-graph-bizmethod-registration-shell`；映射 `required` 以方法参数面为权威镜像（省略→按面填入，面缺席→保持缺席，显式矛盾→本地拒绝零写入）。",
+    "**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）。",
 ]);

package/dist/lanes/businessrule-coverage.js

@@ -1,5 +1,6 @@
 import { claim, declareLaneCoverage } from "./coverage-declaration.js";
 import { BUSINESSRULE_LANE_CONTRACT } from "./businessrule-contract.js";
+import { RULELOG_LANE_CONTRACT } from "./rulelog-contract.js";
 const T = BUSINESSRULE_LANE_CONTRACT.tools;
 export const BUSINESSRULE_COVERAGE = declareLaneCoverage(BUSINESSRULE_LANE_CONTRACT.lane, [
     {
@@ -12,5 +13,12 @@ export const BUSINESSRULE_COVERAGE = declareLaneCoverage(BUSINESSRULE_LANE_CONTR
         evidence: ["packages/omc-cli/src/tools.ts", "packages/omc-cli/test/rule-list.test.ts"],
         tools: [claim("rule.list", T["rule.list"].scope), claim("rule.get", T["rule.get"].scope), claim("rule.references", T["rule.references"].scope)],
     },
+    {
+        // r43a（2026-11-08）：规则执行日志只读面。证据=运行版 v1.1.25 反编译（DomainServiceController/
+        // RuleLogSearchAssembler/RuleLogManagerImpl）+ 真机双证（seal_apply 历史日志 + r43x 自建触发）。
+        capability: "rule execution log search (trigger rows, optional node chains)",
+        evidence: [".scratch/r43-forensic/FORENSIC-rulelog.md", "packages/omc-cli/test/rulelog.test.ts"],
+        tools: [claim("rulelog.search", RULELOG_LANE_CONTRACT.tools["rulelog.search"].scope)],
+    },
 ]);
 //# sourceMappingURL=businessrule-coverage.js.map

package/dist/lanes/datarule.js

@@ -745,14 +745,17 @@ const FORM_CONDITION_RULE_TYPES = Object.freeze({
 export async function syncFormConditionDataRules(session, schemaCode, fieldCode, prevOptions, nextOptions) {
     const result = { created: [], updated: [], deleted: [], skipped: [] };
     const text = (options, key) => (typeof options[key] === "string" ? options[key].trim() : "");
-    const changedKeys = Object.keys(FORM_CONDITION_RULE_TYPES).filter((key) => text(prevOptions, key) !== text(nextOptions, key));
-    if (changedKeys.length === 0)
-        return result;
     const existing = await listDataRules(session, schemaCode);
     // The designer's rule rows live on the PUBLISHED face (like datarule.create's
     // own guard); a draft-only field cannot carry a designer-visible row yet.
     const publishedCodes = await readPublishedFieldCodesOrNull(session, schemaCode);
     const published = publishedCodes === null ? true : publishedCodes.has(fieldCode);
+    const changedKeys = Object.keys(FORM_CONDITION_RULE_TYPES).filter((key) => {
+        const changed = text(prevOptions, key) !== text(nextOptions, key);
+        const desired = text(nextOptions, key);
+        const present = existing.some((row) => Number(row.dataRuleType) === FORM_CONDITION_RULE_TYPES[key] && storedTargetCodes(row).includes(fieldCode));
+        return changed || (desired.length > 0 && !present);
+    });
     for (const key of changedKeys) {
         const dataRuleType = FORM_CONDITION_RULE_TYPES[key];
         const next = text(nextOptions, key);

package/dist/lanes/field.js

@@ -266,7 +266,7 @@ export function registerFieldLane(tools) {
                     // 不带这个键，于是不会出现；write-only 的确认走 field.update 的
                     // readback.committed。
                     ...(Object.prototype.hasOwnProperty.call(row, "propertyEmpty") ? { propertyEmpty: row.propertyEmpty } : {}),
-                    ...(options !== undefined ? { options } : {}),
+                    ...(options !== undefined ? { options, optionsPresent: true } : { optionsPresent: false }),
                     ...(scaleWarning !== undefined ? { shapeWarning: scaleWarning, ...(system ? { origin: "system" } : {}) } : {}),
                     ...(system && scaleWarning === undefined ? { origin: "system" } : {}),
                 };
@@ -292,7 +292,7 @@ export function registerFieldLane(tools) {
             const projected = detailed
                 ? visible
                 : visible.map((field) => {
-                    const options = (field.options ?? {});
+                    const options = ("options" in field ? field.options : undefined) ?? {};
                     const conditions = Object.keys(FORM_CONDITION_OPTION_KEYS).filter((key) => {
                         const value = options[key];
                         return key === "readonlyFormula" ? value === true : typeof value === "string" && value.trim() !== "";
@@ -314,6 +314,7 @@ 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 } : {}),
                     };
                 });
             return {
@@ -1117,6 +1118,19 @@ async function runFieldUpdate(session, args) {
     if (args.choices !== undefined && !same(choiceCodesOf(currentOptions) ?? [], [...args.choices]))
         requestedChanges.push("choices");
     if (requestedChanges.length === 0) {
+        let unchangedSync;
+        let unchangedSyncError;
+        const conditionKeys = new Set(Object.keys(FORM_CONDITION_OPTION_KEYS));
+        if (effectiveOptions !== undefined && [...conditionKeys].some((key) => typeof prepared.options[key] === "string" && String(prepared.options[key]).trim() !== "")) {
+            try {
+                const sync = await syncFormConditionDataRules(session, args.schemaCode, args.code, currentOptions, prepared.options);
+                if (sync.created.length + sync.updated.length + sync.deleted.length + sync.skipped.length > 0)
+                    unchangedSync = sync;
+            }
+            catch (error) {
+                unchangedSyncError = error instanceof Error ? error.message : String(error);
+            }
+        }
         return {
             performed: { errcode: 0, unchanged: true },
             readback: {
@@ -1126,6 +1140,7 @@ async function runFieldUpdate(session, args) {
                 ...(record.name !== undefined ? { name: record.name } : {}),
                 ...(record.name_i18n !== undefined ? { name_i18n: record.name_i18n } : {}),
                 availableFields: ["name", "name_i18n", "options", "choices", "relativeCode", "propertyEmpty"],
+                ...(unchangedSync !== undefined ? { formConditionSync: unchangedSync } : unchangedSyncError !== undefined ? { formConditionSync: { error: unchangedSyncError } } : {}),
             },
         };
     }

package/dist/lanes/form.js

@@ -296,6 +296,7 @@ export function registerFormLane(tools) {
                 .optional()
                 .describe("把子表列绑进**已有** Sheet201 控件的 columns（issue #24）：[{parent:\"items\",fieldCodes:[\"category\"]}]。只追加列，不动其它控件/布局行；无已存布局时退回 scaffold"),
             rebuild: z.boolean().optional().describe("true 时丢弃现有草稿布局，按已发布字段重新生成（新增字段/子表要用它；默认保留现有草稿）"),
+            refreshFromFields: z.boolean().optional().describe("true 时不重建布局，仅按当前已发布字段 options 刷新现有控件派生配置"),
             fromReadback: z.boolean().optional().describe("true = 本次 draftViewJson/draftAttributesJson 来自 form.get 的**逐字未改动**原文（平台自身布局可能含子表列行/系统行超宽，逐字回写放行）。语义是「回写」不是「我读过」：读过之后改过一个字符就不再是回读，会被拒（去掉本参数按普通写面校验）。只加子表列请用 configure_form 的 childColumns"),
             allowEmptyLayout: z.boolean().optional().describe("显式放行空布局（\"[]\"/\"{}\"）写入；默认拒绝（form-empty-layout），防设计器 Save 清空后照写丢控件"),
             buttons: z

package/dist/lanes/list-view.js

@@ -457,7 +457,22 @@ export function registerListViewLane(tools) {
         description: LIST_VIEW_TOOLS["listview.list"].description,
         inputSchema: { environment: environmentArg, schemaCode: z.string().min(1), capability: capabilityArg },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
-            const rows = wireRows((await wireCall(session, { path: ENDPOINTS.listQueryList, query: { schemaCode: args.schemaCode, clientType: "PC" } })).data);
+            let rows;
+            try {
+                rows = wireRows((await wireCall(session, { path: ENDPOINTS.listQueryList, query: { schemaCode: args.schemaCode, clientType: "PC" } })).data);
+            }
+            catch (error) {
+                if (error instanceof WireError && error.errcode === 50000) {
+                    try {
+                        await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "true" } });
+                    }
+                    catch (probe) {
+                        if (probe instanceof WireError && probe.errcode === 300004)
+                            return { absent: true, schemaCode: args.schemaCode };
+                    }
+                }
+                throw error;
+            }
             return {
                 schemaCode: args.schemaCode,
                 count: rows.length,

package/dist/lanes/model.js

@@ -419,7 +419,14 @@ export function registerModelLane(tools) {
                         // 产物缺失/损坏时保持空摘要——不因解引用失败拖垮整个 inspect
                     }
                 }
-                const datarules = dataruleRows.map((rule) => ({ propertyCode: rule.propertyCode, propertyCodes: rule.propertyCodes, dataRuleType: rule.dataRuleType, name: rule.name, checkType: rule.checkType }));
+                const datarules = dataruleRows.map((rule) => {
+                    const hasCondition = ["condition", "conditions", "conditionJson", "ruleCondition", "formula"].some((key) => {
+                        const value = rule[key];
+                        return value !== undefined && value !== null && value !== "" && !(Array.isArray(value) && value.length === 0);
+                    });
+                    const auto = rule.name == null && Number(rule.checkType) === 4 && !hasCondition;
+                    return { propertyCode: rule.propertyCode, propertyCodes: rule.propertyCodes, dataRuleType: rule.dataRuleType, name: rule.name, checkType: rule.checkType, origin: auto ? "auto" : "user" };
+                });
                 // Workflow summary: use the PUBLISHED face for the `published` flag. The
                 // draft face's templateType is ALWAYS "DRAFT" (even for a published
                 // workflow — draft and published are separate faces), so deriving
@@ -496,7 +503,10 @@ export function registerModelLane(tools) {
                         : {}),
                     form: result.form,
                     listview: result.listview ? { code: result.listview.code, columnCount: result.listview.columnCount } : undefined,
-                    ruleCodes: (result.rules ?? []).map((rule) => rule.code),
+                    ruleCodes: Array.isArray(result.rules) ? result.rules.map((rule) => rule.code) : [],
+                    ...(Array.isArray(result.rules) && result.rules.length > 0
+                        ? { rules: { truncated: true, totalRules: result.rules.length, nextCommand: `omc call rule.list --args {"schemaCode":"${String(result.schemaCode ?? "")}"}` } }
+                        : {}),
                     datarules: result.datarules,
                     // r35a-F2：workflow 摘要必须恒有 exists 布尔——compact 投影此前把它丢了，
                     // 真机（走 compact 的分支）于是永远读不到 exists（探针只能靠

package/dist/lanes/organization.js

@@ -1042,11 +1042,11 @@ export function registerOrganizationLane(tools) {
         name: "org.role.delete",
         lane: LANE,
         scope: SCOPES.roleDelete,
-        description: "删除角色（`GET organization/role/strike_out_role?ids=`）。平台**拒绝删除仍有成员的角色**（`-1 角色下已经包含用户数据！`，实测 1.1.25）：默认先读成员数、非空即拒绝并给出人数；`force:true` 才会先逐人移出再删。**可用 roleCode 代替 roleId**（org.role.list 的码表只有 code）。",
+        description: "删除角色（`GET organization/role/strike_out_role?ids=`）。平台**拒绝删除仍有成员的角色**（`-1 角色下已经包含用户数据！`，实测 1.1.25）：默认先读成员并拒绝；拒绝回执带可直接粘贴的 `org.role.removeUsers` 命令。`force:true` 的语义是**先逐人移出全部成员，再删除角色**（不是强行绕过平台校验）。**可用 roleCode 代替 roleId**（org.role.list 的码表只有 code）。",
         inputSchema: {
             roleId: z.string().min(1).optional().describe("角色 id（32 位 hex）；与 roleCode 二选一"),
             roleCode: z.string().min(1).optional().describe("角色 code（org.role.list 的 roles 码表，如 qc_manager）或名称"),
-            force: z.boolean().optional().describe("true = 先移出全部成员再删角色"),
+            force: z.boolean().optional().describe("true = 先逐人调用 removeUsers 移出全部成员，再删角色；不会保留成员"),
         },
         execute: async (session, args) => {
             const roleId = await resolveRoleRef(session, { roleId: args.roleId, roleCode: args.roleCode }, "org.role.delete");
@@ -1054,7 +1054,7 @@ export function registerOrganizationLane(tools) {
             if (rows.length > 0 && args.force !== true)
                 throw new ToolRefusalError({
                     status: "refused", blocker: "role-has-members", roleId, members: rows.length,
-                    nextCommand: `omc call org.role.delete --args '${JSON.stringify({ roleId, force: true })}'`,
+                    nextCommand: `omc call org.role.removeUsers --args '${JSON.stringify({ roleId, ids: rows.map(roleUserId) })}'`,
                     message: `角色下还有 ${rows.length} 名成员，平台拒绝删除（errmsg：角色下已经包含用户数据）。先 org.role.removeUsers，或传 force:true 让工具移出后再删。`,
                 });
             if (rows.length > 0)

package/dist/lanes/rule-graph.js

@@ -1517,6 +1517,22 @@ export function validateRuleNodeGraph(graph, ruleCode, schemaCode, options = {})
             });
         }
     }
+    // F11 (r44): `_input` is the trigger input binding, not a writable model.
+    // QUERY may legitimately use inputParam:"_input"; only UPDATE targets are
+    // rejected here because the platform accepts/publishes them and then throws
+    // at runtime, rolling back the entire rule (including SYSTEM_CREATE).
+    for (const node of nodeRecords) {
+        if (String(node.nodeType ?? "") !== "UPDATE")
+            continue;
+        if (String(node.targetObjectCode ?? "").trim() !== "_input")
+            continue;
+        blockers.push({
+            code: "rule-graph-update-target-input",
+            nodeCode: String(node.nodeCode ?? ""),
+            key: "targetObjectCode",
+            message: 'UPDATE 的 targetObjectCode 不接受 `_input`（1.1.25 运行时 EXCEPTION 并回滚全规则）；自更新写本模型 schemaCode；QUERY 的 inputParam 用 `_input` 不受影响',
+        });
+    }
     // Cross-model write-back: SUPPORTED (verified live 2026-09-28). An UPDATE whose
     // `targetObjectCode` is a DIFFERENT model than the rule's own model writes back
     // correctly once TWO prerequisites hold — a 2026-09-27 probe that reported

package/dist/lanes/rulelog-contract.js

@@ -0,0 +1,15 @@
+import { assertLaneContract } from "./contract-support.js";
+import { CONTRACT_FAMILY, CONTRACT_REFERENCE_VERSION } from "./contract-support.js";
+import { LANES } from "./lane-ids.js";
+const description = "查询规则执行日志；支持时间/规则/状态筛选、按触发行 id 客户端匹配，以及前 3 条日志的节点链。日志异步约 5 秒落库，未见不等于未触发；历史按平台保留天数清理，CODING 在线开发规则不记日志。";
+export const RULELOG_LANE_CONTRACT = Object.freeze({
+    lane: LANES.businessrule,
+    family: CONTRACT_FAMILY,
+    referenceVersion: CONTRACT_REFERENCE_VERSION,
+    endpoints: Object.freeze({ search: "ruleLogSearch", activity: "ruleActivityLog" }),
+    wire: Object.freeze({ page: 0, size: 20, triggerRows: "inputSummaries[].id", nodeId: "平台 VO 不提供 targetBizObjectId" }),
+    evidence: ["TASK-r43a.md §一"],
+    tools: Object.freeze({ "rulelog.search": Object.freeze({ scope: "rule execution log search (trigger-time desc, row match client-side)", description }) }),
+});
+export function assertRuleLogContract() { assertLaneContract(RULELOG_LANE_CONTRACT); }
+//# sourceMappingURL=rulelog-contract.js.map

package/dist/lanes/rulelog.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { ENDPOINTS } from "../endpoints.js";
+import { capabilityArg, environmentArg } from "../args.js";
+import { governedRead } from "../read.js";
+import { defineTool } from "../tool-types.js";
+import { wireCall } from "../wire.js";
+import { RULELOG_LANE_CONTRACT } from "./rulelog-contract.js";
+const path = (template, schemaCode) => template.replace("{schemaCode}", encodeURIComponent(schemaCode));
+const notes = ["日志异步落库约 5 秒，未见不等于未触发", "成功/失败日志按平台配置天数清理，历史有限", "CODING 模式在线开发 Java 规则不记日志"];
+export function registerRuleLogLane(tools) {
+    tools.push(defineTool({
+        name: "rulelog.search", layer: "low", kind: "read", lane: RULELOG_LANE_CONTRACT.lane,
+        scope: RULELOG_LANE_CONTRACT.tools["rulelog.search"].scope,
+        description: RULELOG_LANE_CONTRACT.tools["rulelog.search"].description,
+        inputSchema: {
+            environment: environmentArg, schemaCode: z.string().min(1), bizObjectId: z.string().min(1).optional(),
+            since: z.string().optional(), until: z.string().optional(), ruleCode: z.string().optional(), status: z.boolean().optional(),
+            includeNodes: z.boolean().optional(), page: z.number().int().min(0).optional(), size: z.number().int().min(1).max(50).optional(), capability: capabilityArg,
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            const requestedPage = args.page ?? 0, requestedSize = args.size ?? 20;
+            const fetch = async (page, size) => {
+                const body = { page, size };
+                for (const [key, value] of [["startTime", args.since], ["endTime", args.until], ["ruleCode", args.ruleCode], ["status", args.status]])
+                    if (value !== undefined)
+                        body[key] = value;
+                return (await wireCall(session, { path: path(ENDPOINTS.ruleLogSearch, args.schemaCode), method: "POST", body })).data;
+            };
+            let data;
+            let rows;
+            let rowFilter;
+            if (args.bizObjectId === undefined) {
+                data = await fetch(requestedPage, requestedSize);
+                rows = Array.isArray(data.content) ? data.content : [];
+            }
+            else {
+                rows = [];
+                let scannedElements = 0;
+                let scannedPages = 0;
+                let found = false;
+                for (let p = 0; p < 5; p += 1) {
+                    const candidate = await fetch(p, 20);
+                    scannedPages += 1;
+                    const pageRows = Array.isArray(candidate.content) ? candidate.content : [];
+                    scannedElements += pageRows.length;
+                    const hit = pageRows.filter((row) => Array.isArray(row.inputSummaries) && row.inputSummaries.some((v) => v && typeof v === "object" && v.id === args.bizObjectId));
+                    rows.push(...hit);
+                    if (hit.length) {
+                        found = true;
+                        break;
+                    }
+                }
+                data = { totalElements: rows.length, totalPages: scannedPages };
+                rowFilter = { bizObjectId: args.bizObjectId, matched: found, scannedPages, scannedElements };
+            }
+            const logs = await Promise.all(rows.map(async (row, index) => {
+                const log = { ruleCode: row.code, name: row.name, triggerType: row.triggerType, status: row.status, triggerTime: row.triggerTime, finishTime: row.finishTime, ...(row.errMsg ? { errMsg: row.errMsg } : {}), ruleVersion: row.ruleVersion, traceId: row.traceId, triggerRows: Array.isArray(row.inputSummaries) ? row.inputSummaries.map((v) => ({ id: v.id, name: v.name })) : [] };
+                if (args.includeNodes === true && index < 3) {
+                    const nodeData = (await wireCall(session, { path: path(ENDPOINTS.ruleActivityLog, args.schemaCode), method: "POST", body: { ruleLogId: row.id } })).data;
+                    log.nodes = Array.isArray(nodeData) ? nodeData.map((node) => ({ type: node.type, name: node.name, status: node.status, ...(node.targetSchemaCode ? { targetSchemaCode: node.targetSchemaCode } : {}), ...(node.errMsg ? { errMsg: node.errMsg } : {}) })) : [];
+                }
+                return log;
+            }));
+            return { index: { schemaCode: args.schemaCode, page: requestedPage, size: requestedSize, totalElements: data.totalElements ?? logs.length, totalPages: data.totalPages ?? 0, ...(rowFilter ? { rowFilter } : {}) }, logs, notes: ["status=true 表示成功，status=false 表示失败", ...notes, ...(args.includeNodes === true ? ["节点 VO 不提供 targetBizObjectId，节点行级 id 不可得；仅前 3 条命中日志拉取节点链"] : [])] };
+        }, { target: `rulelog.search:${args.schemaCode}:${JSON.stringify(args)}` }),
+    }));
+}
+//# sourceMappingURL=rulelog.js.map

package/dist/lanes/workflow.js

@@ -779,6 +779,55 @@ export function approvalByOriginatorWarnings(template) {
             message: `所有参与人节点（${activityCodes.join("、")}）都指向 {Originator}：该流程会由发起人自审自批；这是允许的单人流程，但请确认该行为符合业务意图。`,
         }];
 }
+/**
+ * The runtime deliberately treats an empty role resolution as a successful
+ * activation owned by the originator.  Keep this advisory: the originator
+ * may legitimately be a member of the configured role.  The platform's
+ * participant chain is `ouScope ∩ originator department chain`; when that
+ * intersection is empty it silently takes this fallback path.
+ */
+export function participantFallbackWarnings(input) {
+    if (!input.originator)
+        return [];
+    const configured = new Map();
+    const rows = Array.isArray(input.template?.activities) ? input.template.activities : [];
+    for (const row of rows) {
+        if (String(row.activityType ?? "") !== "PARTICIPANT")
+            continue;
+        const code = String(row.activityCode ?? row.code ?? "");
+        const participant = typeof row.participant === "string" ? row.participant.trim() : "";
+        if (!code || !participant || /^(?:\{Originator\}|Originator)$/i.test(participant))
+            continue;
+        let role;
+        const fn = /FindUserByRole\s*\(\s*[^,]+,\s*(["'])(.*?)\1\s*,/i.exec(participant);
+        if (fn?.[2])
+            role = fn[2];
+        if (!role && participant.startsWith("[")) {
+            try {
+                const entries = JSON.parse(participant);
+                if (Array.isArray(entries)) {
+                    const candidate = entries.find((entry) => entry && typeof entry === "object" && String(entry.type ?? "") === "2");
+                    if (candidate)
+                        role = String(candidate.code ?? candidate.name ?? candidate.id ?? "") || undefined;
+                }
+            }
+            catch { /* advisory only */ }
+        }
+        if (role)
+            configured.set(code, role);
+    }
+    return input.activities
+        .filter((activity) => activity.status === 1 && activity.activityType === "PARTICIPANT" && activity.participantCount > 0)
+        .filter((activity) => activity.participants.every((person) => person.id === input.originator))
+        .map((activity) => ({
+        suspect: true,
+        nodeCode: activity.activityCode ?? "?",
+        ...(configured.get(activity.activityCode ?? "") ? { configuredRole: configured.get(activity.activityCode ?? "") } : {}),
+        note: configured.has(activity.activityCode ?? "")
+            ? "角色成员可能不覆盖发起人 OU，平台已退回发起人——核对 org.role.userScope"
+            : "参与者与发起人相同；若该节点配置的是角色，可能因成员 scope 不覆盖发起人 OU 而被平台退回发起人——核对 org.role.userScope",
+    }));
+}
 /**
  * Role participants are filtered by `ouScope ∩ originator's department chain`.
  * A role whose members all have an empty scope therefore resolves to NOBODY —
@@ -3371,6 +3420,24 @@ export function registerWorkflowLane(tools) {
             // activity that currently holds tasks. No active activity while the
             // instance is still PROCESSING is exactly the silent-stall shape.
             const diagnosis = diagnoseInstanceActivity({ instanceStatus, endStatus: header ? wireString(header.endStatus) : null, originator: header ? wireString(header.originator) : null, activities });
+            // The instance face gives the resolved participant, while the
+            // published template gives the configured role. Compare both faces
+            // here (and only here): data.submit wiring intentionally remains in
+            // runtime-data.ts's owning batch. If the template cannot be read,
+            // participantFallbackWarnings degrades to a participant==originator
+            // hint rather than claiming a role mismatch.
+            let publishedTemplate = null;
+            const workflowCode = header ? wireString(header.workflowCode) ?? wireString(header.workflowCode_) : null;
+            if (workflowCode) {
+                try {
+                    const published = await wireCall(session, { path: ENDPOINTS.workflowGetPublished, query: { workflowCode } });
+                    publishedTemplate = published.data && typeof published.data === "object" && !Array.isArray(published.data) ? published.data : null;
+                }
+                catch {
+                    publishedTemplate = null;
+                }
+            }
+            const participantFallback = participantFallbackWarnings({ activities, template: publishedTemplate, originator: header ? wireString(header.originator) : null });
             return {
                 workflowInstanceId: args.workflowInstanceId,
                 ...(instanceStatus ? { instanceStatus } : {}),
@@ -3379,6 +3446,7 @@ export function registerWorkflowLane(tools) {
                 activeCount: active.length,
                 reachedCount: reached.length,
                 activities,
+                ...(participantFallback.length ? { participantFallback } : {}),
                 diagnosis,
             };
         }),

package/dist/model-scaffold.js

@@ -20,6 +20,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";
 /** Validate the caller's `--fields` payload (fail before any write). */
 export function validateScaffoldFields(fields) {
     const problems = [];
@@ -64,7 +67,10 @@ export async function cmdModelScaffold(args) {
     const flag = (name) => argvValue(args, name);
     const code = flag("--code") ?? flag("--schema") ?? flag("--schema-code");
     const name = flag("--name");
-    const fieldsJson = flag("--fields") ?? flag("--fields-json");
+    const fieldsFile = flag("--fields-file");
+    const fieldsFlag = flag("--fields");
+    const fieldsStdin = fieldsFlag === "-";
+    const fieldsJson = fieldsStdin ? readFileSync(0, "utf8") : fieldsFlag ?? flag("--fields-json");
     const folderId = flag("--folder") ?? flag("--folder-id");
     const applicationCode = flag("--app");
     const environment = flag("--env") ?? flag("--environment");
@@ -72,13 +78,13 @@ export async function cmdModelScaffold(args) {
     const publishForm = !args.includes("--no-form");
     const forcePublish = args.includes("--force-publish");
     const usage = [
-        "用法：omc model-scaffold --code <模型code> --name <模型名> --fields '<JSON 数组>' [--folder <目录id>] [--apply]",
+        "用法：omc model-scaffold --code <模型code> --name <模型名> --fields '<JSON 数组>' [--fields-file <路径>|--fields -] [--folder <目录id>] [--apply]",
         "  --fields 每条是一个 field.create 的参数：{\"code\",\"name\",\"propertyType\",...}；子表加 \"subFields\":[...]。",
         "  子表键名统一用 subFields（field.create 平台键）；childFields 仍作别名接受，但 --help 只展示 subFields。",
         "  默认 dry-run（列出将要做什么）；--apply 依次执行 建模型→建字段→建子列→发布字段→发布表单。",
         "  幂等：模型/字段已存在记为 skipped 继续；有真失败时默认不发布（--force-publish 可强发）。",
         "  每个子调用使用独立 requestId（避免同 id 不同参数被幂等门拒绝）；重入已存在字段记 skipped。",
-        "  从文件读：--fields-file <配置根内路径>。",
+        "  --fields-file 从配置根内文件读 JSON 数组；--fields - 从 stdin 读 JSON 数组。",
     ].join("\n");
     const invalid = (message) => {
         writeEnvelope(envelope("error", {}, request, { code: "invalid-input", message: `${message}\n${usage}`, retryable: false }));
@@ -88,11 +94,23 @@ export async function cmdModelScaffold(args) {
         return invalid("--code 必填");
     if (!name)
         return invalid("--name 必填");
-    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))
             throw new Error("--fields 必须是 JSON 数组");
         fields = parsed;
@@ -161,7 +179,7 @@ export async function cmdModelScaffold(args) {
             status: "dry-run",
             ...plan,
             preflight: { checked: fields.length, passed: true },
-            note: "dry-run 只列计划；已对每个字段跑过本地形状预检（零 wire）。--apply 依次执行 建模型 → 建字段 → 建子列 → 发布字段 → 发布表单。",
+            note: "dry-run 只列计划；已对每个字段跑过本地形状预检（零 wire）。dry-run 只校参数与计划，不代表运行时可达/规则健康（模型可见性、规则节点运行时异常都不在探测面）。--apply 依次执行 建模型 → 建字段 → 建子列 → 发布字段 → 发布表单。",
         }, request));
         return CLI_EXIT_CODES.ok;
     }

package/dist/read.js

@@ -59,7 +59,11 @@ export async function governedRead(ctx, tool, args, execute, options = {}) {
         // 2026-11-01 预算批 v2（r38 usage 实证）：1-4KB 中结果 59 次/135KB≈37% 全内联，
         // model.inspect 17 次全部卡在旧门下。降到 2048；compact 对配置清单保形为码表
         // （CODE_LIST_KEYS），完整正文仍在 detailArtifactId。
-        const large = jsonBytes(result) > 2048;
+        // r44fb: keep small row sets in the first envelope even when each row has
+        // useful detail (data.list items or rulelog nodes).
+        const smallRowSet = (Array.isArray(result.items) && result.items.length <= 10)
+            || (Array.isArray(result.logs) && result.logs.length <= 10);
+        const large = !smallRowSet && jsonBytes(result) > 2048;
         const fileName = `${tool.name.replace(/[^a-zA-Z0-9._-]/g, "_")}-${sha256(target).slice(0, 16)}.json`;
         const artifactRef = writeArtifact(ctx, fileName, detail);
         const cacheEntry = { environmentFingerprint, targetFingerprint, detailFile: artifactRef.detailFile, detailSha256: artifactRef.detailSha256 };
@@ -68,7 +72,7 @@ export async function governedRead(ctx, tool, args, execute, options = {}) {
             // Small raw bodies keep the old inline behaviour; large ones are dieted
             // (see FULL_INLINE_CEILING_BYTES). The raw body stays fully reachable via
             // the artifact, so no capability is lost — only the inline copy is skipped.
-            if (rawBytes <= FULL_INLINE_CEILING_BYTES) {
+            if (rawBytes <= FULL_INLINE_CEILING_BYTES || smallRowSet || rawBytes <= 32768) {
                 ctx.readbackCache.set(target, cacheEntry);
                 return { ...detail, detailFile: artifactRef.detailFile, detailSha256: artifactRef.detailSha256 };
             }

package/dist/recipes/field.js

@@ -357,7 +357,7 @@ const externalLookupModel = Object.freeze({
             schemaCode: "<映射模型code>",
             queryCode: "<映射模型code>",
             displayField: "<映射模型显示字段>",
-            mappings: [{ source: "<映射模型.业务字段>", target: "<本模型.落点字段>" }],
+            mappings: [{ source: "<目标模型字段>", target: "<本模型字段>" }],
         },
     },
     preconditions: [
@@ -370,7 +370,7 @@ const externalLookupModel = Object.freeze({
         "下拉框形态在 form.draft 控件层配置；映射表要有数据下拉才有选项。",
     ],
     priorToolReferences: [
-        { tool: "model.create", args: { environment }, purpose: "建映射模型（字段与接口返回一一对应）" },
+        { tool: "model.create", args: { environment }, purpose: "建映射模型（字段与接口返回一一对应；mappings 的 source/target 只填裸字段 code，不带模型前缀）" },
         { tool: "rule.save", args: { environment }, purpose: "数据段规则（三选一，见 conditionalRequirements）" },
     ],
     dryRun: { supported: true, command: `omc call field.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "校验 WORK_SHEET options 与 mappings 形状" },

package/dist/recipes/online-js.js

@@ -27,6 +27,19 @@ const onlinejsHighlightScript = Object.freeze({
     requiresEnvironmentDerivedIds: false,
 });
 export const ONLINEJS_METADATA = Object.freeze({
-    "onlinejs.compose": Object.freeze({ recipes: [onlinejsHighlightScript], relatedTools: ["form.get", "form.draft", "form.publish"] }),
+    "onlinejs.compose": Object.freeze({ recipes: [onlinejsHighlightScript, Object.freeze({
+                id: "current-user-dept",
+                title: "读取当前用户与部门成员（门户已实证请求）",
+                status: "offline-valid",
+                tool: "onlinejs.compose",
+                args: { environment, schemaCode: model, sheetCode: "<默认表单 code == 模型 code>", replace: true, source: "(function(form){ h3form.axios.get(config.apiHost + '/api/organization/user/info', {params:{id:'<userId>'}}).then(function(res){ var dept = {id:res.data.departmentId, name:res.data.departmentName}; return h3form.axios.get(config.apiHost + '/api/organization/department/users', {params:{deptId:dept.id,page:0,size:300,filterType:'admin'}}); }).then(function(res){ var members = res.data.content || []; }); })" },
+                preconditions: ["门户取证：GET /api/organization/user/info 回 data.departmentId/departmentName；GET /api/organization/department/users 回 data.content，成员含 id/name"],
+                conditionalRequirements: ["这是已实证的门户请求形状；userId、schemaCode、字段使用前替换为真实值", "脚本含引号/较长时用 --args-file"],
+                refusalRecovery: [{ code: "onlinejs-source-invalid", action: "完整外壳改 `replace:true`（六元素模板保留，仅整体替换 customScript）" }],
+                priorToolReferences: [{ tool: "form.get", args: { environment, schemaCode: model }, purpose: "确认表单已发布与控件编码" }],
+                dryRun: { supported: true, command: `omc call onlinejs.compose --env ${environment} --dry-run --args-file compose.json`, notes: "dry-run 校验外壳/合并模式，不写平台" },
+                expectedReadback: { readback: { deliveryState: "DELIVERED", published: true, scriptElementPresent: true } },
+                requiresEnvironmentDerivedIds: false,
+            })], relatedTools: ["form.get", "form.draft", "form.publish"] }),
 });
 //# sourceMappingURL=online-js.js.map

package/dist/residue.js

@@ -108,10 +108,14 @@ export async function scanResidues(session, prefix, options = {}) {
     const hasModelResidue = modelFace.some((item) => item.count > 0);
     const hasOtherResidue = faces.some((item) => item.face !== "model" && item.count > 0);
     const pendingCascade = !hasModelResidue && hasOtherResidue;
+    const nonZeroFaces = faces.filter((item) => item.count > 0);
+    const compact = options.allFaces === true ? faces : nonZeroFaces;
     return {
         prefix,
-        faces,
+        faces: compact,
+        ...(options.allFaces === true ? {} : { byFace: compact }),
         totalResidues,
+        userResidues,
         clean: userResidues === 0 && !pendingCascade,
         ...(systemPresetCount > 0 ? { systemPresetCount } : {}),
         ...(pendingCascade ? { pendingCascade: true } : {}),
@@ -124,7 +128,7 @@ export async function cmdResidue(prefix, options, transport) {
     try {
         const context = makeToolContext({ sessions: new SessionManager(new ConfigStore(defaultPaths())) });
         const session = await context.sessions.session(options.env);
-        return emitResult(await scanResidues(session, prefix, { apps: options.apps, deep: options.noDeep !== true }), transport);
+        return emitResult(await scanResidues(session, prefix, { apps: options.apps, deep: options.noDeep !== true, allFaces: options.allFaces }), transport);
     }
     catch (error) {
         return emitResult({ status: "error", blocker: "residue-scan-failed", message: error instanceof Error ? error.message : String(error) }, transport);

package/dist/rule-support.js

@@ -968,6 +968,10 @@ export async function executeRuleSaveWrite(session, args) {
         ? "保存≠生效：本次只写了 DRAFT。规则虽 enabled:true，运行时仍跑上一版已发布图——请再 rule.enable（内部 publish + 翻 DRAFT 启用）或 rule.save 传 publish:true 后再 rule.enable，用 data.submit/data.load 核对新图副作用"
         : "保存≠生效：本次只写了 DRAFT。rule.enable（businessrule/publish 出新版本 + 翻 DRAFT 启用开关）后规则才会分发；或 rule.save 传 publish:true 只发布（启用仍走 rule.enable）";
     const currentRow = async () => wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } })).data).find((item) => item.code === args.ruleCode);
+    // Keep warnings tied to the submitted graph; old node-specific warnings are
+    // stale inventory noise after an upsert replaces the graph.
+    const graphNodeCodes = new Set(nodes.map((node) => String(node.nodeCode ?? "")).filter(Boolean));
+    const currentLintWarnings = lintWarnings.filter((warning) => warning.nodeCode === undefined || graphNodeCodes.has(warning.nodeCode) || warning.code === "rule-graph-system-node-tool-owned");
     if (args.publish === true) {
         const row = await currentRow();
         if (row?.id) {
@@ -1003,6 +1007,9 @@ export async function executeRuleSaveWrite(session, args) {
         // hardcoded true made a draft rule look live and a workflow end-event
         // binding on it was silently dead. Liveness itself is `rule.enable`.
         const published = effective?.status === "ENABLED" || effective?.latestPublished === true || effective?.templateType === "PUBLISH";
+        const effectiveNow = published && enabled;
+        const effectiveBasis = effectiveNow ? "本次图已发布且规则 enabled:true，当前运行面可用" : "本次图未同时满足 publish + enabled；仍需 rule.enable 才是当前运行图";
+        const previousRuleVersion = existing?.ruleVersion;
         return {
             performed: { errcode: performed.errcode, mode: existing?.id ? "update" : "create", publishRequested: true, ...(bizMethodChecks > 0 ? { bizMethodChecks } : {}) },
             readback: {
@@ -1010,7 +1017,7 @@ export async function executeRuleSaveWrite(session, args) {
                 published,
                 enabled,
                 status: effective?.status,
-                ...(lintWarnings.length > 0 ? { lintWarnings } : {}),
+                ...(currentLintWarnings.length > 0 ? { lintWarnings: currentLintWarnings } : {}),
                 ...(lintHazards.length > 0 ? { lintHazards } : {}),
                 customTrigger: customTriggerApplied,
                 // publish only mints the PUBLISH row; the runtime gate
@@ -1024,6 +1031,9 @@ export async function executeRuleSaveWrite(session, args) {
                 ...(customTriggerApplied ? {} : { customTriggerHint: "图中没有 CUSTOM_NODE 触发节点：门户按钮/流程按钮调用该规则时会按各自的触发面执行；rule.run 也能执行（它不要求 CUSTOM_NODE），执行时以 BUTTON 触发类型跑同一张图" }),
                 id: effective?.id ?? undefined,
                 ruleVersion: effective?.ruleVersion,
+                previousRuleVersion,
+                effectiveNow,
+                effectiveBasis,
                 latestPublished: effective?.latestPublished,
                 ...(existing?.id ? { versionNote } : {}),
                 ...(enabled ? {} : { nextAction: "rule.enable（businessrule/publish + businessrule/enable 两步）后规则才会分发并对流程/按钮可见；publish:true 只写入版本" }),
@@ -1031,6 +1041,7 @@ export async function executeRuleSaveWrite(session, args) {
         };
     }
     const effective = await currentRow();
+    const previousRuleVersion = existing?.ruleVersion;
     return {
         performed: { errcode: performed.errcode, mode: existing?.id ? "update" : "create", ...(bizMethodChecks > 0 ? { bizMethodChecks } : {}) },
         readback: {
@@ -1042,12 +1053,15 @@ export async function executeRuleSaveWrite(session, args) {
             effective: false,
             requiresPublishAction: "rule.enable",
             ...(existing?.defaultRule === true || PLATFORM_TRIGGER_RULE_CODES.has(args.ruleCode) ? { presetRule: true } : {}),
-            ...(lintWarnings.length > 0 ? { lintWarnings } : {}),
+            ...(currentLintWarnings.length > 0 ? { lintWarnings: currentLintWarnings } : {}),
             ...(lintHazards.length > 0 ? { lintHazards } : {}),
             customTrigger: customTriggerApplied,
             ...(customTriggerApplied ? {} : { customTriggerHint: "图中没有 CUSTOM_NODE 触发节点：门户按钮/流程按钮调用该规则时会按各自的触发面执行；rule.run 也能执行（它不要求 CUSTOM_NODE），执行时以 BUTTON 触发类型跑同一张图" }),
             id: effective?.id ?? undefined,
             ruleVersion: effective?.ruleVersion,
+            previousRuleVersion,
+            effectiveNow: false,
+            effectiveBasis: "本次只写 DRAFT，未发布；rule.enable（或 publish:true 后再 enable）才会让本次图成为当前运行图",
             latestPublished: effective?.latestPublished,
             ...(existing?.id ? { versionNote } : {}),
             nextAction: saveNotEffectiveNextAction,

package/dist/tools.js

@@ -13,6 +13,7 @@ import { registerFieldLane } from "./lanes/field.js";
 import { registerDataRuleLane } from "./lanes/datarule.js";
 import { registerFormLane } from "./lanes/form.js";
 import { registerBusinessRuleLane } from "./lanes/businessrule.js";
+import { registerRuleLogLane } from "./lanes/rulelog.js";
 import { registerRuleLifecycleLane } from "./lanes/rule-lifecycle.js";
 import { registerRuntimeDataLane } from "./lanes/runtime-data.js";
 import { registerWorkflowLane } from "./lanes/workflow.js";
@@ -57,6 +58,7 @@ export function buildToolRegistry() {
     registerDataRuleLane(tools);
     registerFormLane(tools);
     registerBusinessRuleLane(tools);
+    registerRuleLogLane(tools);
     registerRuleLifecycleLane(tools);
     registerRuntimeDataLane(tools);
     registerWorkflowLane(tools);

package/dist/write.js

@@ -93,6 +93,17 @@ async function governedWrite(ctx, tool, args, execute, dryRunPayload, readOnlyEs
             if (error instanceof ToolRefusalError)
                 throw error;
             if (error instanceof WireError) {
+                // F3: rule-node runtime failures are masked by the platform as 300004.
+                if (error.errcode === 300004) {
+                    return {
+                        status: "refused",
+                        blocker: `wire-${error.kind}`,
+                        errcode: 300004,
+                        message: `${error.message}——若 modelPresent:true 且 form 已发布，这个 300004 大概率是业务规则节点运行时异常，不是模型缺失；先查 rulelog 的 EXCEPTION/ROLLBACK，再看最近改动的规则。`,
+                        nextCommand: "omc help omc-refusals",
+                        diagnostic: "omc call rulelog.search --args '{\"schemaCode\":\"<model>\",\"includeNodes\":true}'；再用 rule.get 检查最近改动规则，隔离法是暂时删/禁规则后重试",
+                    };
+                }
                 // authine-orm Serializer.update/delete throws "Object <id> is not
                 // serialized." when the entity handle was never loaded from the store.
                 // That is a PLATFORM object-state error, not a shape error — reported as

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stalfh233/omc-cli",
-  "version": "0.6.23",
+  "version": "0.6.25",
   "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.23",
+    "omc-core": "0.6.25",
     "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.23"
+    "@stalfh233/omc-fake-platform": "0.6.25"
   }
 }

package/skills/omc-capabilities.md

@@ -31,8 +31,8 @@ only the section for the capability you need —
 | 字段 `field` | 字段族 + 子表 + **计算字段** | 字段、属性、子表、明细、下拉、单选、多选、附件、人员、部门、日期、数值、关联、**公式/计算/求和/汇总/合计/回主表** | [字段](#字段-field) |
 | 默认表单 `form` | 表单布局与发布 | 表单、页面、布局、控件、只读、显示 | [默认表单](#默认表单-form) |
 | 列表视图 `listview` | 列表表头与列 | 列表、视图、查询列、筛选、表头、甘特 | [列表视图](#列表视图-listview) |
-| 字段级规则 `datarule` | 字段级控件规则 | 字段级规则、控件规则、校验规则、计算拼接、显示规则、条件必填/只读/显示 | [字段级规则](#字段级规则-datarule) |
-| 业务规则 `businessrule` | 图形规则图 + **定时任务** | 业务规则、触发器、规则图、事件、BRANCH、BIZ_ACTION、**定时任务/定时/每天/周期/调度** | [业务规则](#业务规则-businessrule) |
+| 字段级引擎规则（非表单控件） `datarule` | 字段级引擎读面 | 字段级规则、校验规则、计算拼接、显示规则、条件必填/只读/显示 | [字段级规则](#字段级规则-datarule) |
+| 业务规则 `businessrule` | 图形规则图 + **定时任务** + 审计 | 业务规则、触发器、规则图、事件、BRANCH、BIZ_ACTION、**定时任务/定时/每天/周期/调度**、触发日志审计 | [业务规则](#业务规则-businessrule) |
 | 规则生命周期 `rule-lifecycle` | 规则启停删 | 启用规则、停用规则、删除规则、规则启停 | [规则生命周期](#规则生命周期-rule-lifecycle) |
 | 流程模板 `workflow` | 审批流程模板 | 流程、工作流、审批、节点、待办、流转、参与人、审批人、表单操作按钮 | [流程模板](#流程模板-workflow) |
 | 表单在线 JS `onlinejs` | 表单脚本发布/回读 | 在线js、脚本、联动、onload、onvalidate | [表单在线 JS](#表单在线-js-onlinejs) |
@@ -121,6 +121,8 @@ only the section for the capability you need —
 
 ## 字段级规则 `datarule`
 
+> **字段级引擎规则（非表单控件）**：表单条件必填/显示/只读走 `field.update options`；本面是设计器引擎读面。
+
 - **能做哪些事**：字段级数据规则（bizdatarule）create/update/delete；条件必填（type4）、条件只读（type5）、条件显示（type3）、计算拼接（type2）等，按平台校验器闭环。
 - **工具**：`datarule.list`、`datarule.create`、`datarule.update`、`datarule.delete`
 - **recipe**：
@@ -132,7 +134,7 @@ only the section for the capability you need —
 ## 业务规则 `businessrule`
 
 - **能做哪些事**：图形规则图（nodeGraph）——数据事件（Create/Update/Delete）触发、按钮/流程触发、动作节点（UPDATE/CREATE/DELETE/QUERY/ASSIGN/MESSAGE/BIZ_ACTION/GET_LIST…）、BRANCH 条件分支、**定时任务 TIMING_TASK**（每天/周期，SCHEDULER 节点）。
-- **工具**：`rule.list`、`rule.get`、`rule.references`（跨规则引用检索：谁引用了服务/模型/字段）、`rule.save`、`rule.node.update`
+- **工具**：`rule.list`、`rule.get`、`rule.references`（跨规则引用检索：谁引用了服务/模型/字段）、`rule.save`、`rule.node.update`、`rulelog.search`（**规则执行日志审计入口**：规则触发没触发/哪行/节点链——data.update 后查 F31）
 - **recipe**：
   - `omc describe rule.save --example standard-business-rule-graph`
   - `omc describe rule.save --example business-rule-branch-conditional`
@@ -160,6 +162,7 @@ only the section for the capability you need —
 
 - **能做哪些事**：表单在线 JS 的 compose 六元素骨架、`draftHtmlJson.customScript`、发布与 SHA-256 回读；**读现存脚本**（`onlinejs.get` 抽 customScript innerHTML 原文+SHA-256，不必拉 form.get --full 六份 JSON）（脚本**编写**不在 CLI 范围，遵循项目在线 JS 规范或向用户索取定稿 source）。
 - **工具**：`onlinejs.get`、`onlinejs.compose`
+- **常用运行时 API（已实证）**：门户可用 `form.getControl(code)`、`form.on('onRendered', fn)` 与控件 `valueChange.subscribe`；当前用户/部门取证走 `h3form.axios.get(config.apiHost + '/api/organization/user/info', {params:{id:userId}})`，响应字段含 `data.departmentId`/`data.departmentName`；部门成员走 `/api/organization/department/users`，列表在 `data.content`，成员含 `id`/`name`。配方：`omc describe onlinejs.compose --example current-user-dept`。
 - **边界 / 陷阱**：仅表单在线 JS；后端在线开发（`/api/api/programming` Java 源码）是独立 `programming` lane（`programming.get/save/compile/publish`），与在线 JS 不互换。INCREMENTAL 合并对同内容重发幂等；同头注释的整文件修订会被拒（`onlinejs-revision-replace-required`），走 `onlinejs.get` 取回 → 改 → `replace:true`。
 
 ## 后端在线开发 `programming`

package/skills/omc-playbook.md

@@ -11,16 +11,13 @@ description: 一页纸业务场景步骤清单（采购申请 / 请假审批 /
 
 ## 采购申请（主子表 + 合计 + 条件审批 + 列表 + 按钮）
 
-1. `omc next "从零做采购申请：主子表、合计、条件审批、列表、按钮"`
-2. `omc intent schema`（或直接按下方拼装器链）
-3. `omc model-scaffold --app <app> --code <code> --name 采购申请 --fields '[{"code":"title","name":"标题","propertyType":"SHORT_TEXT"},{"code":"amount","name":"合计","propertyType":"NUMERICAL","options":{"scale":2}},{"code":"<主表code>_details","name":"明细","propertyType":"CHILD_TABLE","subFields":[{"code":"item","name":"品名","propertyType":"SHORT_TEXT"},{"code":"qty","name":"数量","propertyType":"NUMERICAL","options":{"scale":0}},{"code":"price","name":"单价","propertyType":"NUMERICAL","options":{"scale":2}},{"code":"lineAmount","name":"金额","propertyType":"NUMERICAL","options":{"scale":2}}]}]' --apply`
-   子表 code 是全局子 schema code，必须全局唯一；不要使用 `details`、`items` 这类通用名，按 `<主表code>_details` 这类带主表前缀的形式命名，避免撞名 40000。
+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 必须全局唯一）
 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}'`（这是**谁能发起**，不是行级可见范围）
-7. 列表：`omc call listview.configure --args '{"schemaCode":"<code>","fieldCodes":["title","amount"],"conditions":[{"propertyCode":"assetNo","filterType":"Eq","defaultValue":"<设备编号>"}]}'`
-   按设备编号等条件查询时用 `conditions`；形状以 `omc describe listview.configure --param conditions` 为准（至少提供 `propertyCode`，再按字段补 `filterType`/`defaultValue`）。
-8. 表单按钮：`omc call listview.configure --args '{"schemaCode":"<code>","buttons":[{"name":"提交审批","useLocation":"FORM","bindAction":"FLOW"}]}'`（形状以 describe 为准）
+7. 列表：`listview.configure` 写 `fieldCodes`/`conditions`；条件形状以 `omc describe listview.configure --param conditions` 为准。
+8. 按钮：`listview.configure` 写 `buttons:[{name,useLocation:"FORM",bindAction:"FLOW"}]`。
 9. ⚠️ **行级「申请人只看自己」当前工具面不支持**（`workflow.permissions` / `org.role.setUserScope` 都不是行级数据权限）
 
 ## 请假审批（线性流）
@@ -36,6 +33,17 @@ description: 一页纸业务场景步骤清单（采购申请 / 请假审批 /
 2. `omc call listview.configure --args '{"schemaCode":"vendor","fieldCodes":["name","code"]}'`
 3. 造数：`omc describe data.submit --example plain-data-submit`
 
+## 条件表单 + 关联带出
+
+1. 条件必填/显示/只读写 `field.update options`（不要用 datarule）；子表条件列同法，建在父字段 code 下。
+2. 关联带出映射用**裸 code**（无 `schema.` 前缀）；发布链 `field.publish → form.draft rebuild:true → form.publish`，`form.get` 验收。
+
+## 数据事件规则（跨模型联动 + 执行日志）
+
+1. 联动挂预置 `Create`/`Update`（submit 触发 Create、update 触发 Update）→ `rule.enable`；`data.load` 验收目标行。
+2. 取证：`omc call rulelog.search --args '{"schemaCode":"<模型>","bizObjectId":"<行id>"}'——触发/行/节点链一次问清。
+
+
 ## 读法
 
 - 默认索引：`omc help omc-playbook`（看节摘要）

package/skills/omc-refusals.md

@@ -68,6 +68,13 @@ condition/expression/query shape is off. Compare against
 Escalate to 二开 **only** for a real `capability-out-of-coverage` (§2).
 
 `40000 调用数据库发生异常` is the **most opaque** shape code — no detail at all.
+
+### 3d. 300004 during form/submit can be a rule-node failure
+
+Model present + form published yet submit says `300004 数据模型不存在`? Often a
+rule-node exception in disguise (r44b): `rulelog.search {schemaCode,includeNodes:true}`
+→ `EXCEPTION`/`ROLLBACK` nodes → `rule.get` the changed rule; disable/delete it to
+isolate. Never recreate a healthy model.
 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;