@stalfh233/omc-cli 0.4.100 → 0.4.101

package/README.md

@@ -28,6 +28,9 @@
 - **应用目录（分组）**——`folder.tree/create/update/delete` + `model.move`；
   应用树是嵌套 `children`，读面已递归展平并给 `path`/`depth`。
 - **方法论即可读**——`skills/` 下的方法论通过 `omc help <topic>` 按需读取；agent 不必去翻仓库文件。
+- **一次调用就是答案（0.4.100）**——`omc help --search "<词>"` 跨全部 topic 全文检索、命中节正文内联（严禁自己 `--all | grep`）；`omc describe <tool>` 默认带 `firstCall` 最小可跑形状（上下文键占位符化并列入 missing，绝不冒充合法值）；`omc next "<目标>"` 首答只给一个可执行动作或一个问题（`firstAnswer`）；`omc commands --filter` 支持能力语言（聚合/字典/业务集成…），零命中回 ≤3 个最近候选。
+- **拒绝即教学**——写前拒绝信封自带「你错在哪、正确形状、同源配方命令、不要做什么」；平台/权限/环境类只给「先修什么」，不给注定失败的重试命令。
+- **复合写命令**——`omc submit-verify`（逐条提交 → 真实 id 读回 → 差异汇总）、`omc rule-save-enable`（保存成功才启用，回执回答「会不会真的运行」）、`omc workflow-update-publish`（显式合成最终模板：默认保留旧节点，`--confirm-replace` 才丢弃）。全部默认 dry-run、第一步失败立即停、不自动重试。
 - **凭据零回显**——凭据（0600 存储或环境变量）不会出现在任何输出、产物或错误里。
 - **不确定性语义**——传输失败时冻结（`status: "uncertain", frozen: true`），
   绝不伪造成功。
@@ -130,10 +133,19 @@ omc call discover_environment --env <env> --args '{}'   # 环境就绪（真实
 - **intent**：`partial` 表示该能力可声明式（`omc intent`）覆盖一部分——通常 create/update；
   `none` 表示只走 `omc call`。删除类、方法面、分类/连接池等仍走 `omc call` 逃生舱。
 
-## 近期能力（0.4.74 → 0.4.88）
+## 近期能力（0.4.84 → 0.4.100）
 
 | 版本 | 新增 / 修复 |
 |---|---|
+| 0.4.100 | **回合经济学批（r19–r20，同题面实测 184 调用/503KB → 84 调用/98KB）**：`omc help --search "<词>"` 全文检索（命中节正文内联，单节 >6KB 只给精确回放命令）；`describe` 默认带 `firstCall`（offline-valid 最小可跑形状，`executable === missing为空`）；`omc next` 首答 `firstAnswer`（ready=无占位符可跑 / needs-input=一个问题 / blocked=不伪造路径），`discover_environment` 退出 firstCommands 首位、章节指针 ≤1 且非通用草稿模板、输出 ≤4096B；`commands --filter` 语义检索（工具名/能力别名/配方/摘要，大小写与分隔符归一；零命中最小信封+≤3 候选；宽词按能力分组 ≤3.5KB）；拒绝即教学（拒绝信封自带正确形状+与 firstCall 同源的配方命令+不要做什么；平台/权限类只给先修什么）；三条复合写命令 `submit-verify` / `rule-save-enable` / `workflow-update-publish`（默认 dry-run、第一步失败立即停、合并语义显式）；`OMC_NO_USAGE=1` 计量隔离（读侧不受影响）；报表能力按裁决暂缓（报表类目标 boundary 首答；`/dashboard/v1/*` 502 教学「环境边界不要重试」；`report.create` 半成功显式警示+清理命令） |
+| 0.4.99 | 聚合算法三态实测定案：`LARGE/SMALL` 必带 k（缺 → 50000 掩码）、`UNION` 的 `resultType` 只能 0/1；审批提交**顶层 `agree` 才有效**（`approval.agree/opinion` 被静默忽略且仍按通过处理——写前拒绝 + `approvalNote` 顶层参数）；聚合事件回算窗口 ≈3 分钟实测（`field.publish --force` 重置） |
+| 0.4.98 | 聚合指向子表 schema 写前拒绝（会让目标模型整体 40000 无明细且匹配恒 0）；`40000` 裸掩码给排查解释（先疑字段级配置）；`omc next` 造数据场景路由 |
+| 0.4.97 | 三个写前 gate：日期毫秒时间戳（落库 NULL）、单值关联传数组（50000）、更新时无 id 子表行按新增插入不判重（实测 2 行变 8 行）；跨模型聚合行为图谱（混用条件/多组 OR/COUNTIF/MAX/来源删除回算） |
+| 0.4.96 | 聚合定案（反编译 1.1.25 运行版 jar）：`propertyType/operatorType/resultType` 等 `@JsonCreator get(int)` 枚举**只认整数码**（写名字 → 305003 掩码，CLI 自动转码）；同模型子表聚合是平台死路（`checkCycleOfAggregation:1032` 判环，`field.create` 接受、`field.publish` 炸）→ 写前拒绝；跨模型汇总配方 `formula-aggregation-cross-model`（DYNAMIC 条件两侧字段分属两模型、`queryConditions` 不能为空） |
+| 0.4.95 | `omc compute` 诚实化：`datarule` type2（shortTextStitch）在 REST 路径**永不执行**（`CalculateHandler` 由 `forceExecuteCalculateRule` 门控、全库 0 调用方；门户「能算」是客户端 JS 求值器）——不再假装可配 |
+| 0.4.94 | QUERY 输出不可寻址写前拒绝；`100005` 判「同 workItem 已提交」（永久，非时间窗） |
+| 0.4.92 | `rule.run` 真门（此前是假成功）；custompage 八工具 |
+| 0.4.89/90 | 修 0.4.88 DRAFT 实例回归；`/organization/department/tree` 深度 BFS（deptIds 只回直接子级）；组织树参与人解析按 `ouScope ∩ 发起人部门链`（全空=静默回退发起人 → 写前拒绝）；结构化 nextCommand |
 | 0.4.88 | **`omc model-purge`**：一条命令按依赖倒序清掉一个模型（流程实例 → model.delete 级联带走流程/视图/字段/表单/规则）。这是 r12–r14 三次「脏沙盒幽灵故障」的根治——顺手修了它的死锁（视图最后一条不能删 306103 + 列表绑定流程 303024，所以不删流程、让模型级联）。另：ladder 的 **recipe 命令提到 firstCommands**（r14 抱怨「ladder 没给可直接跑的命令」）、recipe 增加 `aliases` 意图词、`listview.configure` 的拒绝恢复补上 `targetCode` 按 bindAction 的语义 |
 | 0.4.87 | **r14 真机探针修复**：`workitem.list` 的 50000 **不再是无解题**——按 `participant` 走 JPA 查询端点（能查**别人**名下的待办、且不解析流程模板），全局搜索失败时回 `workitem-search-unavailable` 带成因与三条绕行；`workflow.delete` 的 402508 改 `workflow-has-instances` 并说明**不要改用 model.delete 绕过**；`model.delete` 在有未完结待办时回 `workflowWarning`（级联会留脏待办 → 全局待办搜索整页 NPE）。另修两个 composer 模板参数名写错（`form-default --value`→`--default`、`rule-when --rule`→`--on`），并加**模板 vs `--help` 自动校验测试** |
 | 0.4.86 | **r13 真机探针修复**：`omc next` 增加 **composer 路由**（含建模型+字段/审批流/计算/条件规则/表单默认值 → 直接给出对应一条命令；读面仍走 ladder，条件分支流程仍走 recipe）——r13 读了文档里那行 `model-scaffold` 却仍调 26 次 `field.create`，说明「写进文档」不等于「能被发现」。`data.submit` 审批提交**写前校验身份**：非本人在办的待办直接回 `submit-workitem-not-mine`（带待办持有者 + 三条出路），不再让平台回一个 `40005 权限不足`让 agent 猜 |

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

@@ -1240,7 +1240,7 @@
     {
       "capability": "rule.list latest business-rule listing and rule.get node route definition readback",
       "status": "executable",
-      "scope": "GET /api/api/runtime/business_rule/list_by_schemacode returning the full latest-version business-field set (no server-side filters); GET /api/api/app/businessrule/get returning the saved node and route graph for readback",
+      "scope": "GET /api/api/runtime/business_rule/list_by_schemacode returning the full latest-version business-field set (no server-side filters); GET /api/api/app/businessrule/get returning the saved node and route graph for readback; cross-rule reference search over model.list + businessrule list/get scans (rule.references)",
       "version_family": "8.6",
       "anchor_version": "8.6.26",
       "evidence": [
@@ -1251,16 +1251,22 @@
         {
           "path": "packages/omc-cli/test/rule-list.test.ts",
           "anchor": "contract tests"
+        },
+        {
+          "path": "packages/omc-cli/test/rule-references.test.ts",
+          "anchor": "contract tests"
         }
       ],
       "lane": "B1-businessrule",
       "tools": [
         "rule.list",
-        "rule.get"
+        "rule.get",
+        "rule.references"
       ],
       "scopes": [
         "latest rule business-field listing",
-        "rule node route readback"
+        "rule node route readback",
+        "cross-rule reference search"
       ]
     },
     {

package/dist/cli-contract.js

@@ -220,7 +220,11 @@ export function classifyResult(result) {
         return { status: "error", error: withNext({ code: "invalid-input", message: `unknown tool ${String(result.tool ?? "")}${suffix}`, retryable: false }), exitCode: CLI_EXIT_CODES.invalidInput };
     }
     if (result.blocker === "tool-input-invalid")
-        return { status: "error", error: withNext({ code: "invalid-input", message: String(result.message ?? "tool input is invalid"), retryable: false }), exitCode: CLI_EXIT_CODES.invalidInput };
+        return {
+            status: "error",
+            error: { ...withNext({ code: "invalid-input", message: String(result.message ?? "tool input is invalid"), retryable: false }), nextCommand: `omc describe ${String(result.tool ?? "<tool>")}` },
+            exitCode: CLI_EXIT_CODES.invalidInput,
+        };
     if (status === "uncertain")
         return { status, error: withNext({ code: "uncertain", message: String(result.message ?? result.reason ?? "outcome is uncertain"), retryable: true }), exitCode: CLI_EXIT_CODES.uncertain };
     if (status === "refused") {

package/dist/discovery.js

@@ -182,6 +182,13 @@ function terseType(node) {
         const label = `${node.type ?? "string"}: ${values.join("|")}`;
         return label.length > 80 ? `${node.type ?? "string"} (enum)` : label;
     }
+    // 券商 issue 1.2（2026-10-27）：union 渲染成 "any" 曾让调用方以为 controls 收
+    // 任意值、直觉传逗号串被 invalid_union 拒。anyOf 如实标注成员类型。
+    if (Array.isArray(node.anyOf) && node.anyOf.length > 0) {
+        const members = [...new Set(node.anyOf.map((member) => terseType(member)))];
+        const label = members.join("|");
+        return label.length > 60 ? `(${label.slice(0, 57)}...)` : label;
+    }
     if (node.type === "array")
         return `array<${terseType(node.items)}>`;
     return node.type ?? "any";

package/dist/goal-routes.js

@@ -556,6 +556,38 @@ export function goalRoute(registry, goal) {
     // Composer before the capability solver: a recurring write SHAPE has a single
     // command that does the job with preflight + idempotency, which beats a ladder
     // of atomic tools even when the ladder also matches (r13: 26 field.create).
+    // r19 券商 issue 1.1（2026-10-27）：子表**控件**（type 201）的显示/只读条件
+    // （displayFormula/readonlyFormula）不在字段面——field.update 对子表只管**列**、
+    // 对控件条件必拒；唯一路径是表单 attributes（form.get 读 draftAttributesJson
+    // 定位控件 → form.draft 改 → form.publish）。此前该场景路由进 field→form 梯子
+    // 且首级无可行工具（firstCommands 为空），agent 只能靠拒收文案自己悟。
+    if (/子表|控件/.test(goal) && /子表.*(显示|隐藏|只读|显隐).*(条件|公式|规则)|displayFormula|readonlyFormula/.test(goal)) {
+        return {
+            status: "ok",
+            goal,
+            confident: true,
+            mode: "modify",
+            write: true,
+            match: { kind: "capability", ref: "form", title: "子表控件显示/只读条件（表单 attributes 面）" },
+            route: {
+                capability: "form",
+                note: "子表控件的 displayFormula/readonlyFormula 走表单 attributes：form.get(controls:true) 读 draftAttributesJson 定位控件 → form.draft 改该控件条件 → form.publish。field.update 只管子表列，对控件条件必拒（券商 issue 2026-10-27 实证）",
+                readiness: DISCOVERY_AUTHORITY.readiness,
+                firstCommands: [
+                    "omc call form.get --args '{\"schemaCode\":\"<schemaCode>\",\"controls\":true}'",
+                    "omc describe form.draft",
+                ],
+                write: true,
+            },
+            firstAnswer: {
+                state: "needs-input",
+                question: "目标模型 schemaCode 与子表控件 code 是什么？（form.get controls:true 读 draftAttributesJson 定位控件，form.draft 改其条件后 form.publish）",
+                action: LIST_MODELS_ACTION,
+                pendingCommand: "omc call form.draft --args '{\"schemaCode\":\"<schemaCode>\",\"draftAttributesJson\":\"<改好后的完整 attributes JSON>\"}'",
+                why: "子表控件（type 201）的显示/只读条件在表单 attributes，不在字段面——field.update 对子表只管列、必拒",
+            },
+        };
+    }
     const composer = matchComposer(goal, mode);
     if (composer) {
         const topics = (composer.topics ?? []).filter((topic) => availableTopics.has(topic));

package/dist/governed-execution.js

@@ -20,7 +20,7 @@ export async function admitGovernedWrite(ctx, request) {
             blocker: "environment-write-disabled",
             environment: resolved.name,
             production: resolved.profile.production === true,
-            message: `${environmentNotice(resolved.profile)} 请在 omc setup 中开启“允许写入此环境”。`,
+            message: `${environmentNotice(resolved.profile)} 请在 omc setup 中开启“允许写入此环境”。若你本意是写项目环境：检查当前目录是否项目根（.omc-env 所在目录）——在其它目录跑 omc 会解析不到项目环境而落到全局只读策略，cd 回项目根再试。`,
         });
     let session;
     try {

package/dist/lanes/b2-registration.js

@@ -416,7 +416,7 @@ export function registerB2Lane(tools) {
         });
         const afterRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data);
         const after = afterRows.find((row) => row.code === args.methodCode);
-        return { performed: { errcode: performed.errcode }, readback: { methodPresent: after != null, nameMatches: args.name === undefined || after?.name === args.name, configMatches: methodConfigPlain === undefined || after?.configJson === methodConfigPlain, inputParameters: decodeJsonColumn(after?.inputParametersJson), outputParameters: decodeJsonColumn(after?.outputParametersJson) } };
+        return { performed: { errcode: performed.errcode }, readback: { methodCode: args.methodCode, methodPresent: after != null, nameMatches: args.name === undefined || after?.name === args.name, configMatches: methodConfigPlain === undefined || after?.configJson === methodConfigPlain, inputParameters: decodeJsonColumn(after?.inputParametersJson), outputParameters: decodeJsonColumn(after?.outputParametersJson), mappingNote: "规则映射直接用这里的参数 code（bizPropertyType 供类型对账），不必再 service.get" } };
     }, (args) => {
         assertStructuredConfig(args.methodConfig, "methodConfig");
     }, undefined, b2ServiceRollbackSpec("method.update"));
@@ -463,7 +463,7 @@ export function registerB2Lane(tools) {
         });
         const afterRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data);
         const after = afterRows.find((row) => row.code === args.methodCode);
-        return { performed: { errcode: performed.errcode }, readback: { methodPresent: after != null, nameMatches: after?.name === args.name, configMatches: methodConfigPlain === undefined || after?.configJson === methodConfigPlain, inputParameters: decodeJsonColumn(after?.inputParametersJson), outputParameters: decodeJsonColumn(after?.outputParametersJson) } };
+        return { performed: { errcode: performed.errcode }, readback: { methodCode: args.methodCode, methodPresent: after != null, nameMatches: after?.name === args.name, configMatches: methodConfigPlain === undefined || after?.configJson === methodConfigPlain, inputParameters: decodeJsonColumn(after?.inputParametersJson), outputParameters: decodeJsonColumn(after?.outputParametersJson), mappingNote: "规则映射直接用这里的参数 code（bizPropertyType 供类型对账），不必再 service.get" } };
     }, (args) => {
         assertStructuredConfig(args.methodConfig, "methodConfig");
     }, undefined, b2ServiceRollbackSpec("method.create"));
@@ -850,9 +850,26 @@ export function registerB2Lane(tools) {
             ? wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data)
             : [];
         const registered = args.methodName ? methodRows.some((row) => row.code === args.methodName) : undefined;
+        // r19 p7：readback 只回布尔时，agent 只能再调 service.get 拿参数 code（12 次里
+        // 6 次是这种写后验证读）。方法视图内联进 readback，rule.save 的 methodMapping
+        // 直接用这里的 code，不必再读。
+        const methodRow = args.methodName ? methodRows.find((row) => row.code === args.methodName) : undefined;
         return {
             performed: { errcode: performed.errcode },
-            readback: { servicePresent: readback.data != null, ...(registered !== undefined ? { methodPresent: registered, methodCount: methodRows.length } : {}) },
+            readback: {
+                servicePresent: readback.data != null,
+                ...(registered !== undefined ? { methodPresent: registered, methodCount: methodRows.length } : {}),
+                ...(methodRow !== undefined
+                    ? {
+                        method: {
+                            code: methodRow.code,
+                            inputParameters: decodeJsonColumn(methodRow.inputParametersJson),
+                            outputParameters: decodeJsonColumn(methodRow.outputParametersJson),
+                        },
+                        mappingNote: "rule.save 的 methodMapping 直接用上面的参数 code：inputMappings.bizCode=来源字段 code、serviceMethodParameterCode=参数 code；不必再 service.get",
+                    }
+                    : {}),
+            },
         };
     }, (args) => {
         // Dry-lint (zero wire). `omc call` bypasses zod, so every schema-level

package/dist/lanes/businessrule-contract.js

@@ -151,6 +151,10 @@ export const BUSINESSRULE_LANE_CONTRACT = Object.freeze({
             scope: "rule node route readback",
             description: "读回一条业务规则的完整定义（businessrule/get?id=），解析并回显 node/route 图 JSON（触发节点、UPDATE/CREATE 动作节点的 targetObjectCode/inputParam/dataActions/filterCondition 等）——规则族读写链的权威读回面，也是对照设计器生成图形的取证入口。",
         }),
+        "rule.references": Object.freeze({
+            scope: "cross-rule reference search",
+            description: "跨规则引用检索（r23 实证的能力缺失：agent 为查『谁引用了服务 X』枚举了全平台 147 个 schema×ruleCode 组合/171 次 rule.get——本工具一调替代）。kind=service 查 BIZ_ACTION 的 methodMapping.serviceCode；kind=model 查 CREATE/UPDATE/DELETE 的 targetObjectCode 与 methodMapping.schemaCode（删模型前的影响面）；kind=field 查 dataActions.targetDataItem 与 inputMappings/outputMappings 的 bizCode（删字段前的影响面；字段 code 跨模型不唯一，建议配 schemaCodes 限范围）。实现为客户端聚合（model.list→rule.list→rule.get 全扫，约几十次 wire 读、几秒完），输出只回命中行。第一版不含：条件叶子里的字段引用、datarule 引用、workflow.bindRule 绑定。",
+        }),
         "rule.save": Object.freeze({
             scope: "dead-state CRUD conditional node graphs",
             description: RULE_SAVE_DESCRIPTION,

package/dist/lanes/businessrule-coverage.js

@@ -10,7 +10,7 @@ export const BUSINESSRULE_COVERAGE = declareLaneCoverage(BUSINESSRULE_LANE_CONTR
     {
         capability: "rule.list latest business-rule listing and rule.get node route definition readback",
         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)],
+        tools: [claim("rule.list", T["rule.list"].scope), claim("rule.get", T["rule.get"].scope), claim("rule.references", T["rule.references"].scope)],
     },
 ]);
 //# sourceMappingURL=businessrule-coverage.js.map

package/dist/lanes/businessrule.js

@@ -116,6 +116,99 @@ export function registerBusinessRuleLane(tools) {
             };
         }, { full: args.full === true, target: `rule.list:${args.schemaCode}` }),
     }));
+    tools.push(defineTool({
+        name: "rule.references",
+        layer: "low",
+        kind: "read",
+        lane: RULE_LANE,
+        scope: RULE_TOOLS["rule.references"].scope,
+        description: RULE_TOOLS["rule.references"].description,
+        inputSchema: {
+            environment: environmentArg,
+            kind: z.enum(["service", "model", "field"]).describe("按什么找引用：service=BIZ_ACTION methodMapping.serviceCode；model=CREATE/UPDATE/DELETE targetObjectCode 与 methodMapping.schemaCode；field=dataActions.targetDataItem 与映射 bizCode"),
+            code: z.string().min(1).describe("要查引用的编码（服务 code / 模型 code / 字段 code）"),
+            schemaCodes: z.union([z.array(z.string().min(1)), z.string()]).optional().describe("只扫这些模型（省 wire 读）；省略=全平台模型"),
+            capability: capabilityArg,
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            // r23（2026-10-27）：agent 为查「谁引用了服务 X」枚举了 147 个
+            // schema×ruleCode 组合（171 次 rule.get / 229KB）。没有引用检索面时，
+            // 全库枚举是理性选择——所以给它一个。客户端聚合：模型清单 → 每模型
+            // rule.list → 每规则 rule.get → 图内匹配，一次调用、只回命中行。
+            const scoped = args.schemaCodes === undefined
+                ? wireRows((await wireCall(session, { path: ENDPOINTS.modelList })).data).map((row) => String(row.schemaCode ?? "")).filter((code) => code !== "")
+                : (Array.isArray(args.schemaCodes) ? args.schemaCodes : [args.schemaCodes]);
+            const wanted = args.code;
+            const matches = [];
+            let scannedRules = 0;
+            let parseFailures = 0;
+            for (const schemaCode of scoped) {
+                let rows = [];
+                try {
+                    rows = wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode } })).data);
+                }
+                catch {
+                    continue; // 模型无规则面（读失败/空）按无规则处理，不让单个模型挡住全扫
+                }
+                for (const row of rows) {
+                    const ruleCode = String(row.code ?? "");
+                    const ruleId = row.id;
+                    scannedRules += 1;
+                    if (typeof ruleId !== "string" || ruleId === "")
+                        continue;
+                    let record = null;
+                    try {
+                        record = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id: ruleId } })).data;
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!record)
+                        continue;
+                    const nodes = decodeJsonColumn(record.node, JSON_COLUMN_NULL_COALESCE);
+                    if (!Array.isArray(nodes)) {
+                        parseFailures += 1;
+                        continue;
+                    }
+                    for (const rawNode of nodes) {
+                        const nodeCode = String(rawNode.nodeCode ?? "");
+                        const nodeType = String(rawNode.nodeType ?? "");
+                        const mapping = rawNode.methodMapping;
+                        if (args.kind === "service") {
+                            if (nodeType === "BIZ_ACTION" && mapping && String(mapping.serviceCode ?? "") === wanted)
+                                matches.push({ schemaCode, ruleCode, nodeCode, nodeType, via: "methodMapping.serviceCode" });
+                        }
+                        else if (args.kind === "model") {
+                            if (["CREATE", "UPDATE", "DELETE"].includes(nodeType) && String(rawNode.targetObjectCode ?? "") === wanted)
+                                matches.push({ schemaCode, ruleCode, nodeCode, nodeType, via: "targetObjectCode" });
+                            if (mapping && String(mapping.schemaCode ?? "") === wanted)
+                                matches.push({ schemaCode, ruleCode, nodeCode, nodeType, via: "methodMapping.schemaCode" });
+                        }
+                        else {
+                            if (["CREATE", "UPDATE", "DELETE"].includes(nodeType) && Array.isArray(rawNode.dataActions)
+                                && rawNode.dataActions.some((action) => String(action.targetDataItem ?? "") === wanted))
+                                matches.push({ schemaCode, ruleCode, nodeCode, nodeType, via: "dataActions.targetDataItem" });
+                            if (mapping) {
+                                for (const [key, label] of [["inputMappings", "inputMappings.bizCode"], ["outputMappings", "outputMappings.bizCode"]]) {
+                                    if (Array.isArray(mapping[key]) && mapping[key].some((row2) => String(row2.bizCode ?? "") === wanted && (row2.codeType === undefined || row2.codeType === 1)))
+                                        matches.push({ schemaCode, ruleCode, nodeCode, nodeType, via: label });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return {
+                kind: args.kind,
+                code: wanted,
+                scanned: { models: scoped.length, rules: scannedRules, ...(parseFailures > 0 ? { parseFailures } : {}) },
+                matches,
+                ...(matches.length === 0
+                    ? { note: "零命中=全平台（或指定 schemaCodes 范围内）没有规则引用它。范围：service→methodMapping.serviceCode；model→targetObjectCode/methodMapping.schemaCode；field→dataActions.targetDataItem/映射 bizCode（不含条件叶子与 datarule，第一版边界）" }
+                    : {}),
+            };
+        }, { target: `rule.references:${args.kind}:${args.code}` }),
+    }));
     tools.push(defineTool({
         name: "rule.get",
         layer: "low",

package/dist/lanes/field.js

@@ -333,7 +333,16 @@ export function registerFieldLane(tools) {
                 ...(selector.length > 0 ? { selected: selector } : {}),
                 ...(args.all !== true ? { businessOnly: true } : {}),
                 fields: projected,
-                ...(detailed ? {} : { inventory: true, hint: '字段详情（options/subSchema）用 code/fields 选择器或 full:true' }),
+                // 券商 issue 1.4（2026-10-27）：默认面空清单曾被误读成「模型没有字段」。
+                // 空清单要自己解释三种可能，别让 agent 二次试错。
+                ...(detailed
+                    ? {}
+                    : {
+                        inventory: true,
+                        hint: projected.length === 0
+                            ? "字段详情（options/subSchema）用 code/fields 选择器或 full:true。当前 draft 面没有业务字段——字段可能都在 published 面（published:true）、尚未创建，或只有系统字段（all:true 核对）"
+                            : "字段详情（options/subSchema）用 code/fields 选择器或 full:true",
+                    }),
             };
         }, {
             // Round 4: the default diet reduced the whole list to a count, so agents

package/dist/lanes/form.js

@@ -50,7 +50,7 @@ export function registerFormLane(tools) {
             controls: z
                 .union([z.boolean(), z.array(z.string().min(1))])
                 .optional()
-                .describe("控件定义投影：true = 返回全部控件的 draft/published 定义；字符串数组 = 只返回这些控件码的定义；省略 = 只回控件码清单"),
+                .describe("布尔或字符串数组：true=返回全部控件的 draft/published 定义；数组如 [\"controlA\",\"controlB\"]=只回这些控件码的定义；省略=只回控件码清单。注意：逗号拼出的单个字符串不是合法取值（invalid_union）——多控件用 JSON 数组。要控件的 options/subSchema 时改用 full:true 再 artifact get --jq <field> 取单字段"),
             full: z.boolean().optional().describe("返回全部六份布局 JSON 原文（大体积）"),
             buttonScripts: z.boolean().optional().describe("附带表单按钮的脚本原文（options.customButtonJson 里 SCRIPT 按钮的 actionConfig.scriptData）及 sha/字节数"),
             capability: capabilityArg,
@@ -148,7 +148,7 @@ export function registerFormLane(tools) {
     writeTool(tools, "form.draft", FORM_LANE, FORM_TOOLS["form.draft"].scope, FORM_TOOLS["form.draft"].description, {
         schemaCode: z.string().min(1),
         sheetCode: z.string().min(1).optional().describe("表单槽位码；省略时默认 = schemaCode（模型码即默认表单槽位）"),
-        draftViewJson: z.string().optional(),
+        draftViewJson: z.string().optional().describe("行分组：一行 N 个 code=N 列；改列数须改行分组，非改 span"),
         draftAttributesJson: z.string().optional(),
         draftHtmlJson: z.string().optional(),
         fieldCodes: z.array(z.string().min(1)).optional().describe("脚手架绑定的已发布字段（按此顺序）；由 configure_form/intent 显式传入"),

package/dist/lanes/workflow.js

@@ -1686,6 +1686,34 @@ function sanitizeWorkflowSnapshotForReplay(row) {
         }),
     };
 }
+/**
+ * 2026-10-27 用户需求：创建流程时流程名默认与表单名一致。
+ *
+ * 解析链（全部真实读回，不捏造）：
+ *   ① 显式 name → "args"
+ *   ② 该模型默认表单的名字（bizsheet/get 的 name 字段）→ "form-name"
+ *   ③ 模型名（bizmodels/list_schema 行的 name）→ "model-name"
+ *   ④ 都读不到（模型不存在/无名字段）→ 拒绝：让调用方显式给 name，
+ *      绝不拿 schemaCode 冒充流程名（占位符冒充合法值是形状红线）。
+ */
+async function resolveWorkflowName(session, explicitName, schemaCode) {
+    if (typeof explicitName === "string" && explicitName.trim().length > 0)
+        return { name: explicitName, resolvedFrom: "args" };
+    const sheet = await wireCall(session, { path: ENDPOINTS.sheetGet, query: { schemaCode, sheetCode: schemaCode } }).catch(() => null);
+    const sheetName = sheet?.data?.name;
+    if (typeof sheetName === "string" && sheetName.trim().length > 0)
+        return { name: sheetName, resolvedFrom: "form-name" };
+    const listed = await wireCall(session, { path: ENDPOINTS.modelList, method: "POST", body: { schemaCodes: [schemaCode] } }).catch(() => null);
+    const rows = wireRows(listed?.data);
+    const modelName = rows.find((row) => String(row.schemaCode ?? "") === schemaCode)?.name;
+    if (typeof modelName === "string" && modelName.trim().length > 0)
+        return { name: modelName, resolvedFrom: "model-name" };
+    throw new ToolRefusalError({
+        status: "refused",
+        blocker: "invalid-input",
+        message: `流程 name 缺省解析失败：模型 ${schemaCode} 读不到表单名或模型名（模型不存在？）。显式传 name，或先确认模型存在（omc call model.list --args '{"filter":"<名或码>"}'）`,
+    });
+}
 function workflowRollbackSpec(toolName) {
     return {
         target: (args) => `workflow:${String(args.schemaCode ?? "")}/${String(args.code ?? args.workflowCode ?? "")}`,
@@ -2121,7 +2149,13 @@ export function registerWorkflowLane(tools) {
             return { workflowCode, valid: errors.length === 0, errorCount: errors.length, warningCount: warnings.length, errors, warnings };
         }, { target: `workflow.validate:${args.workflowCode ?? args.schemaCode}` }),
     }));
-    writeTool(tools, "workflow.create", WORKFLOW_LANE, WORKFLOW_TOOLS["workflow.create"].scope, WORKFLOW_TOOLS["workflow.create"].description, { schemaCode: z.string().min(1), name: z.string().min(1), code: z.string().min(1) }, async (session, args) => {
+    writeTool(tools, "workflow.create", WORKFLOW_LANE, WORKFLOW_TOOLS["workflow.create"].scope, WORKFLOW_TOOLS["workflow.create"].description, {
+        schemaCode: z.string().min(1),
+        // 2026-10-27 用户需求：流程名默认与表单名一致。省略时的解析链见
+        // resolveWorkflowName——表单名 → 模型名 → 拒绝（不拿 schemaCode 冒充）。
+        name: z.string().min(1).optional().describe("流程名称；省略时默认 = 该模型默认表单的名字（无表单草稿时用模型名），与设计器行为一致"),
+        code: z.string().min(1),
+    }, async (session, args) => {
         // Ticket 76 idempotent retry: get_header FIRST — a post-timeout
         // re-create of the same code short-circuits with the existing header
         // and ZERO create wires. On the happy path this read REPLACES the
@@ -2131,12 +2165,13 @@ export function registerWorkflowLane(tools) {
         if (existingHeader != null) {
             return { performed: { skipped: "already-present" }, readback: { alreadyPresent: true, header: existingHeader } };
         }
+        const { name: workflowName, resolvedFrom } = await resolveWorkflowName(session, args.name, args.schemaCode);
         let performed;
         try {
             performed = await wireCall(session, {
                 path: ENDPOINTS.workflowCreate,
                 method: "POST",
-                body: { workflowCode: args.code, workflowName: args.name, schemaCode: args.schemaCode, icon: "h-icon-all-logic" },
+                body: { workflowCode: args.code, workflowName, schemaCode: args.schemaCode, icon: "h-icon-all-logic" },
             });
         }
         catch (error) {
@@ -2163,7 +2198,7 @@ export function registerWorkflowLane(tools) {
         const draft = await getWorkflowDraftOrNull(session, args.code);
         return {
             performed: { errcode: performed.errcode },
-            readback: { workflowCode: args.code, headerPresent: true, draftPresent: draft != null, templateId: draft?.id ?? null },
+            readback: { workflowCode: args.code, name: workflowName, nameResolvedFrom: resolvedFrom, headerPresent: true, draftPresent: draft != null, templateId: draft?.id ?? null },
         };
     }, undefined, undefined, workflowRollbackSpec("workflow.create"));
     writeTool(tools, "workflow.update", WORKFLOW_LANE, WORKFLOW_TOOLS["workflow.update"].scope, WORKFLOW_TOOLS["workflow.update"].description, { schemaCode: z.string().min(1), code: z.string().min(1), template: workflowTemplateArg, merge: z.boolean().optional().describe("增量：只发改动/新增的活动与路由，工具按 activityCode 合并到草稿（草稿为基；新增节点自动接链），不必先读回整模板再重发。默认自动：模板缺 START 或 END 时按增量 merge（部分模板），给了完整 START..END 才整模板替换；显式 true 强制增量、false 强制替换。merge 是并集、绝不删边：结果比草稿少边会被拒（workflow-merge-would-drop-routes）；--dry-run 会返回 routesBefore/routesAfter/routesAdded/routesDropped") }, async (session, args) => {

package/dist/recipes/b2-registration.js

@@ -16,14 +16,15 @@ const restfulQueryService = Object.freeze({
         },
         methodName: "querySupplier",
         methodConfig: { httpType: "Post", requestBodyType: "JSON", url: "/supplier/query", frontEndExtensionEnable: true },
-        methodInputParameters: [{ code: "keyword", name: "关键字", required: true, configJson: { position: "REQUEST_BODY" } }],
-        methodOutputParameters: [{ code: "name", name: "供应商名称", configJson: { position: "REQUEST_BODY" } }],
+        methodInputParameters: [{ code: "keyword", name: "关键字", required: true, bizPropertyType: "SHORT_TEXT", configJson: { position: "REQUEST_BODY" } }],
+        methodOutputParameters: [{ code: "name", name: "供应商名称", bizPropertyType: "SHORT_TEXT", configJson: { position: "REQUEST_BODY" } }],
     },
     preconditions: ["serviceCategoryId 由 service.category.list 解析（「全部」是空 id 虚拟项不可用）；RESTFUL 服务 configJson 需要 auth 与 commonlist[url]；带 methodName 时必须有 methodConfig"],
     conditionalRequirements: [
         "RESTFUL auth.code ∈ customer(parameterlist=[]) / basic(client… username/password) / oauth_password / oauth_client；parameterlist 每项 {code,value} 且必须与 auth.code 期望参数完全一致",
         "RESTFUL 方法 configJson 必需键：httpType(Post/Get/Put/Patch/Delete)、requestBodyType(Form-urlencoded/JSON/Text)、url、frontEndExtensionEnable(布尔)",
         "RESTFUL 每个输入/输出参数必须带 configJson.position ∈ QUERY_PARAMS/REQUEST_HEADER/REQUEST_BODY/PATH_PARAMS（URL_VARIABLE 被运行时拒 501007）",
+        "每个输入/输出参数必须带 bizPropertyType（如 SHORT_TEXT/NUMERICAL）——缺它提交即被 bizservice-parameter-face-invalid 拒（r19-p7 首拒根因，2026-10-26 修正本配方）",
         "一次写只建一个方法；给既有服务加方法走 method.create（escape hatch）",
     ],
     priorToolReferences: [
@@ -92,10 +93,10 @@ const methodCreateRestfulGet = Object.freeze({
         name: "供应商查询",
         methodConfig: { httpType: "Get", requestBodyType: "JSON", url: "/openapi/supplier/query", frontEndExtensionEnable: true },
         methodInputParameters: [
-            { code: "keyword", name: "关键字", required: true, configJson: { position: "QUERY_PARAMS" } },
-            { code: "x-lowcode-corpId", name: "企业ID（平台注入常量）", required: false, codeType: 0, bizCode: "<corpId>", configJson: { position: "REQUEST_HEADER" } },
+            { code: "keyword", name: "关键字", required: true, bizPropertyType: "SHORT_TEXT", configJson: { position: "QUERY_PARAMS" } },
+            { code: "x-lowcode-corpId", name: "企业ID（平台注入常量）", required: false, bizPropertyType: "SHORT_TEXT", codeType: 0, bizCode: "<corpId>", configJson: { position: "REQUEST_HEADER" } },
         ],
-        methodOutputParameters: [{ code: "name", name: "供应商名称", configJson: { position: "REQUEST_BODY" } }],
+        methodOutputParameters: [{ code: "name", name: "供应商名称", bizPropertyType: "SHORT_TEXT", configJson: { position: "REQUEST_BODY" } }],
     },
     preconditions: ["服务已存在（method.create 只加方法）；methodCode 未存在；RESTFUL 每个入参与出参都带 configJson.position"],
     conditionalRequirements: [
@@ -127,8 +128,8 @@ const methodCreateRestfulPost = Object.freeze({
         methodCode: "saveSupplier",
         name: "供应商保存",
         methodConfig: { httpType: "Post", requestBodyType: "JSON", url: "/openapi/supplier/save", frontEndExtensionEnable: true },
-        methodInputParameters: [{ code: "body", name: "供应商对象", required: true, configJson: { position: "REQUEST_BODY" } }],
-        methodOutputParameters: [{ code: "id", name: "主键", configJson: { position: "REQUEST_BODY" } }],
+        methodInputParameters: [{ code: "body", name: "供应商对象", required: true, bizPropertyType: "SHORT_TEXT", configJson: { position: "REQUEST_BODY" } }],
+        methodOutputParameters: [{ code: "id", name: "主键", bizPropertyType: "SHORT_TEXT", configJson: { position: "REQUEST_BODY" } }],
     },
     preconditions: ["服务已存在；methodCode 未存在；POST 入参 position=REQUEST_BODY，requestBodyType=JSON"],
     conditionalRequirements: [

package/dist/recipes/businessrule.js

@@ -255,6 +255,7 @@ const ruleCrossModelCreate = Object.freeze({
         "上游是 QUERY 时 `inputParam=\"_<QUERY节点code>_output\"`（QUERY 查 N 行→CREATE 逐条生成即 N→N 扇出，真机验证支持，同/跨模型均可）；否则 `\"_input\"`。",
         "`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 回读核对。",
     ],
     priorToolReferences: [
         { tool: "field.list", args: { environment, schemaCode: "<targetModel>", published: true }, purpose: "确认目标模型/字段已发布" },
@@ -269,7 +270,63 @@ const ruleCrossModelCreate = Object.freeze({
     ],
     requiresEnvironmentDerivedIds: false,
 });
+/**
+ * r19 p7（2026-10-26）：「Create 规则调用二开服务回写」在真机上全链路走通，但
+ * agent 为 methodMapping 形状 describe 了 rule.save 4 次（最大 16.8KB）——五条
+ * 既有配方里只有 data-duplicate-flag 带单向 inputMappings。本配方以 p7 的真实
+ * 成功参数为模板（输入 cname→来源字段、输出 level→目标字段，codeType:1），
+ * 双向映射一步可抄。
+ */
+const ruleBizactionInvokeService = Object.freeze({
+    id: "rule-bizaction-invoke-service",
+    title: "Create 规则调用服务方法并映射回写（BIZ_ACTION 双向）",
+    aliases: ["服务方法", "调用服务", "BIZ_ACTION", "回写服务", "查服务回写"],
+    status: "requires-prior-readback",
+    tool: "rule.save",
+    args: {
+        environment,
+        schemaCode: model,
+        ruleCode: "Create",
+        name: "数据新增",
+        nodeGraph: {
+            nodes: [
+                { nodeCode: "Start", nodeName: "开始", nodeType: "START" },
+                { nodeCode: "A1", nodeName: "调用服务并回写", nodeType: "BIZ_ACTION", inputParam: "_input", methodMapping: { schemaCode: model, serviceCode: "<svc>", serviceMethodCode: "<method>", inputMappings: [{ serviceMethodParameterCode: "<in_code>", codeType: 1, bizCode: "<src_field>", required: true }], outputMappings: [{ serviceMethodParameterCode: "<out_code>", codeType: 1, bizCode: "<dst_field>" }] } },
+                { nodeCode: "Create", nodeName: "新增数据", nodeType: "SYSTEM_CREATE", isSystemNode: true },
+                { nodeCode: "End", nodeName: "结束", nodeType: "END" },
+            ],
+            routes: [
+                { preNode: "Start", postNode: "A1", routeCondition: true },
+                { preNode: "A1", postNode: "Create", routeCondition: true },
+                { preNode: "Create", postNode: "End", routeCondition: true },
+            ],
+        },
+        publish: true,
+    },
+    preconditions: [
+        "模型与来源/目标字段已发布；服务与方法已注册（service.register 的 readback.method 直接给参数 code）",
+        "方法出参类型（bizPropertyType）与目标字段类型匹配",
+    ],
+    conditionalRequirements: [
+        "codeType:1 = 映射模型字段（bizCode=字段 code）；codeType:0 = 常量（bizCode=常量值）；serviceMethodParameterCode 必须与方法声明的参数 code 逐字一致",
+        "**接口响应必须在 JSON 根级**返回与出参 code 同名的键——嵌套在信封里（如 {data:{level}}）会静默映射不上（p7 实测）",
+        "**平台自调自己（127.0.0.1）会被运行时鉴权拦**：errcode 500012「绑定的API需要提供正确的身份验证或凭据」——需要带出站凭据的真实外部服务，或服务端配置鉴权放行；这不是 BIZ_ACTION 不支持（p7 定案）",
+        "BIZ_ACTION 放在 SYSTEM_CREATE **之前**（与自更新 UPDATE 相反：ASSIGN/BIZ_ACTION 在系统节点前，UPDATE 在系统节点后）",
+    ],
+    priorToolReferences: [
+        { tool: "service.register", args: { environment }, purpose: "注册服务+方法；readback.method 内联参数面（code/bizPropertyType），不必再 service.get" },
+    ],
+    dryRun: { supported: true, command: `omc call rule.save --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 跑图 lint + 映射键校验（schemaCode/serviceCode/serviceMethodCode 非空、codeType 枚举）；服务参数面一致性真机 save 才核" },
+    expectedReadback: { readback: { published: true, enabled: false, next: "rule.enable → data.submit 触发 → data.load 读回目标字段" } },
+    refusalRecovery: [
+        { code: "rule-graph-bizmethod-unresolved", action: "serviceCode/serviceMethodCode 必须是已注册服务（service.list）；方法级详情 service.get" },
+        { code: "rule-graph-bizaction-mapping-field-missing", action: "inputMappings 的 bizCode 必须是本模型已发布字段 code（field.list 核对）" },
+        ...commonRecovery,
+    ],
+    notes: "p7 实测链（sandbox-r19/.scratch/report-p7.md §4）：注册查询服务 → 本配方建 Create 规则 → rule.enable → 提交触发。运行期若 500012 见 conditionalRequirements 第 3 条（出站凭据边界）",
+    requiresEnvironmentDerivedIds: true,
+});
 export const BUSINESSRULE_METADATA = Object.freeze({
-    "rule.save": Object.freeze({ recipes: [ruleGraph, ruleBranchGraph, ruleTimingTask, dataDuplicateFlag, ruleCrossModelCreate], relatedTools: ["field.list", "rule.get", "rule.enable"] }),
+    "rule.save": Object.freeze({ recipes: [ruleGraph, ruleBranchGraph, ruleTimingTask, dataDuplicateFlag, ruleCrossModelCreate, ruleBizactionInvokeService], relatedTools: ["field.list", "rule.get", "rule.enable", "service.get"] }),
 });
 //# sourceMappingURL=businessrule.js.map