@stalfh233/omc-cli 0.6.24 → 0.6.26

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.js

@@ -61,7 +61,7 @@ export function registerRuleLogLane(tools) {
                 }
                 return log;
             }));
-            return { index: { schemaCode: args.schemaCode, page: requestedPage, size: requestedSize, totalElements: data.totalElements ?? logs.length, totalPages: data.totalPages ?? 0, ...(rowFilter ? { rowFilter } : {}) }, logs, notes: [...notes, ...(args.includeNodes === true ? ["节点 VO 不提供 targetBizObjectId，节点行级 id 不可得；仅前 3 条命中日志拉取节点链"] : [])] };
+            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)}` }),
     }));
 }

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

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

package/dist/recipes/field.js

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

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

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

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

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`、`rulelog.search`（**规则执行日志**：触发了没有/哪行触发/节点链——data.update 后查 F31）
+- **工具**：`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,14 @@ 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 必须全局唯一）
+3. （`model-scaffold` 已在第 2 步完成字段发布与表单发布；无需另起命令）
 4. `omc compute --schema <code> --target amount --formula 'SUM({<主表code>_details.lineAmount})' --apply`（⚠️ 只在门户算，REST 不回填）
 5. 条件审批（金额>50000 两级）：**不要** `approval-flow --condition`（无此参数）。线性先：`omc approval-flow --schema <code> --steps '经理@role:<mgr>' --steps '总监@role:<dir>' --apply`；条件分流改 `omc describe workflow.update --example workflow-conditional-branch` 后 `workflow.update`。
 6. 发起权限：`omc call workflow.addPermission --args '{"workflowCode":"<code>_wf","unitId":"<deptOrRoleId>","unitType":1}'`（这是**谁能发起**，不是行级可见范围）
-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 +34,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;