@stalfh233/omc-cli 0.4.100 → 0.4.102

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

@@ -1508,7 +1508,7 @@ async function main() {
         .option("--schema <schemaCode>", "模型 code")
         .option("--schema-code <schemaCode>")
         .option("--rule-code <ruleCode>")
-        .option("--name <name>")
+        .option("--name <name>", "规则显示名（rule.save 的 name 位；与既有规则同名则覆盖更新）")
         .option("--node-graph <json>", "规则图 {nodes,routes} JSON")
         .option("--publish", "保存后同时发布规则版本")
         .option("--env <environment>")

package/dist/compound-writes.js

@@ -225,18 +225,25 @@ export async function runRuleSaveEnable(options) {
  *    droppedNodes 列明。
  * 两种路径都不依赖平台的合并/整替行为：最终模板由本命令显式合成。
  */
+/**
+ * 节点码/类型的读取兼容真机与 fake 两种投影（r22 2026-10-27 真机实证：
+ * workflow.get_draft 真机节点形如 {"index":0,"code":"Activity1","type":"START"}，
+ * 而本命令原读法 activityCode/activityType 恒空 → preservedNodes 恒空）。
+ */
+const activityCodeOf = (activity) => String(activity.activityCode ?? activity.code ?? "");
+const activityTypeOf = (activity) => String(activity.activityType ?? activity.type ?? "").toUpperCase();
 function composeFinalTemplate(draftActivities, template, confirmReplace) {
-    const newCodes = new Set((template.activities ?? []).map((activity) => String(activity.activityCode ?? "")));
+    const newCodes = new Set((template.activities ?? []).map((activity) => activityCodeOf(activity)));
     const oldNodes = draftActivities.filter((activity) => {
-        const code = String(activity.activityCode ?? "");
+        const code = activityCodeOf(activity);
         return code !== "" && !newCodes.has(code);
     });
-    const oldCodes = oldNodes.map((activity) => String(activity.activityCode ?? ""));
+    const oldCodes = oldNodes.map((activity) => activityCodeOf(activity));
     if (confirmReplace || oldCodes.length === 0) {
         return { finalTemplate: template, preservedNodes: [], droppedNodes: confirmReplace ? oldCodes : [] };
     }
     const activities = template.activities ?? [];
-    const endIndex = activities.findIndex((activity) => String(activity.activityType ?? "").toUpperCase() === "END");
+    const endIndex = activities.findIndex((activity) => activityTypeOf(activity) === "END");
     const merged = endIndex >= 0
         ? [...activities.slice(0, endIndex), ...oldNodes, ...activities.slice(endIndex)]
         : [...activities, ...oldNodes];
@@ -251,7 +258,11 @@ export async function runWorkflowUpdatePublish(options) {
     }
     const draft = options.apply ? await invoke("workflow.get_draft", { schemaCode: options.schema, ...(options.code ? { code: options.code } : {}) }) : { status: "ok", data: null };
     const draftData = (draft.data ?? null);
-    const draftActivities = (draftData?.activities ?? draftData?.template?.activities ?? []);
+    // r22 真机实证：真机投影在 workflowSummary.activities；fake 在 activities/template.activities——三口径全兼容。
+    const draftActivities = (draftData?.workflowSummary?.activities
+        ?? draftData?.activities
+        ?? draftData?.template?.activities
+        ?? []);
     const { finalTemplate, preservedNodes, droppedNodes } = composeFinalTemplate(draftActivities, options.template, options.confirmReplace === true);
     if (!options.apply) {
         emit({

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/field-change.js

@@ -2,6 +2,7 @@ import { FIELD_PROPERTY_TYPES } from "./field-families.js";
 import { assertFormConditions, assertNumericalScale, assertFieldOptionsAllowed, buildChildTableSubSchema, buildFieldOptions, ensureRelationDisplayFieldOptions, normalizeFieldPropertyType, relationDisplayFieldCode, } from "./field-families.js";
 import { nameI18nJson } from "./field-families.js";
 import { decodeJsonObjectColumn } from "./json-column.js";
+import { normalizeFormConditionOptions } from "./lanes/datarule-protocol.js";
 import { ToolRefusalError } from "./tool-types.js";
 /**
  * Fail-closed relation-target gate (round17 dogfood R3). A relation field whose
@@ -75,6 +76,10 @@ export function fieldChangeWireBody(input, prepared) {
     };
 }
 export function prepareFieldUpdate(input) {
+    // r26 快速装载：符号式/裸值条件就地编译为平台中文规范形状（合规式零改写）。
+    const normalizedOptions = input.options === undefined ? undefined : normalizeFormConditionOptions(input.options);
+    const effectiveOptions = normalizedOptions?.options;
+    const conditionCompiled = normalizedOptions?.compiledNotes ?? [];
     const recordType = Number(input.base.type ?? input.base.propertyType);
     const isChildTable = recordType === FIELD_PROPERTY_TYPES.CHILD_TABLE;
     if (isChildTable && (input.options !== undefined || input.choices !== undefined || input.subFields !== undefined))
@@ -93,10 +98,10 @@ export function prepareFieldUpdate(input) {
             ...buildFieldOptions({
                 propertyType: recordType,
                 ...(input.choices ? { choices: input.choices } : {}),
-                ...(input.options ? { options: input.options } : {}),
+                ...(effectiveOptions ? { options: effectiveOptions } : {}),
             }),
         });
-    if (!isChildTable && !input.options && !input.choices)
+    if (!isChildTable && !effectiveOptions && !input.choices)
         Object.assign(nextOptions, currentOptions);
     if (!isChildTable) {
         // An update that touches a relation's options must keep a resolvable target:
@@ -104,10 +109,10 @@ export function prepareFieldUpdate(input) {
         // field.publish cannot later 300010 on this field.
         assertRelationTargetPresent(recordType, nextOptions, input.relativeCode ?? (typeof input.base.relativeCode === "string" ? input.base.relativeCode : undefined), input.code);
         assertFieldOptionsAllowed(recordType, nextOptions, input.schemaCode);
-        if (input.options !== undefined || input.choices !== undefined)
+        if (effectiveOptions !== undefined || input.choices !== undefined)
             assertNumericalScale(recordType, nextOptions);
-        if (input.options !== undefined)
-            assertFormConditions(input.options);
+        if (effectiveOptions !== undefined)
+            assertFormConditions(effectiveOptions);
     }
     // Ticket 61: an explicit displayField wins; otherwise preserve the stored
     // top-level relativePropertyCode (the runtime reads it, not options).
@@ -119,7 +124,7 @@ export function prepareFieldUpdate(input) {
         : input.name !== undefined
             ? nameI18nJson(input.name)
             : (typeof input.base.name_i18n === "string" ? input.base.name_i18n : undefined);
-    return { propertyType: recordType, isChildTable, options: nextOptions, ...(displayCode !== undefined ? { displayCode } : {}), ...(name !== undefined ? { name } : {}), ...(nameI18n !== undefined ? { nameI18n } : {}) };
+    return { propertyType: recordType, isChildTable, options: nextOptions, ...(conditionCompiled.length > 0 ? { conditionCompiled } : {}), ...(displayCode !== undefined ? { displayCode } : {}), ...(name !== undefined ? { name } : {}), ...(nameI18n !== undefined ? { nameI18n } : {}) };
 }
 /** The single field-update wire body: the stored row spread with changed keys. */
 export function fieldUpdateWireBody(input, prepared) {

package/dist/field-families.js

@@ -167,7 +167,7 @@ export const fieldOptionsArg = z
     schemaCode: z.string().optional().describe("relation target model code (WORK_SHEET / MULT_WORK_SHEET)"),
     queryCode: z.string().optional().describe("relation query code (usually the target model code)"),
     displayField: z.string().optional().describe("relation display field (usually 'name')"),
-    mappings: z.string().optional().describe('relation carry mappings, e.g. [{"source":"<target field code>","target":"<this-model field code>"}]'),
+    mappings: z.union([z.string(), z.array(z.object({ source: z.string(), target: z.string() }))]).optional().describe('relation carry mappings——数组 [{"source":"<target field code>","target":"<this-model field code>"}] 或等价 JSON 字符串均可，CLI 就地归一（空数组/"[]" → 无映射）'),
     searchFormula: jsonString().optional().describe("WORK_SHEET / MULT_WORK_SHEET data restriction range JSON"),
     conditions: jsonString().optional().describe("WORK_SHEET / MULT_WORK_SHEET query conditions JSON"),
     optionsSet: optionsSetArg.optional().describe("selection source: custom, dictionary, or businessModel"),
@@ -495,6 +495,64 @@ function normalizeBusinessModelCondition(businessModel) {
     if (parts.length > 0)
         businessModel.condition = parts.join("&&");
 }
+/**
+ * r26 快速装载（2026-10-28）：关联带出 mappings 的就地归一。agent 最自然的
+ * 写法是数组 `mappings:[{source:"contract_name",target:"contract_name"}]`——
+ * 此前静默失效（wire 成数组形态，平台只认 JSON 字符串），必须照 describe
+ * 拼字符串（r24/r26 各 ~15 轮试错的来源之一）。归一规则：
+ *  - 数组：空数组 → `""`（无映射规范形态，规避 `"[]"` 假"已设置"坑）；
+ *    非空逐项必须是 `{source,target}` 非空字符串 → 紧凑 JSON 字符串
+ *  - 字符串：`"[]"` → `""`；可 JSON.parse 的必须解析为 `[{source,target}]`
+ *    形状（坏结构教学拒绝）；parse 失败按原样拒绝
+ *  - 其它类型拒绝教学
+ */
+export function normalizeMappingsOption(options) {
+    if (!("mappings" in options) || options.mappings === undefined)
+        return { options };
+    const mappings = options.mappings;
+    const mappingsError = (detail) => refuseFieldOptions(`relation mappings fail the reproduced protocol`, `rejected: options.mappings ${detail}；合法形状：JSON 字符串 [{"source":"<来源字段>","target":"<目标字段>"}] 或等价数组；无映射用 ""（不是 "[]"——"[]" 会让设计器显示"已设置"但弹窗无映射行）`);
+    let normalized;
+    if (Array.isArray(mappings)) {
+        if (mappings.length === 0)
+            normalized = "";
+        else {
+            const rows = mappings.map((row) => {
+                if (row === null || typeof row !== "object" || Array.isArray(row))
+                    mappingsError("数组每项必须是 {source,target} 对象");
+                const record = row;
+                const source = record.source;
+                const target = record.target;
+                if (typeof source !== "string" || source.trim() === "" || typeof target !== "string" || target.trim() === "")
+                    mappingsError("每项的 source/target 必须是非空字符串");
+                return { source: source.trim(), target: target.trim() };
+            });
+            normalized = JSON.stringify(rows);
+        }
+    }
+    else if (typeof mappings === "string") {
+        const trimmed = mappings.trim();
+        if (trimmed === "" || trimmed === "[]")
+            normalized = "";
+        else {
+            let parsed;
+            try {
+                parsed = JSON.parse(trimmed);
+            }
+            catch {
+                mappingsError(`字符串必须可解析为 JSON 数组（收到：${trimmed.slice(0, 40)}…）`);
+            }
+            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 非空字符串）");
+            normalized = JSON.stringify(parsed.map(({ source, target }) => ({ source: source.trim(), target: target.trim() })));
+        }
+    }
+    else
+        mappingsError(`必须是 JSON 字符串或数组（收到 ${typeof mappings}）`);
+    const next = { ...options, mappings: normalized };
+    // note 只在「形态」变化（数组→字符串 / "[]"→""）时给；纯 trim 不算。
+    const shapeChanged = Array.isArray(mappings) || (typeof mappings === "string" && mappings.trim() === "[]");
+    return { options: next, ...(shapeChanged ? { note: `options.mappings 已归一为平台字符串形态：${normalized === "" ? "空串（无映射）" : String(normalized)}` } : {}) };
+}
 export function buildFieldOptions(args) {
     const explicit = args.options;
     const raw = args.propertyType;
@@ -513,7 +571,7 @@ export function buildFieldOptions(args) {
                 refuseFieldOptions("selection field options carry no optionsSet source", `rejected: ${choiceError}`);
         }
         normalizeBusinessModelOrderBy(explicit);
-        return explicit;
+        return normalizeMappingsOption(explicit).options;
     }
     const choices = args.choices;
     if (Array.isArray(choices) && choices.length > 0) {

package/dist/goal-routes.js

@@ -556,6 +556,75 @@ 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 只能靠拒收文案自己悟。
+    // r27 探针（2026-10-28）：普通字段的条件必填/显隐/只读——「为字段配置条件必填…规则」
+    // 这类措辞被判成 read-ladder（"要查看哪个对象？"），agent 被迫自行探索并先撞
+    // datarule.create（配方明令禁止的路线）再折回 field.update，单意图浪费约 15 次调用。
+    // 触发词面：条件必填/必填条件/条件显隐/显示条件/隐藏条件/条件只读/只读条件 +
+    // 配置/设置/改成/修改/加上 等写动词，或直接点名 requiredFormula/displayFormula/
+    // readonlyCondition。不提「子表/控件」（那是上一条表单 attributes 的专项路由）。
+    if (!/子表/.test(goal)
+        && !/查看|有哪些|是什么|怎么|列出|看看|查询|检查|确认/.test(goal)
+        && (/条件必填|必填条件|条件显隐|显隐条件|显示条件|条件显示|隐藏条件|条件隐藏|条件只读|只读条件|requiredFormula|displayFormula|readonlyCondition/.test(goal))
+        && /配置|设置|改成|修改|加上|加一个|做个|做一|变必填|控制|当.*时/.test(goal)) {
+        return {
+            status: "ok",
+            goal,
+            confident: true,
+            mode: "modify",
+            write: true,
+            match: { kind: "recipe", ref: "form-conditional-required", title: "字段层条件必填/显隐/只读（field.update options 面）" },
+            route: {
+                capability: "field",
+                lane: "field-families",
+                note: "普通字段的条件必填（requiredFormula）/条件显隐（displayFormula）/条件只读（readonlyCondition）都在字段 options 面：field.update 写入即自动配对 bizdatarule 3/4/5 行（回执 formConditionSync）。表达式可用自然符号式（{字段} = \"值\" / {字段} >= 5000 / {字段} 不为空），CLI 就地编译为平台中文形状。**不要用 datarule.create**——type4 不让门户控件变必填（实测）。",
+                readiness: DISCOVERY_AUTHORITY.readiness,
+                firstCommands: [
+                    "omc describe field.update --example form-conditional-required",
+                    "omc call field.list --args '{\"schemaCode\":\"<schemaCode\",\"full\":true}'",
+                ],
+                write: true,
+            },
+            firstAnswer: {
+                state: "needs-input",
+                question: "目标模型 schemaCode 与字段 code 是什么？（给我 schemaCode 或业务名，我列清单核对）",
+                action: LIST_MODELS_ACTION,
+                pendingCommand: "omc call field.update --args '{\"schemaCode\":\"<schemaCode>\",\"code\":\"<字段code>\",\"options\":{\"requiredFormula\":\"{触发字段} 等于 某值\"}}'",
+                why: "命中字段层条件三件套路由：field.update 的 options.requiredFormula/displayFormula/readonlyCondition（表达式支持符号式就地编译）",
+            },
+        };
+    }
+    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",