@stalfh233/omc-cli 0.6.14 → 0.6.16

package/dist/batch-call.js

@@ -20,6 +20,54 @@
  */
 import { refusalText } from "./cli-contract.js";
 import { runScript } from "./script.js";
+function inputBusinessKey(args) {
+    const keys = ["code", "name", "bizObjectId", "id"];
+    const out = {};
+    for (const key of keys)
+        if (args[key] !== undefined)
+            out[key] = args[key];
+    return out;
+}
+function failureDetails(entry, args) {
+    const message = refusalText(entry.result);
+    const formData = args.formData && typeof args.formData === "object" && !Array.isArray(args.formData)
+        ? args.formData
+        : args;
+    const numericName = Object.keys(formData).find((key) => /amount|qty|quantity|price|number|count/i.test(key));
+    const numericValue = numericName === undefined ? undefined : formData[numericName];
+    if (numericName !== undefined && typeof numericValue === "string" && /50000|服务异常|wire-business/i.test(message)) {
+        return {
+            fieldCode: numericName,
+            value: numericValue,
+            reason: `NUMERICAL 字段收到字符串 "${numericValue}"`,
+        };
+    }
+    return { hint: "平台回了无明细 50000，常见成因见 help omc-refusals；请用该行输入与已发布字段逐项核对" };
+}
+export function batchWarnings(argsList) {
+    const warnings = [];
+    const seenCodes = new Map();
+    argsList.forEach((args, index) => {
+        const row = index + 1;
+        const data = args.formData && typeof args.formData === "object" && !Array.isArray(args.formData) ? args.formData : args;
+        if (data.code === undefined || data.code === null || data.code === "")
+            warnings.push({ row, fieldCode: "code", code: "required", message: "必填字段 code 缺失" });
+        else if (typeof data.code === "string") {
+            const previous = seenCodes.get(data.code);
+            if (previous !== undefined)
+                warnings.push({ row, fieldCode: "code", code: "duplicate", message: `code 与第 ${previous} 行重复` });
+            else
+                seenCodes.set(data.code, row);
+        }
+        for (const [fieldCode, value] of Object.entries(data)) {
+            if (typeof value === "string" && value.length > 255)
+                warnings.push({ row, fieldCode, code: "maxLength", message: `${fieldCode} 长度 ${value.length} 超过常见上限 255` });
+            if (typeof value === "number" && !Number.isInteger(value) && /qty|quantity|count|level/i.test(fieldCode))
+                warnings.push({ row, fieldCode, code: "scale-exceeded", message: `${fieldCode} 含小数，但字段可能是 0 位数值字段` });
+        }
+    });
+    return warnings;
+}
 /** Cap mirrors `omc script`: a runaway list should be a refusal, not a 20-min hang. */
 export const BATCH_MAX_ENTRIES = 200;
 /**
@@ -69,9 +117,12 @@ export async function runBatchCall(options) {
         .filter((entry) => entry.status !== "ok")
         .map((entry) => ({
         index: entry.index,
+        row: entry.index + 1,
+        indexBase: 0,
         status: String(entry.result.status ?? "failed"),
         blocker: entry.result.blocker ?? null,
         message: refusalText(entry.result),
+        ...failureDetails(entry, options.argsList[entry.index] ?? {}),
         ...(Array.isArray(entry.result.issues) ? { issues: entry.result.issues } : {}),
     }));
     const executed = entries.length;
@@ -92,7 +143,10 @@ export async function runBatchCall(options) {
         const skippedMarker = performed?.skipped;
         return {
             index: entry.index,
+            row: entry.index + 1,
+            indexBase: 0,
             ok: entry.status === "ok",
+            ...inputBusinessKey(options.argsList[entry.index] ?? {}),
             ...(bizObjectId !== undefined ? { bizObjectId } : {}),
             ...(entry.status === "ok" ? {} : { status: String(entry.result.status ?? "failed"), blocker: entry.result.blocker ?? null }),
             ...(skippedMarker !== undefined ? { skipped: String(skippedMarker) } : {}),
@@ -112,6 +166,7 @@ export async function runBatchCall(options) {
             // 每条一行摘要（index/ok/bizObjectId）——不是完整信封，但足以回答
             // 「第 3 条建成了吗、它的 id 是什么」。失败项另有 failures 带完整原因。
             entries: entriesInline,
+            ...(batchWarnings(options.argsList).length > 0 ? { warnings: batchWarnings(options.argsList) } : {}),
             ...(entries.length > entriesInline.length
                 ? { entriesOmitted: entries.length - entriesInline.length, entriesHint: `条目超过 ${ENTRIES_INLINE_LIMIT} 条，只内联前 ${ENTRIES_INLINE_LIMIT} 条摘要；完整结果走 detailArtifactId / omc artifact get` }
                 : {}),

package/dist/capability-overview.js

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

package/dist/cli.js

@@ -463,9 +463,10 @@ async function cmdBatchCall(store, toolName, rawList, options) {
                 failures.push({ index, blocker: payload.blocker ?? null, message: refusalText(payload), ...(Array.isArray(payload.validation) ? { validation: payload.validation } : {}), ...(payload.citation !== undefined ? { citation: payload.citation } : {}) });
             }
         });
-        const result = {
+        let result = {
             status: failures.length > 0 ? "partial" : "ok",
             mode: "preflight",
+            shapeOnly: true,
             tool: toolName,
             requested: entries.length,
             shapeChecked: entries.length,
@@ -473,8 +474,16 @@ async function cmdBatchCall(store, toolName, rawList, options) {
             writes: 0,
             // On failure the caller has to change the JSON first, so there is no
             // runnable command yet; on success, hand over the exact execution command.
-            ...(failures.length > 0 ? { failures } : { nextCommand: `omc call ${toolName} --args-list ${JSON.stringify(JSON.stringify(entries))}` }),
+            ...(failures.length > 0 ? { failures } : { nextCommand: `omc call ${toolName} --args-list '<file|stdin>'` }),
         };
+        const preflightPaths = [...argvValues(options.args, "--extract"), ...argvValues(options.args, "--jq")]
+            .flatMap((path) => path.split(",")).map((path) => path.trim()).filter(Boolean);
+        const preflightKeys = options.args.includes("--extract-keys") || options.args.includes("--keys") || options.args.some((token, index) => token === "--jq" && (options.args[index + 1] === undefined || options.args[index + 1].startsWith("--")));
+        if (preflightPaths.length > 0 || preflightKeys) {
+            const projected = projectResultExtract(result, preflightPaths, preflightKeys);
+            if (projected !== undefined)
+                result = projected;
+        }
         const classified = classifyResult(result);
         writeEnvelope(envelope(classified.status, result, request, classified.error));
         return failures.length > 0 ? 1 : 0;
@@ -525,7 +534,7 @@ async function cmdCall(store, args) {
                 return emitTransportResult({ status: "ok", ...described, helpNote: "来自 omc describe；完整面用 omc describe <tool> [--full|--param|--example]" }, { request, maxOutputBytes });
             }
         }
-        console.error("用法：omc call <tool> [--env <环境>] [--args '<json>' | --args - (stdin) | --args-file <配置根内路径>] [--extract <path>]... [--jq [path]] [--extract-keys] [--args-list <json数组> [--preflight]]");
+        console.error("用法：omc call <tool> [--env <环境>] [--args '<json>' | --args - (stdin) | --args-file <配置根内路径（必须位于配置根内；跨目录临时文件用 --args -（stdin））>] [--extract <path>]... [--jq [path]] [--extract-keys] [--args-list <json数组> [--preflight]]");
         console.error("输出预算：--max-output-bytes 默认 65536（只约束最终 stdout 信封；读面 diet ~2048 独立外置 detailArtifactId）；artifact get 内联上限 8192");
         console.error("写入：由环境 writable 决定（只读环境拒写）；生产环境的写必须在 args 里带 confirmProduction:true。");
         return emit(toolName && toolName !== "help" ? "error" : "ok", {}, toolName && toolName !== "help" ? CLI_EXIT_CODES.invalidInput : 0);
@@ -536,6 +545,11 @@ async function cmdCall(store, args) {
     const argsList = flag("--args-list");
     if (argsList !== undefined)
         return cmdBatchCall(store, toolName, argsList, { environment, requestValue, args, preflight: args.includes("--preflight") });
+    if (args.includes("--preflight")) {
+        const message = "--preflight 仅用于 --args-list 批量形状；单次调用没有批量预检语义。请改用 --args-list，或移除 --preflight 后执行单次调用。";
+        writeEnvelope(envelope("error", {}, request, { code: "invalid-input", message, retryable: false }));
+        return CLI_EXIT_CODES.invalidInput;
+    }
     // 1.2 of issue 2026-10-23: read faces answer {detailArtifactId, sha256} and the
     // caller then needs a SECOND call to see one value (16 two-step chains in one
     // session; 15 more were pure --keys probes). `--extract <path>` (repeatable)
@@ -685,7 +699,7 @@ async function cmdCall(store, args) {
         const otherUnknown = unknownKeys.filter((key) => !APP_SCOPE_ARG_KEYS.has(key));
         if (tool.kind !== "write" && otherUnknown.length > 0) {
             if (!lenientArgs) {
-                const suggestions = otherUnknown.map((key) => ({ key, ...suggestArgumentKey(key, [...schemaKeys]) }));
+                const suggestions = otherUnknown.map((key) => ({ key, ...suggestArgumentKey(key, [...schemaKeys], toolName) }));
                 const pairs = suggestions.map((entry) => {
                     if (entry.closest)
                         return `${entry.key}→${entry.closest}`;
@@ -705,7 +719,7 @@ async function cmdCall(store, args) {
                 return emit("error", result, CLI_EXIT_CODES.invalidInput);
             }
             for (const key of otherUnknown) {
-                ignoredReadKeys.push({ key, ...suggestArgumentKey(key, [...schemaKeys]) });
+                ignoredReadKeys.push({ key, ...suggestArgumentKey(key, [...schemaKeys], toolName) });
             }
         }
     }
@@ -781,6 +795,10 @@ async function cmdCall(store, args) {
         const projected = projectResultExtract(result, extractPaths, extractKeys);
         if (projected !== undefined)
             result = projected;
+        // Projected reads are represented by extract[] (and rows[] for multi-path).
+        // Do not also copy the single-path value to top-level content.
+        if (extractPaths.length > 0 && !extractKeys && typeof result === "object" && result !== null)
+            delete result.content;
     }
     // 读面未知键的非阻断回显：放在投影**之后**，否则会被 --jq 的窄投影吞掉。
     if (ignoredReadKeys.length > 0 && typeof result === "object" && result !== null) {
@@ -828,8 +846,15 @@ const APP_SCOPE_ARG_KEYS = new Set(["appCode", "applicationCode", "application"]
  * 短键（≤5 字符）靠距离算不准，这里先查显式缩写表（与 tool-types 的 KEY_ALIAS_HINTS
  * 同源），命中且参数真实存在才用；否则退回 closestMatches。
  */
-export function suggestArgumentKey(key, schemaKeys) {
+export function suggestArgumentKey(key, schemaKeys, toolName) {
     const known = new Set(schemaKeys);
+    const normalizedTool = toolName?.toLowerCase() ?? "";
+    if ((normalizedTool.startsWith("workflow.") || normalizedTool.startsWith("workitem.")) && key === "code" && known.has("workflowCode"))
+        return { closest: "workflowCode" };
+    if (normalizedTool.startsWith("data.") && key === "id" && known.has("bizObjectId"))
+        return { closest: "bizObjectId" };
+    if (normalizedTool.startsWith("data.") && key === "ids" && known.has("bizObjectIds"))
+        return { closest: "bizObjectIds" };
     const aliases = KEY_ALIAS_HINTS[key.toLowerCase()] ?? [];
     for (const candidate of aliases) {
         if (known.has(candidate))
@@ -1616,17 +1641,22 @@ async function cmdGraphPull(environment, concurrency, transport) {
         return emitThrown(error, transport);
     }
 }
-function cmdGraphReferences(kind, code, transport) {
+function cmdGraphReferences(kind, code, transport, requestedEnvironment) {
     if (!["service", "model", "field"].includes(kind))
         return emitInvalid(transport, { message: "kind 必须是 service / model / field（同 rule.references 第一版边界）" });
     try {
         const result = queryGraphReferences(kind, code);
+        if (requestedEnvironment !== undefined && requestedEnvironment !== result.index.environmentName)
+            return emitResult({ status: "refused", blocker: "graph-environment-mismatch", message: `索引已绑定环境 ${result.index.environmentName}，不是 ${requestedEnvironment}；请先 omc graph pull --env ${requestedEnvironment}`, index: result.index }, transport);
         return emitResult({
             status: "ok",
             kind: result.kind,
             code: result.code,
             matches: result.matches,
             index: result.index,
+            // r35a-F4：覆盖声明必须透传——CLI 这里是白名单式重建，漏加就等于没修
+            // （matches:[] 曾被当成可安全删除的依据）。
+            ...(result.coverage !== undefined ? { coverage: result.coverage } : {}),
             ...(result.note !== undefined ? { note: result.note } : {}),
             ...(result.gapWarning !== undefined ? { gapWarning: result.gapWarning } : {}),
         }, transport);
@@ -2129,7 +2159,7 @@ async function main() {
         commandExitCode = CLI_EXIT_CODES.ok;
     });
     command.command("doctor").option("--environment <environment>").option("--env <environment>").option("--service <serviceCode>", "可选：体检单个业务集成服务的鉴权参数形状（掩码/占位/全 0 检出，WARN 非致命）").action(async (options) => { commandExitCode = await cmdDoctor(new ConfigStore(defaultPaths()), options.environment ?? options.env, options.service); });
-    command.command("call <tool>").option("--env <environment>").option("--environment <environment>").option("--args <json>").option("--args-file <path>").option("--args-list <json-array>", '同一工具跑 N 次（JSON 数组，每条一个 args 对象）；逐条执行、默认不中断，最后回 succeeded/failed 汇总。适合批量建字段等').option("--preflight", "与 --args-list 一起用：只跑参数校验 + 写前语义闸（零 wire、零写入），一次报全所有形状问题").option("--keys", "与 artifact get 的 --keys 同义（= --extract-keys）：列出本次结果 artifact 的顶层键与体积").addOption(new Option("--extract <path>", "在本次结果的 artifact 内取一个路径的值（可重复；省掉一次 artifact get）").argParser((value, previous = []) => [...previous, value]).default([])).addOption(new Option("--jq [path]", "同 --extract，并支持 [] 映射（如 items[].fields.planNo）；裸 --jq 列出结果的顶层键").argParser((value, previous = []) => [...previous, value]).default([])).option("--extract-keys", "列出本次结果 artifact 的顶层键与体积（省掉一次 artifact get --keys）").option("--max-output-bytes <bytes>", "最终 stdout 信封预算；默认 65536（投影/--jq 之后再判）；读面 diet(~2048) 独立外置 detailArtifactId，抬高本参数不会把已 diet 的大表重新内联；artifact get 内联上限 8192").option("--request-id <requestId>").option("--timeout-ms <milliseconds>").option("--wait <milliseconds>").option("--dry-run").addHelpText("after", `\n${onboardingHelp()}\n`).action(async (tool, options) => {
+    command.command("call <tool>").option("--env <environment>").option("--environment <environment>").option("--args <json>").option("--args-file <path>", "从文件读参数 JSON。**必须位于配置根内**（跨目录/系统临时文件会被拒）；免落盘用 `--args -`（stdin）").option("--args-list <json-array>", '同一工具跑 N 次（JSON 数组，每条一个 args 对象）；逐条执行、默认不中断，最后回 succeeded/failed 汇总。适合批量建字段等').option("--preflight", "与 --args-list 一起用：只跑参数校验 + 写前语义闸（零 wire、零写入），一次报全所有形状问题").option("--keys", "与 artifact get 的 --keys 同义（= --extract-keys）：列出本次结果 artifact 的顶层键与体积").addOption(new Option("--extract <path>", "在本次结果的 artifact 内取一个路径的值（可重复；省掉一次 artifact get）").argParser((value, previous = []) => [...previous, value]).default([])).addOption(new Option("--jq [path]", "同 --extract，并支持 [] 映射（如 items[].fields.planNo）；裸 --jq 列出结果的顶层键").argParser((value, previous = []) => [...previous, value]).default([])).option("--extract-keys", "列出本次结果 artifact 的顶层键与体积（省掉一次 artifact get --keys）").option("--max-output-bytes <bytes>", "最终 stdout 信封预算；默认 65536（投影/--jq 之后再判）；读面 diet(~2048) 独立外置 detailArtifactId，抬高本参数不会把已 diet 的大表重新内联；artifact get 内联上限 8192").option("--request-id <requestId>").option("--timeout-ms <milliseconds>").option("--wait <milliseconds>").option("--dry-run").addHelpText("after", `\n${onboardingHelp()}\n`).action(async (tool, options) => {
         const rest = [tool, ...(options.env ? ["--env", options.env] : []), ...(options.environment ? ["--environment", options.environment] : []), ...(options.args !== undefined ? ["--args", options.args] : []), ...(options.argsFile !== undefined ? ["--args-file", options.argsFile] : []), ...(options.argsList !== undefined ? ["--args-list", options.argsList] : []), ...(options.preflight ? ["--preflight"] : []), ...(Array.isArray(options.extract) ? options.extract.flatMap((path) => ["--extract", path]) : []), ...(Array.isArray(options.jq) ? options.jq.flatMap((path) => path === true ? ["--jq"] : ["--jq", path]) : []), ...(options.extractKeys ? ["--extract-keys"] : []),
             ...(options.keys ? ["--keys"] : []), ...(options.maxOutputBytes !== undefined ? ["--max-output-bytes", options.maxOutputBytes] : []), ...(options.requestId ? ["--request-id", options.requestId] : []), ...(options.timeoutMs !== undefined ? ["--timeout-ms", options.timeoutMs] : []), ...(options.wait !== undefined ? ["--wait", options.wait] : []), ...(options.dryRun ? ["--dry-run"] : [])];
         commandExitCode = await cmdCall(new ConfigStore(defaultPaths()), rest);
@@ -2412,18 +2442,19 @@ async function main() {
             console.error(`已清理 ${result.removed} 个读回产物，释放 ${formatBytes(result.freedBytes)}；保留 ${result.kept} 个（${formatBytes(result.keptBytes)}）`);
         commandExitCode = CLI_EXIT_CODES.ok;
     });
-    // r28h F3（真机 2026-11-05）：`omc call` 用 `--extract`、`artifact get` 用 `--jq`，
-    // 语义完全相同。探针先试 `--extract` 拿到 `unknown option`（白花一次往返），
-    // 才想起两者不同名。别名照收，help 里也标出来。
-    artifactCommand.command("get <id>").option("--jq [path]").option("--extract <path>", "同 --jq（与 omc call 的 --extract 同名，省一次命名切换）").option("--path-only").option("--summary").option("--keys [a,b]").option("--full", "整包返回正文（默认：正文超过 8KB 时只回形状 outline + fetch，按需 --jq/--keys 定向取值）").option("--max-output-bytes <bytes>").action(async (id, options) => {
+    artifactCommand.command("get <id>").addOption(new Option("--jq [path]").argParser((value, previous = []) => [...previous, value]).default([])).option("--extract <path>", "同 --jq（与 omc call 的 --extract 同名，省一次命名切换）").option("--path-only").option("--summary").option("--keys [a,b]").option("--full", "整包返回正文（默认：正文超过 8KB 时只回形状 outline + fetch，按需 --jq/--keys 定向取值）").option("--max-output-bytes <bytes>").action(async (id, options) => {
         // A bare `--jq`/`--keys` is a key-inventory request, not a missing argument:
         // commander's "argument missing" (invalid-input + retry) is a dead end the
         // caller cannot fix without already knowing the flag takes a value (r11
         // burned six rounds on `artifact get <id> --jq` before trying `--summary`).
         // --extract 是 --jq 的同义别名（r28h F3）。
-        const jqPath = typeof options.jq === "string" ? options.jq : typeof options.extract === "string" ? options.extract : undefined;
+        // 重复 --jq 的多路径合并为逗号路径透传（r34c-F8：此前静默只留最后一个）。
+        const jqPaths = [
+            ...(Array.isArray(options.jq) ? options.jq.filter((v) => typeof v === "string") : []),
+            ...(typeof options.extract === "string" ? [options.extract] : []),
+        ];
         const bareJq = options.jq === true;
-        commandExitCode = await withTransport(options, request, (transport) => cmdArtifactGet(id, transport, { ...(jqPath !== undefined ? { jq: jqPath } : {}), pathOnly: options.pathOnly === true, summary: options.summary === true || options.keys === true || bareJq,
+        commandExitCode = await withTransport(options, request, (transport) => cmdArtifactGet(id, transport, { ...(jqPaths.length > 0 ? { jq: jqPaths.join(",") } : {}), pathOnly: options.pathOnly === true, summary: options.summary === true || options.keys === true || bareJq,
             pureKeys: (options.keys === true || bareJq) && options.summary !== true, ...(typeof options.keys === "string" ? { keys: options.keys } : {}), full: options.full === true }));
     });
     command.command("bench").option("--live-sample").option("--env <environment>").action(async (options) => { commandExitCode = await cmdBench([...(options.liveSample ? ["--live-sample"] : []), ...(options.env ? ["--env", options.env] : [])]); });
@@ -2496,8 +2527,8 @@ async function main() {
         const parsed = options.concurrency === undefined ? undefined : Number.parseInt(String(options.concurrency), 10);
         commandExitCode = await withTransport(options, request, (transport) => cmdGraphPull(options.environment ?? options.env, parsed, transport));
     });
-    graphCommand.command("references <kind> <code>").option("--max-output-bytes <bytes>").addHelpText("after", "\n离线查询（零 wire）：kind = service|model|field，语义同 rule.references 第一版边界；结果带索引新鲜度与扫描缺口（有缺口时零命中不构成「无引用」证明）。\n").action(async (kind, code, options) => {
-        commandExitCode = await withTransport(options, request, (transport) => cmdGraphReferences(kind, code, transport));
+    graphCommand.command("references <kind> <code>").option("--env <environment>", "本子命令不接触环境；该参数仅用于提示索引绑定环境").option("--max-output-bytes <bytes>").addHelpText("after", "\n离线查询（零 wire）：kind = service|model|field，语义同 rule.references 第一版边界；结果带索引新鲜度与扫描缺口（有缺口时零命中不构成「无引用」证明）。覆盖：规则图/数据规则/视图；不含表单、workflow.permissions、流程绑定、在线 JS。在线版 rule.references 不含数据规则；两者都不含上述未扫描面。\n").action(async (kind, code, options) => {
+        commandExitCode = await withTransport(options, request, (transport) => cmdGraphReferences(kind, code, transport, options.environment ?? options.env));
     });
     graphCommand.command("impact <kind> <code>").option("--max-output-bytes <bytes>").addHelpText("after", "\n影响面（离线）：跳1=引用该编码的规则（同 references），跳2=这些规则还读写哪些 service/model/field——改前看爆炸半径。截断上限 50 规则×每类 20 码。\n").action(async (kind, code, options) => {
         commandExitCode = await withTransport(options, request, (transport) => cmdGraphImpact(kind, code, transport));

package/dist/discovery.js

@@ -588,7 +588,13 @@ export function describeParam(registry, name, param) {
         // r28e 真机（2026-11-05）：调用方看到 `status:"ok"` + 一堆键，误以为"参数存在、
         // 只是描述为空"。`found:false` 是机器信号，但人读时需要一句话点明——否则
         // 会照着 `available` 之外的名字继续试。
-        const nearest = closestMatch(param, Object.keys(schema.properties ?? {}));
+        const availableKeys = Object.keys(schema.properties ?? {});
+        // Prefer a same-tool semantic alias over a cross-tool same-name suggestion.
+        // `datarule.create --param type` means the rule discriminator, whose wire
+        // name is dataRuleType; recommending custompage.list's `type` sends the
+        // caller to the wrong tool family.
+        const semantic = name.startsWith("datarule.") && param === "type" && availableKeys.includes("dataRuleType") ? "dataRuleType" : undefined;
+        const nearest = semantic ?? closestMatch(param, availableKeys);
         return {
             name: tool.name,
             param,

package/dist/goal-routes.js

@@ -672,6 +672,29 @@ export function goalRoute(registry, goal) {
             firstAnswer: { state: "blocked", why: boundary.note },
         };
     }
+    if (/批量导入|批量写入|批量删除|导入数据/.test(goal)) {
+        const action = /批量删除/.test(goal) ? "data.delete" : "data.save";
+        return {
+            status: "ok", goal, confident: true, mode: "modify", write: true,
+            match: { kind: "capability", ref: "data", title: "运行数据批量写入（--args-list）" },
+            route: { capability: "data", lane: "runtime-data", note: "运行数据批量操作逐条执行，失败继续；先用 --preflight 做零写入形状校验", readiness: DISCOVERY_AUTHORITY.readiness, firstCommands: [`omc call ${action} --args-list '<file|stdin>' --preflight`, `omc call ${action} --args-list '<file|stdin>'`], write: true },
+            firstAnswer: { state: "needs-input", question: "目标模型 schemaCode 和输入文件/JSON 数组是什么？示例：omc call data.save --args-list '<file|stdin>' --preflight", action: LIST_MODELS_ACTION, pendingCommand: `omc call ${action} --args-list '<file|stdin>'`, why: "批量导入/写入/删除使用 --args-list；先预检形状，再逐条执行" },
+        };
+    }
+    // Cross-application model moves/copies are not an intent migration. There
+    // is no model.move/model.copy path across app boundaries: model.move only
+    // reparents a model within its current application. Keep the useful
+    // declarative route for rebuilding the target model, but put this fact in
+    // the route itself so callers cannot mistake intent for an in-place move.
+    if (/模型/.test(goal) && /(跨应用|一个应用.*另一个应用|从一个应用.*到另一个应用)/.test(goal) && /(移动|复制|迁移|搬)/.test(goal)) {
+        const routed = wholePackageRoute(registry, goal, index, ["app", "model"]);
+        const clarification = "事实澄清：没有跨应用迁移/复制模型的专用工具；model.move 仅支持同一应用内换目录。跨应用移植需要在新应用重建模型，并手工搬运数据。";
+        return {
+            ...routed,
+            route: { ...routed.route, note: clarification },
+            firstAnswer: { ...routed.firstAnswer, why: `${clarification} ${routed.firstAnswer.why}` },
+        };
+    }
     // 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).

package/dist/graph.js

@@ -607,16 +607,26 @@ export function queryGraphReferences(kind, code) {
             via: row.via,
         }));
         const gapped = summary.gaps.count > 0;
+        // r35a-F4（真机 2026-11-06）：探针拿 matches:[] 差点把一个**被表单引用**的
+        // 字段判成「可安全删除」——note 只说了「不含规则条件叶子/流程绑定」，从没
+        // 明说表单与流程权限表不在扫描范围。散文字段不承担安全契约：这里给结构化
+        // coverage，让「没人引用」与「这一面没扫」在机器可读层面可分。
+        const coverage = {
+            scanned: ["businessrule", "datarule", "listview"],
+            notScanned: ["form", "workflow.permissions", "workflow.bindings", "onlinejs", "rule.conditions"],
+            note: "matches:[] 只代表 scanned 面零命中；notScanned 面（尤其 form 与 workflow.permissions）未扫描，不可据此判定可安全删除",
+        };
         return {
             kind,
             code,
             matches,
+            coverage,
             index: summary,
             ...(matches.length === 0
                 ? {
                     note: (gapped
                         ? "零命中，但索引存在扫描缺口——不可作为「无引用」证明；先 omc graph pull 重建再查"
-                        : "零命中=索引覆盖范围内没有引用它（规则面：service→methodMapping.serviceCode；model→targetObjectCode/methodMapping.schemaCode；field→dataActions.targetDataItem/映射 bizCode；数据规则面：propertyCodes 目标与 options {字段} 引用；视图面：列/排序/条件的 propertyCode。不含规则条件叶子/流程绑定）") +
+                        : "零命中=仅 scanned 面（规则/数据规则/视图）没有引用它；form（表单控件）与 workflow.permissions 未扫描，见 coverage.notScanned——不可据此判定可安全删除") +
                         (zeroHitKindHint(db, kind, code, "references") ?? ""),
                 }
                 : {}),

package/dist/human-summary.js

@@ -167,7 +167,10 @@ function phraseOf(tool, args, outcome) {
         case "datarule.create":
         case "datarule.update": {
             const type = DATA_RULE_TYPE_NAMES_ZH[Number(args.dataRuleType)] ?? `类型${String(args.dataRuleType ?? "?")}`;
-            return `${tool === "datarule.create" ? "创建" : "更新"}字段规则（${stringArg(args, "propertyCode") ?? "?"}，${type}），挂在 ${schemaCode ?? "?"}`;
+            const readbackRule = outcome?.readback?.after ?? outcome?.readback?.before;
+            const ruleName = readbackRule && typeof readbackRule === "object" ? stringArg(readbackRule, "name") : undefined;
+            const identity = ruleName ?? stringArg(args, "propertyCode") ?? (readbackRule && typeof readbackRule === "object" ? stringArg(readbackRule, "id")?.slice(0, 8) : undefined) ?? "?";
+            return `${tool === "datarule.create" ? "创建" : "更新"}字段规则（${identity}，${type}），挂在 ${schemaCode ?? "?"}`;
         }
         case "datarule.delete":
             return `删除字段规则 ${stringArg(args, "id") ?? "?"}（${schemaCode ?? "?"}）`;

package/dist/lanes/businessrule.js

@@ -141,12 +141,25 @@ export function registerBusinessRuleLane(tools) {
             // key (schemaCode+ruleCode), so the row id is rarely needed.
             const fullRows = args.full === true;
             const visible = args.onlyCustom === true ? rows.filter((row) => row.defaultRule !== true) : rows;
+            const statusLag = visible.some((row) => row.enabled === true && String(row.status ?? "") !== "ENABLED");
             return {
                 schemaCode: args.schemaCode,
                 modelPresent: true,
                 // r28g F18：list 投影的是 PUBLISH 行；运行时可执行性以 rule.get / rule.enable.verified 为准。
                 source: "published-list",
                 executableHint: "rules[].enabled/status 来自 PUBLISH 投影；运行时判定读 DRAFT（rule.get 的 enabled+ruleStatus，或 rule.enable 回执的 executable/verified）。不要仅凭本面判定可 rule.run。",
+                ...(statusLag
+                    ? {
+                        statusLag: true,
+                        statusNote: "本面 status 是 PUBLISH 投影列，与 rule.get 的 ruleStatus 可不同；检测到 enabled=true 而 status 非 ENABLED 的滞后行——enabled=true 才是分发真相，运行时以 rule.get/enable 复核",
+                    }
+                    : {
+                        // r35a-F7（真机 2026-11-06）：`status` 与 rule.get 的 `ruleStatus` 是
+                        // **不同 wire 列**，可一个 ENABLED 一个 DISABLED（探针实测
+                        // list status=ENABLED/ruleVersion=1 vs get ruleStatus=DISABLED/0）。
+                        // 常态化给一句短注（~90B/次），避免把本面 status 当运行时真相。
+                        statusNote: "本面 status 是 PUBLISH 投影列，与 rule.get 的 ruleStatus 可不同；运行时是否生效以 rule.get/enable 为准",
+                    }),
                 ...(args.onlyCustom === true ? { filtered: { onlyCustom: true, total: rows.length, returned: visible.length } } : {}),
                 ...(endpointFamily ? { endpointFamily } : {}),
                 rules: visible.map((row) => ({
@@ -154,6 +167,7 @@ export function registerBusinessRuleLane(tools) {
                     name: row.name,
                     enabled: row.enabled,
                     status: row.status,
+                    ...(row.enabled === true && String(row.status ?? "") !== "ENABLED" ? { statusLag: true } : {}),
                     ...(row.ruleVersion !== undefined ? { ruleVersion: row.ruleVersion } : {}),
                     ...(row.defaultRule !== undefined ? { defaultRule: row.defaultRule, preset: row.defaultRule === true } : {}),
                     // ticket-80's update-mode readback teaches following the same-code
@@ -270,6 +284,14 @@ export function registerBusinessRuleLane(tools) {
                 code: wanted,
                 scanned: { models: scoped.length, rules: scannedRules, ...(parseFailures > 0 ? { parseFailures } : {}) },
                 matches,
+                // r35a-F4（真机 2026-11-06）：matches:[] 曾被当成「可安全删除」的依据，
+                // 而探针实测该字段**被表单引用**（form.get draftControlCodes）且出现在
+                // 流程节点权限里——本面两者都没扫。散文字段不承担安全契约：结构化声明。
+                coverage: {
+                    scanned: ["businessrule"],
+                    notScanned: ["datarule", "form", "workflow.permissions", "workflow.bindings", "onlinejs", "listview"],
+                    note: "matches:[] 只代表 businessrule 面零命中；datarule/form/流程权限/视图等未扫描（离线 graph references 覆盖更广，见其 coverage），不可据此判定可安全删除",
+                },
                 ...(scope !== undefined ? { applicationResolution: applicationResolutionOf(scope) } : {}),
                 ...(matches.length === 0
                     ? {

package/dist/lanes/datarule-contract.js

@@ -17,7 +17,7 @@ export const DATARULE_WIRE = Object.freeze({
     delete: "bizdatarule/delete?id=<ruleId> (@RequestParam String id) with list exact-absence readback",
     dataRuleTypes: "DataRuleType: 1 CHECK_RULE (校验), 2 CALCULATE_RULE (计算/拼接), 3 DISPLAY_RULE (显示), 4 OTHER_RULE (必填), 5 READ_ONLY_RULE (只读); 8 EXTENSION_RULE is out of scope",
     dataRuleCheckTypes: "dataRuleType 1 (CHECK_RULE 提交校验规则) 的 checkType 判别（cloudpivot-shared DataRuleCheckType.java）——**校验类需求走这里，不要写在线 JS**：1 REGEX_CHECK 正则校验 / 2 SUBMIT_CHECK 提交校验（含跨字段比较）/ 3 EMPTY_ROW_CHECK 空行校验 / 4 MAX_LENGTH_CHECK 最大长度校验 / 5 REPEAT_CHECK 重复校验；checkType 只配 dataRuleType 1，缺省或非法值由工具拒绝。**数值上下限没有专用类型——用 checkType 2 提交校验表达（如 数量≥0：options 提交校验条件 {quantity}>=0，r21 实证）**",
-    optionsByCheckType: "各 checkType 的 options（engine/bo/datarule/impl/checkType/*）：1 REGEX_CHECK{regexp:'/…/',regexpText:{zh,en}}（regexp 必须斜杠包裹，RegexCheckValidator 会去掉首尾字符）；2 SUBMIT_CHECK{conditions:'<字段code> 操作符 <值> [&&| || 连接]', verifyType:'submitDenied'?（满足条件即拒绝提交，缺省为满足才允许）, prompt:'<提示，**纯文本**，勿 URL 编码——这种顶层 options.prompt 门户原样显示，编码过会显示成 %E5..乱码>' }（操作符 等于/不等于/大于/小于/大于等于/小于等于/为空/不为空…；**字段 vs 字面量**直接写值如 {qty} 大于 100；**跨字段**右值必须写实为值对象 {\"valueType\":\"currentModel\",\"value\":\"<字段code>\"}，如「结束日期不早于开始日期」= {end_date} 小于 {\"valueType\":\"currentModel\",\"value\":\"start_date\"}——裸 {字段code} 右值会原样落库但前端/服务端都不解析成字段值，规则静默不生效，工具拒绝）；3 EMPTY_ROW_CHECK{isEmptyRow,isEmptyRowTips}；4 MAX_LENGTH_CHECK{maxLength}；5 REPEAT_CHECK{properties:[<字段code>],isSubTableValidationAllData?,prompt:[{isDataItem,code}]}（重复提示逐项/数组解析，RepeatCheckValidator:258-272：**isDataItem=0 → code 是字面文案**，如 [{\"isDataItem\":0,\"code\":\"单号重复\"}]；**isDataItem=1 → code 是字段 code**，提示取该字段（值/名）。写成 isDataItem:1 + 字段code 会把提示显示成字段值而不是你要的文案；`promptText` 等未识别键平台会忽略，勿用）",
+    optionsByCheckType: "各 checkType 的 options 白名单（工具会拒绝 unknownOptionKeys，避免平台静默忽略；运行版 1.1.25 SubmitCheckValidator/RepeatCheckValidator 反编译实证 2026-11-06）：1 REGEX_CHECK{regexp,regexpText}；2 SUBMIT_CHECK{conditions,verifyType,prompt}（verifyType 的拒用取值=submitDenied——它是 verifyType 的值，不是独立键）；3 EMPTY_ROW_CHECK{isEmptyRow,isEmptyRowTips}；4 MAX_LENGTH_CHECK{maxLength}；5 REPEAT_CHECK{noRepeat,properties,isSubTableValidationAllData,prompt}。checkType-2 的 prompt 是纯文本（门户 raw 渲染 options.prompt，不做富文本解析）。重复提示逐项/数组解析，RepeatCheckValidator:258-272：isDataItem=0 → code 是字面文案；isDataItem=1 → code 是字段 code。checkType=5 的唯一去重键是 options.noRepeat（配合 properties），平台 REST 也会拦重复；conditions/regexp/maxLength 等只在门户前端提交面执行。",
     optionsByType: "options is a JSON string read per type: 1 check keys (verifyFormula/regexp/maxLength/isEmptyRow/noRepeat/conditions), 2 FormulaConfig — `shortTextStitch` (falling back to `value`) MUST be a JSON OBJECT STRING whose `formula` key holds the expression, e.g. {\"shortTextStitch\":\"{\\\"formula\\\":\\\"{field}\\\",\\\"editorText\\\":\\\"{字段名}\\\"}\"}; a bare \"{field}\" string fails JSONUtil.isJson → getCalRuleExpression returns null → false 305003 dead-cycle; `formulaType:\"AGGREGATION\"` instead reads `aggregation`; a top-level `expression` is NEVER read (it is only a key INSIDE that nested JSON), 3 displayFormula, 4 requiredFormula, 5 readonlyCondition",
     formulaReference: "类型2 公式引用按位置解析：裸 {字段}=**主记录**字段；带点 {子表code.字段}=**子表**字段（FormulaProcessor.constructSubExprParamsValueMap 要求点前等于子表 schema）。所以**主表公式**用裸 {字段}（带 {主表code.字段} 会按子表解析 → 值空/静默 null），**子表公式**（childRule:true）引用同级子字段必须带点 {子表code.字段}（裸引用被当主记录字段 → 值缺失 → 提交 50000）。工具在写前按子表已发布字段判定并拒绝裸引用（blocker datarule-formula-child-bare-reference），读回对存量子表公式加 formulaHint 提示复核。",
     optionsEncoding: "the engine JSON-parses the `options` column and reads requiredFormula / readonlyCondition / displayFormula / verifyFormula / shortTextStitch (whose VALUE is itself a JSON string carrying `formula`); send options as a stringified object",
@@ -85,6 +85,7 @@ export const DATARULE_LANE_CONTRACT = Object.freeze({
             scope: DATARULE_SCOPE,
             description: describeTool("Create a field-level data rule (bizdatarule/create) and read it back from the authoritative list. **表单运行时条件优先 `field.update`**（本工具=字段级引擎/设计器读面）。", [
                 "`dataRuleType` → options 键：1→conditions/prompt/regexp/maxLength（+checkType）；2→shortTextStitch|expression；3→displayFormula；4→requiredFormula（无条件必填=`\"true\"`）；5→readonlyCondition。8 EXTENSION out of scope.",
+                "`childRule:true` 仅用于已发布的子表列（propertyCode/propertyCodes 必须是子表列 code；主表字段省略）。子表列在发布面不可见时先用 field.create + field.publish 生成列，不要直接 POST datarule.create（r34a-F12 真机：childRule 三种形态全被发布面校验拒）。",
                 "**⚠️ type3/4/5 行的两个读面**：门户**运行时**读**字段 options**（`requiredFormula`/`readonlyCondition`/`readonlyFormula`/`displayFormula`，`field.create/update` 写）；表单设计器**设计态** Set/Unset 读 **bizdatarule/list**（本行，network capture 2026-09-23）。**实测：type3/4/5 规则单独不会让门户表单控件变必填/只读**（中文或符号操作符都一样），符号式经 `historyOpt` 镜像还会让表单渲染崩溃——运行时条件请用中文操作符。表单条件优先走 `field.update`：它会**自动配对**本行（readback.formConditionSync）。本工具用于字段级引擎规则或独立增删改。",
                 "**类型3/4/5 条件串协议（平台 create 不校验，坏形状落库即雷，工具按此协议拒绝）**：`{字段code} 操作符 [值]`。操作符取 **bizdatarule 词表**（与字段 options 的表单交互引擎不同——那是符号式）：**中文** 等于/不等于/大于/小于/大于等于/小于等于/包含/不包含/包含全部/不包含全部/包含任意一个/不包含任意一个/等于任意一个/属于/不属于/介于/为空/不为空（实测 146 条真实规则以此为主），也接受符号 `==` `!=` `>` `<` `>=` `<=` `Contains` `IsEmpty` 等。为空/不为空**不带值**（`{field} 不为空`）；其余带值（JSON 对象或标量）。多条件 ` && `、多组 ` || `。示例 type4：`options:{requiredFormula:\"{amount} 等于 {\\\"valueType\\\":\\\"specifyOption\\\",\\\"value\\\":\\\"A\\\"}\"}`；无条件必填用字面量 \"true\"。**字段绑定用 `propertyCodes`（数组）**，工具自动把 `options.propertyCodes` 也补上；存量的坏规则由 datarule.list 以 shapeWarning 标出。",
                 "`options` is a JSON object sent to the wire as a JSON string; the engine reads `requiredFormula` (4), `readonlyCondition` (5), `displayFormula` (3), `verifyFormula` (1) and `shortTextStitch` (2).",

package/dist/lanes/datarule.js

@@ -50,6 +50,15 @@ export const DATARULE_CHECK_TYPES = Object.freeze({
     4: "MAX_LENGTH_CHECK 最大长度校验（options.maxLength）",
     5: "REPEAT_CHECK 重复校验（options.properties 数组 + isSubTableValidationAllData + prompt）",
 });
+/** Options the 8.6.26 engine actually reads for each data-rule discriminator. */
+export const DATARULE_CHECK_OPTION_KEYS = Object.freeze({
+    1: Object.freeze(["regexp", "regexpText"]),
+    2: Object.freeze(["conditions", "verifyType", "prompt"]),
+    3: Object.freeze(["isEmptyRow", "isEmptyRowTips"]),
+    4: Object.freeze(["maxLength"]),
+    5: Object.freeze(["noRepeat", "properties", "isSubTableValidationAllData", "prompt"]),
+});
+const DATARULE_CALCULATE_MIRROR_KEYS = ["formulaType", "resultType"];
 const checkTypeArg = z
     .number()
     .int()
@@ -120,6 +129,16 @@ function decodeDataRule(row) {
         sortKey: row.sortKey ?? null,
         options,
     };
+    const optionKeys = effectiveOptionKeys(Number(row.dataRuleType), Number(row.checkType));
+    if (options !== null && typeof options === "object" && !Array.isArray(options)) {
+        const storedKeys = Object.keys(options).filter((key) => key !== "propertyCodes");
+        decoded.effectiveKeys = storedKeys.filter((key) => optionKeys.includes(key));
+        decoded.ignoredKeys = storedKeys.filter((key) => !optionKeys.includes(key));
+    }
+    else {
+        decoded.effectiveKeys = [];
+        decoded.ignoredKeys = [];
+    }
     // Round 4 (ADR 0005): read-side annotation. The platform accepted and stored
     // malformed option shapes for years; the same protocol validator that gates
     // writes marks stored landmines here. Report-only — stored data is never
@@ -159,6 +178,21 @@ function decodeDataRule(row) {
     }
     return decoded;
 }
+function effectiveOptionKeys(dataRuleType, checkType) {
+    if (dataRuleType === 1) {
+        if (checkType !== undefined)
+            return DATARULE_CHECK_OPTION_KEYS[checkType] ?? [];
+        return [...new Set(Object.values(DATARULE_CHECK_OPTION_KEYS).flat())];
+    }
+    return dataRuleType === 2 ? [...(DATARULE_TYPE_OPTION_KEYS[2] ?? []), ...DATARULE_CALCULATE_MIRROR_KEYS] : DATARULE_TYPE_OPTION_KEYS[dataRuleType] ?? [];
+}
+function dataRuleExecutionWarning(checkType) {
+    if (checkType === 5)
+        return "重复校验 noRepeat 由服务端拦截，REST `data.submit` 亦会拒绝重复数据（errcode 800150006）；properties 指定参与去重的字段。";
+    if (checkType === 1 || checkType === 2 || checkType === 3 || checkType === 4)
+        return "该校验规则仅由门户前端提交校验执行；REST `data.submit` 不拦截违规数据。需要服务端拦截请改用业务规则（BIZ_ACTION/条件）。";
+    return "校验规则的执行面取决于 checkType；请在门户提交面验收，未提供 checkType 时不要把 REST 行为视为已验证。";
+}
 /**
  * Fail closed when the options object cannot carry the key the engine reads
  * for this type (RequiredDataRuleValidator / ReadOnlyValidator /
@@ -354,6 +388,20 @@ export function assertDataRuleOptions(dataRuleType, options, checkType) {
             message: `dataRuleType ${dataRuleType} requires at least one of ${required.join(", ")} in options (those are the keys the 8.6.26 engine reads)`,
         });
     }
+    const ignored = Object.keys(options).filter((key) => key !== "propertyCodes" && !effectiveOptionKeys(dataRuleType, checkType).includes(key));
+    if (ignored.length > 0) {
+        const allowed = effectiveOptionKeys(dataRuleType, checkType);
+        const checkLabel = dataRuleType === 1 ? `checkType=${checkType ?? "?"}` : `dataRuleType=${dataRuleType}`;
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "datarule-unknown-option-keys",
+            dataRuleType,
+            ...(checkType === undefined ? {} : { checkType }),
+            unknownOptionKeys: ignored,
+            effectiveKeys: allowed,
+            message: `${checkLabel} 不读取 options 键：${ignored.join(", ")}；本类型有效键：${allowed.join(", ") || "（无）"}。平台会静默忽略这些键，拒绝写入以避免误以为规则生效`,
+        });
+    }
     // Round 4 (ADR 0005): types 3/4/5 gate on the reproduced condition protocol.
     // The platform itself does not validate these shapes at create time, so an
     // unguarded write stores a portal-renderer landmine that only fires when a
@@ -818,7 +866,7 @@ export function registerDataRuleLane(tools) {
             dataRuleType: dataRuleTypeArg,
             options: dataRuleOptionsArg,
             checkType: checkTypeArg,
-            childRule: z.boolean().optional(),
+            childRule: z.boolean().optional().describe("true=子表列规则，propertyCode 为子表列 code；主表字段忽略"),
             name: z.string().optional(),
             sortKey: z.number().int().optional(),
         },
@@ -832,20 +880,21 @@ export function registerDataRuleLane(tools) {
             if (published !== null) {
                 const missing = codes.filter((code) => !published.has(code));
                 if (missing.length > 0)
-                    throw new ToolRefusalError({ status: "refused", blocker: "datarule-property-not-published", schemaCode: args.schemaCode, propertyCodes: codes, missing, message: `字段 ${args.schemaCode}.${missing.join(",")} 不在发布面上；拒绝 datarule.create POST` });
+                    throw new ToolRefusalError({ status: "refused", blocker: "datarule-property-not-published", schemaCode: args.schemaCode, propertyCodes: codes, missing, message: `字段 ${args.schemaCode}.${missing.join(",")} 不在发布面上；拒绝 datarule.create POST。子表列规则请随 field.create 生成/发布；datarule.create 的发布面校验不含子表列（childRule 不改变此行为，r34a-F12 真机三形态全拒）` });
             }
             const existingRules = await listDataRules(session, args.schemaCode);
             // dataRuleType 1 (CHECK_RULE) fans out into 5 checkTypes that COEXIST on one
             // field (the platform auto-creates a checkType 4 maxLength row per text
             // field), so the clash key there is field + `checkType`, not field + type.
-            if (existingRules.some((row) => {
+            const duplicate = existingRules.find((row) => {
                 if (Number(row.dataRuleType) !== args.dataRuleType)
                     return false;
                 if (!storedTargetCodes(row).some((code) => codes.includes(code)))
                     return false;
                 return args.dataRuleType === 1 ? (row.checkType ?? null) === (args.checkType ?? null) : true;
-            }))
-                throw new ToolRefusalError({ status: "refused", blocker: "datarule-duplicate-property-type", schemaCode: args.schemaCode, propertyCodes: codes, dataRuleType: args.dataRuleType, ...(args.dataRuleType === 1 ? { checkType: args.checkType } : {}), message: `字段 ${args.schemaCode}.${codes.join(",")} 已存在同类型数据规则${args.dataRuleType === 1 ? `（checkType ${args.checkType}）` : ""}；拒绝重复 POST` });
+            });
+            if (duplicate)
+                throw new ToolRefusalError({ status: "refused", blocker: "datarule-duplicate-property-type", schemaCode: args.schemaCode, propertyCodes: codes, dataRuleType: args.dataRuleType, ...(args.dataRuleType === 1 ? { checkType: args.checkType } : {}), nextCommand: `omc call datarule.update --args '${JSON.stringify({ id: String(duplicate.id ?? "<existingId>"), schemaCode: args.schemaCode, propertyCode: codes.length === 1 ? codes[0] : undefined, propertyCodes: codes.length > 1 ? codes : undefined, dataRuleType: args.dataRuleType, checkType: args.checkType, options: args.options })}'`, message: `字段 ${args.schemaCode}.${codes.join(",")} 已存在同类型数据规则${args.dataRuleType === 1 ? `（checkType ${args.checkType}）` : ""}；拒绝重复 POST；如需修改请使用该规则 id 更新` });
             const createRule = () => wireCall(session, {
                 path: ENDPOINTS.dataRuleCreate,
                 method: "POST",
@@ -872,7 +921,7 @@ export function registerDataRuleLane(tools) {
                     // 提交违规数据（-50 / 超阈值）errcode 0 放行、原值落库——校验在门户前端
                     // 提交管线执行，REST 不拦。先告知执行面，省掉「先实测两轮才发现不生效」。
                     ...(args.dataRuleType === 1
-                        ? { executionWarning: "校验规则在门户前端提交时执行；REST `data.submit` 不拦截违规数据（r35 真机：-50 与超阈值均 errcode 0 放行）。验收拦截效果需走门户，或改用业务规则（BIZ_ACTION/条件）在服务端拦。" }
+                        ? { executionWarning: dataRuleExecutionWarning(args.checkType) }
                         : {}),
                     ...(() => { const w = dataRuleFormulaWarnings(args.dataRuleType, args.options); return w.length ? { lintWarnings: w } : {}; })(),
                 },
@@ -906,7 +955,7 @@ export function registerDataRuleLane(tools) {
             dataRuleType: dataRuleTypeArg,
             options: dataRuleOptionsArg,
             checkType: checkTypeArg,
-            childRule: z.boolean().optional(),
+            childRule: z.boolean().optional().describe("true=子表列规则，propertyCode 为子表列 code；主表字段忽略"),
             name: z.string().optional(),
             sortKey: z.number().int().optional(),
         },
@@ -926,7 +975,7 @@ export function registerDataRuleLane(tools) {
             const requested = dataRuleTargetCodes(patchArgs);
             const codes = requested.length > 0 ? requested : storedTargetCodes(current);
             const boundArgs = { ...patchArgs, propertyCode: codes.length === 1 ? codes[0] : undefined, propertyCodes: codes };
-            if (before.some((row) => {
+            const duplicate = before.find((row) => {
                 if (row.id === id)
                     return false;
                 if (Number(row.dataRuleType) !== args.dataRuleType)
@@ -934,8 +983,9 @@ export function registerDataRuleLane(tools) {
                 if (!storedTargetCodes(row).some((code) => codes.includes(code)))
                     return false;
                 return args.dataRuleType === 1 ? (row.checkType ?? null) === (args.checkType ?? null) : true;
-            }))
-                throw new ToolRefusalError({ status: "refused", blocker: "datarule-duplicate-property-type", message: `字段 ${args.schemaCode}.${codes.join(",")} 已存在同类型数据规则${args.dataRuleType === 1 ? `（checkType ${args.checkType}）` : ""}；拒绝 update POST` });
+            });
+            if (duplicate)
+                throw new ToolRefusalError({ status: "refused", blocker: "datarule-duplicate-property-type", nextCommand: `omc call datarule.update --args '${JSON.stringify({ id: String(duplicate.id ?? "<existingId>"), schemaCode: args.schemaCode, propertyCode: codes.length === 1 ? codes[0] : undefined, propertyCodes: codes.length > 1 ? codes : undefined, dataRuleType: args.dataRuleType, checkType: args.checkType, options: args.options })}'`, message: `字段 ${args.schemaCode}.${codes.join(",")} 已存在同类型数据规则${args.dataRuleType === 1 ? `（checkType ${args.checkType}）` : ""}；拒绝 update POST；如需修改请使用该规则 id 更新` });
             const beforeDecoded = decodeDataRule(current);
             const performed = await wireCall(session, {
                 path: ENDPOINTS.dataRuleUpdate,

package/dist/lanes/field-contract.js

@@ -172,7 +172,7 @@ export const FIELD_LANE_CONTRACT = Object.freeze({
                 "For single/multi-select pass `choices` (e.g. [\"A\",\"B\",\"C\"]) or `options.optionsSet` with optionsType custom/dictionary/businessModel; dictionary uses checkedDictionary/checkedDictionaryCode, businessModel uses schemaCode/sheetDataItem.",
                 "For a relation pass `relativeCode` and `options` (schemaCode/displayField/...). `searchFormula` and `conditions` are JSON strings for the relation data restriction/query conditions.",
                 "For a relation display field the tool writes the field-row top-level `relativePropertyCode` = options.displayField (the runtime reads THAT key, not options.displayField — QueryRuntimeController.java:1214-1226) and defaults options.displayFieldType:0 + displayFieldFormat:\"\".",
-                "For FORMULA pass `options.formulaConfig` (nested JSON string) + `options.persistent:true`; for RELEVANCE_DATA pass `options.relevanceField` + `options.referenceField` + `options.referenceFieldPropertyType`.",
+                "For FORMULA pass `options.formulaConfig` (nested JSON string) + `options.persistent:true`; for RELEVANCE_DATA pass `options.relevanceField` + `options.referenceField` + `options.referenceFieldPropertyType`. 数值字段的小数位写 `options.scale`；顶层 `precision` 不被读取，若误传请改为 `precision→options.scale（数值小数位）`。",
                 "org 选人族（STAFF_SELECTOR 等 5/50/51/60/61）字段行 options 自动写成实例观测的发布安全形状（yst/fwb 发布面 2656 行：null 或 {defaultValue, mappings, virtualField[, noRepeat]}；单选 defaultValue \"\"，多选 []）。deptVisible/multi 是**表单控件面**判别键（disposeUpdateType/updateSelectionType 读 control.options，票 69 已由表单脚手架写入控件面），不出现在字段行。",
             ]),
         }),
@@ -217,7 +217,7 @@ export function assertFieldContract() {
         throw new Error("field contract must carry the blocked families");
     if (FIELD_LANE_CONTRACT.wire.publishScope !== "model")
         throw new Error("field contract pins the publish scope to model");
-    assertDescriptionCarries(FIELD_LANE_CONTRACT, "field.create", ["bizproperty/create", "OCR/ELECTRONIC_SIGN", "`choices`", "options.optionsSet", "`relativeCode`", "searchFormula", "`options.formulaConfig`", "`options.relevanceField`", "code_reserved", "WORK_SHEET"]);
+    assertDescriptionCarries(FIELD_LANE_CONTRACT, "field.create", ["bizproperty/create", "OCR/ELECTRONIC_SIGN", "`choices`", "options.optionsSet", "`relativeCode`", "searchFormula", "`options.formulaConfig`", "`options.relevanceField`", "precision→options.scale", "code_reserved", "WORK_SHEET"]);
     assertDescriptionCarries(FIELD_LANE_CONTRACT, "field.update", ["bizproperty/update", "`options`", "field.publish", "cascadeRepublish", "form.draft(rebuild)", "form.publish(force)", "published fields", "non-structural", "partial"]);
     assertDescriptionCarries(FIELD_LANE_CONTRACT, "field.publish", ["bizproperty/publish", "published", "Model-scoped", "publishedCodes", "unpublishedRequested", "nonexistentCodes", "stillDraftCodes"]);
     assertDescriptionCarries(FIELD_LANE_CONTRACT, "field.delete", ["bizproperty/force_delete", "absence"]);

package/dist/lanes/field.js

@@ -732,10 +732,12 @@ async function fieldUpdateDryRun(session, args) {
                 }),
         };
     }
+    const impact = await collectFieldDeleteImpact(session, args, { full: true });
     return {
         wouldChange: changes.length > 0,
         changes,
         ...(dataImpact !== undefined ? { dataImpact } : {}),
+        impact,
         schemaCode: args.schemaCode,
         code: args.code,
     };
@@ -951,6 +953,11 @@ async function collectFieldDeleteImpact(session, args, options) {
         ...(counted.note ? { dataRowsNote: counted.note } : counted.dataRows === "unknown" ? { dataRowsNote: "拿不到行数：data.list total 不可用" } : {}),
         references,
         dependentUpdates: surfaces.dependentUpdates,
+        coverage: {
+            scanned: options.full ? ["businessrule", "form", "listview", "onlinejs", "data"] : ["form", "listview", "onlinejs", "data"],
+            notScanned: options.full ? ["workflow.permissions", "workflow.bindings", "rule.conditions"] : ["businessrule", "workflow.permissions", "workflow.bindings", "rule.conditions"],
+            coveredSurfaces: options.full ? ["businessrule", "form", "listview", "onlinejs", "data"] : ["form", "listview", "onlinejs", "data"],
+        },
         ...(unknowns.length > 0 ? { unknown: unknowns } : {}),
         note: options.full
             ? "完整影响面（规则+表单+视图+在线JS+行数）。删除不会自动清理依赖面残留。"
@@ -1062,6 +1069,7 @@ async function runFieldUpdate(session, args) {
         ...(args.propertyEmpty !== undefined ? ["propertyEmpty"] : []),
     ];
     const unverifiable = submittedPropertyEmpty !== undefined && !hasReadBackPropertyEmpty ? ["propertyEmpty"] : [];
+    const impact = await collectFieldDeleteImpact(session, args, { full: false });
     return {
         performed: { errcode: performed.errcode },
         ...(prepared.conditionCompiled !== undefined && prepared.conditionCompiled.length > 0
@@ -1069,6 +1077,7 @@ async function runFieldUpdate(session, args) {
             : {}),
         readback: {
             face: "draft",
+            impact,
             fieldPresent: after !== undefined,
             ...(after?.name !== undefined ? { name: after.name } : {}),
             ...(typeof after?.name_i18n === "string" ? { name_i18n: after.name_i18n } : {}),

package/dist/lanes/list-view.js

@@ -476,23 +476,6 @@ export function registerListViewLane(tools) {
             schemaCode: z.string().min(1),
             name: z.string().min(1),
             code: z.string().optional().describe("视图 code；省略时**默认取 schemaCode**（与 listview.get / listview.list / rollback 的默认视图口径一致）。平台侧 code 必填，本工具会替你填，不要再依赖不回执的猜测（r26 真机：不传直接被 errcode 10005「编码不能为空」拒绝，白跑一轮线上往返）"),
-            // r29b F5a: create 没有列参数。接受 fieldCodes 只是为了给可执行 nextCommand，
-            // 避免未知键算法给出「fieldCodes→code」这种南辕北辙的建议。
-            fieldCodes: z.array(z.string()).optional().describe("本工具不配列——若传了会拒绝并指引 listview.configure"),
-        },
-        // dry-run 不跑 execute——fieldCodes 必须在 preflight 拦，否则 dry-run 仍会放行。
-        preflight: (args) => {
-            if (Array.isArray(args.fieldCodes) && args.fieldCodes.length > 0) {
-                const code = args.code ?? args.schemaCode;
-                throw new ToolInputError({
-                    status: "error",
-                    blocker: "tool-input-invalid",
-                    tool: "listview.create",
-                    message: "listview.create 不接受列参数：先 create（schemaCode/name/code），再 listview.configure 配 fieldCodes。" +
-                        "不要把 fieldCodes 当成 create 的拼写错误去改成 code。",
-                    nextCommand: `omc call listview.configure --args '${JSON.stringify({ schemaCode: args.schemaCode, code, fieldCodes: args.fieldCodes })}'`,
-                });
-            }
         },
         execute: async (session, args) => {
             // r26 真机：`code` 在 schema 里可选，但三处读面/rollback 都用
@@ -500,16 +483,6 @@ export function registerListViewLane(tools) {
             // `errcode 10005 编码不能为空`，探针白跑一轮。默认视图 code 就是
             // schemaCode（listview.list 的 hint 也这么写），这里对齐。
             const code = args.code ?? args.schemaCode;
-            if (Array.isArray(args.fieldCodes) && args.fieldCodes.length > 0) {
-                throw new ToolInputError({
-                    status: "error",
-                    blocker: "tool-input-invalid",
-                    tool: "listview.create",
-                    message: "listview.create 不接受列参数：先 create（schemaCode/name/code），再 listview.configure 配 fieldCodes。" +
-                        "不要把 fieldCodes 当成 create 的拼写错误去改成 code。",
-                    nextCommand: `omc call listview.configure --args '${JSON.stringify({ schemaCode: args.schemaCode, code, fieldCodes: args.fieldCodes })}'`,
-                });
-            }
             // Ticket 81: read the header FIRST — a same-code retry short-circuits
             // with the existing view and sends ZERO create wires (the live
             // post-timeout retry otherwise answers 303002 编码重复).

package/dist/lanes/model.js

@@ -393,7 +393,11 @@ export function registerModelLane(tools) {
                 // delete). Same SYSTEM_FIELD_CODES set field.list uses.
                 const visibleColumns = all ? listviewColumns : listviewColumns.filter((column) => !SYSTEM_FIELD_CODES.has(String(column.propertyCode)));
                 const listview = listviewFace && listviewFace.columns
-                    ? { code: listviewFace.code ?? schemaCode, columnCount: visibleColumns.length, columns: visibleColumns.map((column) => ({ propertyCode: column.propertyCode, propertyType: column.propertyType, visible: column.visible })) }
+                    ? {
+                        code: listviewFace.code ?? schemaCode,
+                        columnCount: visibleColumns.length,
+                        columns: visibleColumns.map((column) => ({ propertyCode: column.propertyCode, propertyType: column.propertyType, visible: column.visible })),
+                    }
                     : undefined;
                 const ruleRows = Array.isArray(ruleFace?.rules) ? ruleFace.rules : [];
                 // All rules are kept: the platform pre-creates trigger rows (Create/Update/
@@ -433,6 +437,7 @@ export function registerModelLane(tools) {
                 const workflow = draftFace?.exists === false || (draftFace === undefined && publishedFace === undefined)
                     ? (draftFace && draftFace.schemaCode ? { exists: false } : undefined)
                     : {
+                        exists: true,
                         workflowCode: summary?.workflowCode ?? workflowCode,
                         published: publishedFace?.published === true || pubSummary?.templateType === "PUBLISH",
                         activities: Array.isArray(summary?.activities) ? summary.activities.map((activity) => ({ code: activity.code, type: activity.type, name: activity.name, participant: activity.participant })) : [],
@@ -447,6 +452,7 @@ export function registerModelLane(tools) {
                 const absent = fieldRefusalErrcode === 300004 || faceErrcodes.get("field.list") === 300004;
                 const modelPresent = absent ? false : fieldFace !== undefined && !fieldRefused ? true : undefined;
                 return {
+                    code: schemaCode,
                     schemaCode,
                     ...(modelName !== undefined ? { name: modelName } : {}),
                     ...(modelPresent !== undefined ? { modelPresent } : {}),
@@ -482,12 +488,24 @@ export function registerModelLane(tools) {
                     return result;
                 return {
                     schemaCode: result.schemaCode,
+                    // r35a-F3：compact 投影必须保留 code（model.list 有 code，inspect 此前
+                    // 只剩 schemaCode，`--jq '[].code'` 必 pathMiss 白跑一轮）。
+                    ...(result.code !== undefined ? { code: result.code } : {}),
                     fieldCodes: (result.fields ?? []).map((field) => field.code),
                     form: result.form,
                     listview: result.listview ? { code: result.listview.code, columnCount: result.listview.columnCount } : undefined,
                     ruleCodes: (result.rules ?? []).map((rule) => rule.code),
                     datarules: result.datarules,
-                    workflow: result.workflow ? { workflowCode: result.workflow.workflowCode, published: result.workflow.published } : undefined,
+                    // r35a-F2：workflow 摘要必须恒有 exists 布尔——compact 投影此前把它丢了，
+                    // 真机（走 compact 的分支）于是永远读不到 exists（探针只能靠
+                    // missedEntries 反推「缺失=有流程」，语义反直觉且有安全风险）。
+                    workflow: result.workflow
+                        ? {
+                            exists: result.workflow.exists !== false,
+                            workflowCode: result.workflow.workflowCode,
+                            published: result.workflow.published,
+                        }
+                        : { exists: false },
                     hint: result.hint,
                 };
             },

package/dist/lanes/organization.js

@@ -392,19 +392,36 @@ export function registerOrganizationLane(tools) {
                         return scope.id;
                 return null;
             };
-            const members = rows.map((row) => ({
-                id: roleUserId(row),
-                // r32 探针：把角色 id 当成员 id 传给 userScope/addUsers → 查询为空。
-                // 明示这个 id 的身份与正确来源，防角色/用户 id 混用。
-                idType: "user",
-                name: row.name ?? null,
-                username: row.username ?? null,
-                departmentId: memberDepartment(row),
-                departmentName: row.departmentName ?? null,
-                // `ouScope` decides whether a role member can be resolved as a workflow
-                // participant. Surface the count so an empty scope is visible here.
-                scopeCount: Array.isArray(row.ouScope) ? row.ouScope.length : null,
-                unitType: row.unitType ?? null,
+            const members = await Promise.all(rows.map(async (row) => {
+                const id = roleUserId(row);
+                let username = row.username ?? null;
+                if (username == null && id !== "") {
+                    try {
+                        const user = (await wireCall(session, {
+                            path: ENDPOINTS.organizationUserInfo,
+                            query: { ...orgQuery(session), id },
+                        })).data;
+                        username = user?.username ?? null;
+                    }
+                    catch (error) {
+                        if (!(error instanceof WireError) || error.errcode !== 10011)
+                            throw error;
+                    }
+                }
+                return {
+                    id,
+                    // r32 探针：把角色 id 当成员 id 传给 userScope/addUsers → 查询为空。
+                    // 明示这个 id 的身份与正确来源，防角色/用户 id 混用。
+                    idType: "user",
+                    name: row.name ?? null,
+                    username,
+                    departmentId: memberDepartment(row),
+                    departmentName: row.departmentName ?? null,
+                    // `ouScope` decides whether a role member can be resolved as a workflow
+                    // participant. Surface the count so an empty scope is visible here.
+                    scopeCount: Array.isArray(row.ouScope) ? row.ouScope.length : null,
+                    unitType: row.unitType ?? null,
+                };
             }));
             return {
                 roleId,
@@ -426,7 +443,7 @@ export function registerOrganizationLane(tools) {
             environment: environmentArg,
             roleId: z.string().min(1).optional().describe("角色 id（32 位 hex）；与 roleCode 二选一"),
             roleCode: z.string().min(1).optional().describe("角色 code（org.role.list 的 roles 码表）或名称；与 roleId 二选一"),
-            userId: z.string().min(1).describe("成员的用户记录 id（recId）"),
+            userId: z.string().min(1).optional().describe("成员的用户记录 id（recId）；roleId/roleCode 二者其一必填"),
             capability: capabilityArg,
         },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
@@ -976,8 +993,20 @@ export function registerOrganizationLane(tools) {
                 if (!(error instanceof WireError) || error.errcode !== 10011)
                     throw error;
             }
-            if (!data)
-                return { userId: String(args.userId), exists: false };
+            // r34b-F6（真机 2026-11-06，1.1.25）：死 id 平台**不回 null 也不回 10011**，
+            // 而是 200 + 空壳对象——`!data` 分支真机永远走不到，exists:true + 全 null
+            // 把「不存在」伪装成「存在但没数据」。真机形状：name/username/mobile/email/
+            // departmentId/status 全空且 roleIds 无。全身份字段空 = 按 exists:false 处理。
+            const emptyShell = data !== null && [
+                data.name, data.username, data.mobile, data.email, data.departmentId, data.status,
+            ].every((v) => v == null || v === "") && (!Array.isArray(data.roleIds) || data.roleIds.length === 0);
+            if (!data || emptyShell)
+                return {
+                    userId: String(args.userId), exists: false,
+                    existsNote: emptyShell ? "平台回 200 空壳（身份字段全空）——按不存在处理（r34b-F6 真机）" : undefined,
+                    name: null, username: null, departmentId: null, mobile: null, email: null,
+                    active: null, userStatus: null, roleIds: [],
+                };
             return {
                 userId: String(args.userId), exists: true,
                 name: data.name ?? null, username: data.username ?? null, departmentId: data.departmentId ?? null,

package/dist/lanes/runtime-data.js

@@ -2238,6 +2238,8 @@ export function registerRuntimeDataLane(tools) {
                     ...readback,
                     workflowInstanceId: effectiveInstanceId,
                     objectId,
+                    // The submit response often has no workItemId; when the engine created
+                    // the next todo, its first item is the authoritative continuation id.
                     workItemId: typeof performedData.workItemId === "string" ? performedData.workItemId : null,
                     sequenceStatus,
                     submittedData: approvalDelta ? projectApprovalReadback(loadedRecord, Object.keys(formData ?? {})) : projectReadbackRecord(loadedRecord, args),
@@ -2290,6 +2292,8 @@ export function registerRuntimeDataLane(tools) {
                         }
                         if (nextWorkItems.length > 0) {
                             readback.nextWorkItems = nextWorkItems;
+                            if (readback.workItemId === null)
+                                readback.workItemId = nextWorkItems[0].workItemId;
                             const nextName = nextWorkItems[0].activityName ?? nextWorkItems[0].activityCode ?? "下一节点";
                             if (rejected) {
                                 readback.returnedTo = {

package/dist/lanes/workflow-contract.js

@@ -208,11 +208,11 @@ export const WORKFLOW_LANE_CONTRACT = Object.freeze({
         }),
         "workitem.list": Object.freeze({
             scope: "runtime workflow work-item query",
-            description: "查询当前登录人的待办（`GET /api/api/runtime/workflow/search_workitems`）。WorkItemSearchVO 经 @ModelAttribute 传参，服务端以登录态注入 userId，故无需传处理人——结果天然是「我的待办」。返回每项 workItemId(id) + workflowInstanceId(instanceId) + activityName + state；并尽力经 `GET /api/api/runtime/workflow/getBizObjectByWfInstanceId` 解析 bizObjectId/schemaCode 供 data.submit 审批。`workflowInstanceId` 为客户端精确过滤（服务端 WorkItemSearchVO.filterWorkflowInstanceId 实为 notEqualsTo 排除，不能用于命中实例）；带该过滤时 total 为过滤后的条数，原服务端总数在 unfilteredTotal。**想知道「流程停在哪」，用 `workflow.instanceActivity`，不要靠反复 workitem.list**——待办查询只返回在办项，实例停住时永远是空数组。",
+            description: "查询当前登录人的待办（`GET /api/api/runtime/workflow/search_workitems`）。WorkItemSearchVO 经 @ModelAttribute 传参，服务端以登录态注入 userId，故无需传处理人——结果天然是「我的待办」。返回每项完整键集：`workItemId, workflowInstanceId, workflowCode, activityCode, activityName, state, sequenceNo, originator, originatorName, participant, participantName, bizObjectId, schemaCode`；外置大结果另带 `itemsCount, ids, itemsPreview, truncated, truncatedKeys, omittedKeys, detailFile/detailSha256`，其中 itemsPreview 为前 3 个 `{id}` 引用。并尽力经 `GET /api/api/runtime/workflow/getBizObjectByWfInstanceId` 解析 bizObjectId/schemaCode 供 data.submit 审批。`workflowInstanceId` 为客户端精确过滤（服务端 WorkItemSearchVO.filterWorkflowInstanceId 实为 notEqualsTo 排除，不能用于命中实例）；带该过滤时 total 为过滤后的条数，原服务端总数在 unfilteredTotal。**想知道「流程停在哪」，用 `workflow.instanceActivity`，不要靠反复 workitem.list**——待办查询只返回在办项，实例停住时永远是空数组。",
         }),
         "workflow.instanceActivity": Object.freeze({
             scope: "runtime workflow instance node-state diagnosis",
-            description: "按实例查全部节点状态（`GET /api/api/runtime/workflow/list_workflow_instance_activity`，WorkflowMaintenanceAssembler.listActivateActivity）。返回模板里每个活动节点的 activityCode/activityName/activityType + status（1=当前激活，0=已完成或未到达）+ 解析出的 participants（含姓名/id）。用于「data.submit 回 PROCESSING 但没有下一待办」的自诊断：例子 `omc call workflow.instanceActivity --args '{\"workflowInstanceId\":\"<id>\"}'`。当没有任何节点 status=1 时，readback 的 diagnosis.code=no-active-activity 并列出排查顺序（参与人为空的审批节点 → 参与人写法 → 容器日志 GetParticipantInfo error）。审批推进正常时该工具不需要——data.submit 的 readback.nextSubmit 已给出下一级参数。",
+            description: "按实例查全部节点状态（`activities[].status` 数字枚举：`1=当前激活/持有待办`、`0=已完成或尚未到达`，别与实例级 `instanceStatus:\"PROCESSING\"` 混用——后者只表示流程仍在运行）。返回每个节点 `{activityCode,activityName,activityType,status,participantCount,participants:[{name,id}],sheetTrigger?}`（`GET /api/api/runtime/workflow/list_workflow_instance_activity`，WorkflowMaintenanceAssembler.listActivateActivity）。用于「data.submit 回 PROCESSING 但没有下一待办」的自诊断：例子 `omc call workflow.instanceActivity --args '{\"workflowInstanceId\":\"<id>\"}'`。当没有任何节点 status=1 时，readback 的 diagnosis.code=no-active-activity 并列出排查顺序（参与人为空的审批节点 → 参与人写法 → 容器日志 GetParticipantInfo error）。审批推进正常时该工具不需要——data.submit 的 readback.nextSubmit 已给出下一级参数。",
         }),
     }),
 });

package/dist/lanes/workflow.js

@@ -19,6 +19,24 @@ const WORKFLOW_LANE = WORKFLOW_LANE_CONTRACT.lane;
 const WORKFLOW_TOOLS = WORKFLOW_LANE_CONTRACT.tools;
 const WORKFLOW_ACTIVITY_TYPES = new Set(["START", "END", "CONNECTION", "PARTICIPANT", "SUB_INSTANCE", "CIRCULATE", "SYSTEM_ACTIVITY", "AGENT_ACTIVITY"]);
 const WORKFLOW_POINT = /^-?\d+(?:\.\d+)?,\s-?\d+(?:\.\d+)?$/;
+/** Keep workitem.list's external envelope aligned with data.list. */
+export function workItemListCompactProjection(result) {
+    const compact = {};
+    for (const [key, value] of Object.entries(result)) {
+        if (key !== "items" || !Array.isArray(value)) {
+            if (key !== "ids" && key !== "itemsPreview" && key !== "listArtifactHint")
+                compact[key] = value;
+            continue;
+        }
+        const rows = value;
+        const ids = rows.map((row) => row.workItemId).filter((id) => typeof id === "string" && id.length > 0);
+        compact.itemsCount = rows.length;
+        compact.ids = ids;
+        compact.itemsPreview = ids.slice(0, 3).map((id) => ({ id }));
+        compact.listArtifactHint = "items 已外置（truncatedKeys/omittedKeys 含 items）：完整待办见 artifact；ids=本页全部 workItemId，itemsPreview=前 3 个 id 引用。";
+    }
+    return compact;
+}
 /**
  * Conditional branch lines (round7). `routes[]` maps to the platform `Rule`
  * DTO (Rule.java:28-59), which carries a structured branch condition
@@ -3199,13 +3217,13 @@ export function registerWorkflowLane(tools) {
                 total: page.total,
                 // The JPA-spec path reports no page count; only emit it when known.
                 ...("totalPages" in page && page.totalPages !== undefined ? { totalPages: page.totalPages } : {}),
-                count: items.length,
+                itemsCount: items.length,
                 ...(purposeHint ? { purposeHint } : {}),
                 ...(args.participant !== undefined ? { participant: args.participant, state: args.state ?? "PENDING", source: "list_workitems" } : {}),
                 ...("unfilteredTotal" in page && page.unfilteredTotal !== undefined ? { unfilteredTotal: page.unfilteredTotal } : {}),
                 items,
             };
-        }),
+        }, { compact: workItemListCompactProjection }),
     }));
     tools.push(defineTool({
         name: "workflow.instanceActivity",
@@ -3678,6 +3696,12 @@ export function registerWorkflowLane(tools) {
                 };
             }
             return flat;
+        }, {
+            compact: (result) => ({
+                ...result,
+                roles: Array.isArray(result.roles) ? result.roles : [],
+                groups: Array.isArray(result.groups) ? result.groups : [],
+            }),
         }),
     }));
     tools.push(defineTool({
@@ -3729,7 +3753,7 @@ export function registerWorkflowLane(tools) {
         kind: "read",
         lane: WORKFLOW_LANE,
         scope: WORKFLOW_TOOLS["org.user.search"].scope,
-        description: WORKFLOW_TOOLS["org.user.search"].description,
+        description: `${WORKFLOW_TOOLS["org.user.search"].description} 返回 count=本页 users 条数、total=总命中数；没有本页结果时两者均为 0。`,
         inputSchema: {
             environment: environmentArg,
             // `wd` is the platform's own key; `keyword`/`q` are accepted aliases so a
@@ -3826,7 +3850,8 @@ export function registerWorkflowLane(tools) {
                     corpId: user.corpId ?? null,
                     status: user.status ?? null,
                 }));
-                return { keyword, count: users.length, total: data?.totalElements ?? users.length, users };
+                const totalHits = users.length === 0 ? 0 : (typeof data?.totalElements === "number" ? data.totalElements : users.length);
+                return { keyword, count: users.length, total: totalHits, users };
             }, { compact: userSearchCompact });
         },
     }));

package/dist/read-shapes.js

@@ -94,7 +94,10 @@ const READ_SHAPES = {
     },
     "workitem.list": {
         // Flat rows — no fields bag. Wire id is projected as workItemId.
-        keys: ["items:array<{workItemId,activityCode,...}>", "total", "count"],
+        // r34c-F4（真机 2026-11-06）：此前 `{workItemId,activityCode,...}` 的省略号让
+        // 探针必须实调一次才敢确定标题键叫 activityName（--full 也一样省略）。
+        // 展开真实键集（真机 item 实测）；外置信封的 ids/itemsPreview 由 F7 补。
+        keys: ["items:array<{workItemId,workflowInstanceId,workflowCode,activityCode,activityName,state,sequenceNo,originator,originatorName,participant,participantName,bizObjectId,schemaCode}>", "total", "count"],
         notes: ["待办 id 键是 workItemId，不是 id（平铺，不套 fields）"],
     },
     "rule.list": {

package/dist/read.js

@@ -121,7 +121,10 @@ function externalizedShapePlaceholders(result, dropped) {
     // 自相矛盾的标记会让调用方以为还得去 artifact 取。
     if (dropped.length === 0)
         return {};
-    const placeholders = { truncatedKeys: [...dropped], truncated: true };
+    // Keep the A1 empty/null placeholder shape, but explicitly distinguish it
+    // from a genuine empty payload. `omittedKeys` is the machine-readable face;
+    // `truncatedKeys` remains the legacy list of payload keys moved to artifact.
+    const placeholders = { truncatedKeys: [...dropped], omittedKeys: [...dropped], truncated: true };
     for (const key of dropped)
         placeholders[key] = Array.isArray(result[key]) ? [] : null;
     return placeholders;

package/dist/recipes/field.js

@@ -291,6 +291,44 @@ const formulaAggregationCrossModel = Object.freeze({
     requiresEnvironmentDerivedIds: true,
     prerequisiteData: { source: "field.list(published:true) ×2（来源模型 + 目标模型）", fields: ["source.model", "source.dataItemCode", "source.matchField", "target.matchField"] },
 });
+const formulaExpressionSameModel = Object.freeze({
+    id: "formula-expression-same-model",
+    title: "同模型基础公式字段：FORMULA + EXPRESSION（amount×2）",
+    aliases: ["同模型公式", "基础公式字段", "表达式字段", "公式字段", "amount*2"],
+    status: "offline-valid",
+    tool: "field.create",
+    args: {
+        environment,
+        schemaCode: model,
+        code: "total",
+        name: "合计",
+        propertyType: "FORMULA",
+        options: {
+            formulaConfig: JSON.stringify({
+                resultType: 2,
+                formulaType: "EXPRESSION",
+                expression: JSON.stringify({ formula: "{amount}*2" }),
+            }),
+            persistent: true,
+        },
+    },
+    preconditions: ["目标模型已存在；amount 是同一模型上已存在并已发布的数值字段；total 尚不存在"],
+    conditionalRequirements: [
+        "formulaConfig 是 JSON 字符串，内层 expression 仍是 JSON 字符串：CLI recipe 已代做两层序列化，直接把 args 传给 field.create，不要再手工转义。",
+        "这是同模型的基础 EXPRESSION；跨模型汇总请改用 formula-aggregation-cross-model。",
+    ],
+    priorToolReferences: [
+        { tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认 amount 已发布并确认目标 code 未占用" },
+    ],
+    dryRun: { supported: true, command: `omc call field.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验 FORMULA/EXPRESSION 序列化形状，不创建字段" },
+    expectedReadback: { readback: { fieldPresent: true, options: { formulaConfig: "<EXPRESSION: {amount}*2>" } }, next: ["field.publish", "form.draft", "form.publish"] },
+    refusalRecovery: [
+        { code: "duplicate-field", action: "字段已存在改用 field.update 或换 code" },
+        { code: "formula-expression-source-missing", action: "先创建并发布同模型的 amount 数值字段，再创建 total" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: false,
+});
 /**
  * r29（2026-10-29 中冶终轮）+ 用户领域知识：外部数据（企查查/NC 等）在表单上
  * 「填表时即带出」的标准模式——两段式组合。此前三轮探针（r24/r28b/r29）都发明
@@ -346,6 +384,6 @@ const externalLookupModel = Object.freeze({
 });
 export const FIELD_METADATA = Object.freeze({
     "field.update": Object.freeze({ recipes: [fieldSerialNumber, formConditionalRequired, formAlwaysReadonly, formConditionalReadonly], relatedTools: ["field.list", "field.publish", "form.draft", "form.publish"] }),
-    "field.create": Object.freeze({ recipes: [numericTwoDecimals, dictionarySelection, dictionaryMultiSelection, childTable, businessModelDropdown, formulaAggregationCrossModel, externalLookupModel], relatedTools: ["dictionary.names", "dictionary.records", "discover_environment", "field.list", "field.publish", "form.draft", "configure_form", "form.publish"] }),
+    "field.create": Object.freeze({ recipes: [numericTwoDecimals, dictionarySelection, dictionaryMultiSelection, childTable, businessModelDropdown, formulaAggregationCrossModel, formulaExpressionSameModel, externalLookupModel], relatedTools: ["dictionary.names", "dictionary.records", "discover_environment", "field.list", "field.publish", "form.draft", "configure_form", "form.publish"] }),
 });
 //# sourceMappingURL=field.js.map

package/dist/skills.js

@@ -102,6 +102,19 @@ const SYNTHETIC_SKILLS = Object.freeze({
             "",
         ].join("\n"),
     },
+    "batch-write": {
+        name: "batch-write",
+        description: "批量运行数据写入、形状预检与逐条失败定位",
+        content: [
+            "# 批量写",
+            "",
+            "通用批量入口是 `omc call <tool> --args-list '<json数组>'`，逐条执行且默认不中断。",
+            "先做零写入形状校验：`omc call data.save --args-list '<file|stdin>' --preflight`；回执 `shapeOnly:true`，只校验 JSON 形状与 schema 必填键，不做业务语义校验；业务校验要真写一次才知道。",
+            "支持 `data.save`、`data.delete`、`field.create` 等同一工具逐条批量调用；没有专用 `data.import`，导入数据就是逐条 `data.save`。",
+            "失败项回 `row`（1 基）、`index`（0 基）和尽力推断的字段/原因；成功项回输入中的 `code` 等业务标识。",
+            "",
+        ].join("\n"),
+    },
 });
 /** Every methodology topic exposed by `omc help`. */
 export function listSkills() {

package/dist/tool-types.js

@@ -152,6 +152,41 @@ export const KEY_ALIAS_HINTS = Object.freeze({
     order: ["orders"],
     orderby: ["orders"],
 });
+/** Semantic directions for keys whose wire name is not an edit-distance match. */
+export const KEY_SEMANTIC_HINTS = Object.freeze({
+    precision: "options.scale（数值小数位）",
+});
+/**
+ * r34a-F18（batch2 挂账收尾，2026-11-06 真机）：`data.delete` 传 `id` 时写面
+ * preflight 建议到无关的 `requestId`（编辑距离子串命中）。读面路径（cli.ts 的
+ * suggestArgumentKey）已按工具族给 `id→bizObjectId`，写面必须同一语义，否则
+ * 两条通道互相矛盾。**语境而非全局**：`id` 在多数工具是合法键，不能进
+ * KEY_SEMANTIC_HINTS（那是无条件的）。
+ */
+function contextualClosestKey(toolName, key, schemaKeys) {
+    const t = toolName.toLowerCase();
+    if (t.startsWith("data.") && key === "id" && schemaKeys.has("bizObjectId"))
+        return "bizObjectId";
+    if (t.startsWith("data.") && key === "ids" && schemaKeys.has("bizObjectIds"))
+        return "bizObjectIds";
+    return undefined;
+}
+/**
+ * r35a-F8（真机 2026-11-06）：`field.update` 传 `propertyType` 时，编辑距离
+ * 建议到 `propertyEmpty`（风马牛不相及）——探针要「改字段类型」却拿不到任何
+ * 可行动信息。字段 type/code 在平台设计态不可原地修改，只能删重建（且会波及
+ * 引用），所以这里给的是**替代路径**而不是一个错误参数名。
+ */
+const CONTEXTUAL_KEY_GUIDANCE = Object.freeze({
+    "field.update": Object.freeze({
+        propertyType: "平台不支持原地改字段类型：需 field.delete（先看其 impact）→ field.create；同名 code 的改 type 会丢该列存量值",
+        type: "同上：改类型需 field.delete → field.create；改名（显示名）用 name，改 code 无工具（等同删+建）",
+        code: "字段 code 不可改：只能 field.delete → field.create（引用面会断，先看 field.delete 的 impact）",
+    }),
+    "field.create": Object.freeze({
+        precision: "precision→options.scale（数值小数位，不是顶层 precision）",
+    }),
+});
 function closestSchemaKey(key, schemaKeys) {
     if (schemaKeys.has(key))
         return key;
@@ -198,7 +233,9 @@ export function parseToolInput(tool, input) {
         const schemaKeys = new Set(Object.keys(tool.inputSchema));
         const unknown = Object.keys(normalized).filter((key) => !schemaKeys.has(key));
         if (unknown.length > 0) {
-            const suggestions = unknown.map((key) => `${key}→${closestSchemaKey(key, schemaKeys) ?? "（无相近键，omc describe <tool> 看参数表）"}`);
+            const suggestions = unknown.map((key) => `${key}→${KEY_SEMANTIC_HINTS[key] ?? contextualClosestKey(tool.name, key, schemaKeys) ?? closestSchemaKey(key, schemaKeys) ?? "（无相近键，omc describe <tool> 看参数表）"}`);
+            // r35a-F8：有替代路径指引时单独列（不是「最接近的合法键」，而是「该走哪条路」）。
+            const guidanceLines = unknown.map((key) => CONTEXTUAL_KEY_GUIDANCE[tool.name]?.[key]).filter((hint) => typeof hint === "string" && hint.length > 0);
             // r25 实证：`publish→（无相近键）` 等于没说——配置与发布是两步，用户要的是
             // 另一个工具。有语义指引时优先给可执行的下一步。
             const twoStep = unknown
@@ -209,24 +246,27 @@ export function parseToolInput(tool, input) {
             // 漏掉发布指引（报告原文：「若用程序消费回执，会选 issues[]，就会漏掉」）。
             // 两条通道必须同源，否则等于修了一半。
             const issueHintFor = (key) => {
-                const guidance = TWO_STEP_GUIDANCE[tool.name]?.[key];
+                const guidance = TWO_STEP_GUIDANCE[tool.name]?.[key] ?? CONTEXTUAL_KEY_GUIDANCE[tool.name]?.[key];
                 if (guidance !== undefined)
                     return guidance;
+                const semantic = KEY_SEMANTIC_HINTS[key];
+                const contextual = contextualClosestKey(tool.name, key, schemaKeys);
                 const closest = closestSchemaKey(key, schemaKeys);
                 // 语言规则（HANDOFF §三.3-8）：人读句子中文、机器字段/键名英文。issues[]
                 // 与人读 message 同源（B4），所以这里也是中文句子 + 英文键名。
-                return closest === undefined ? "未知键；本工具的合法键里没有相近的" : `未知键；最接近的合法键：${closest}`;
+                return semantic !== undefined ? `未知键；语义上应改用：${semantic}` : contextual !== undefined ? `未知键；本工具语境最接近的合法键：${contextual}` : closest === undefined ? "未知键；本工具的合法键里没有相近的" : `未知键；最接近的合法键：${closest}`;
             };
             // 未知键的下一步应指向**正确的那个参数**，不是整份 describe（4–17 KB）。
             // 有近邻时 `--param <nearKey>` 是 150–900 B，且直接回答「本来想写哪个键」。
-            const nearestKey = closestSchemaKey(unknown[0], schemaKeys);
+            // 语境建议优先于编辑距离（r34a-F18：data.delete 的 id 指 requestId 是噪声）。
+            const nearestKey = contextualClosestKey(tool.name, unknown[0], schemaKeys) ?? closestSchemaKey(unknown[0], schemaKeys);
             const paramCommand = nearestKey !== undefined ? `omc describe ${tool.name} --param ${nearestKey}` : `omc describe ${tool.name}`;
             throw new ToolInputError({
                 status: "error",
                 blocker: "tool-input-unknown-keys",
                 tool: tool.name,
-                message: `写面工具不接受未知键（会被静默丢弃）：${unknown.join("、")}。${twoStep.length > 0 ? twoStep.join(" ") : `最接近的合法键：${suggestions.join("；")}。参数表：${paramCommand}`}`,
-                ...(twoStep.length > 0 ? { nextCommand: `omc describe ${tool.name}` } : { nextCommand: paramCommand }),
+                message: `写面工具不接受未知键（会被静默丢弃）：${unknown.join("、")}。${twoStep.length > 0 ? twoStep.join(" ") : `${guidanceLines.length > 0 ? guidanceLines.join("；") : `最接近的合法键：${suggestions.join("；")}`}。参数表：${paramCommand}`}`,
+                ...(twoStep.length > 0 || guidanceLines.length > 0 ? { nextCommand: `omc describe ${tool.name}` } : { nextCommand: paramCommand }),
                 issues: unknown.map((key) => ({ path: [key], code: "unrecognized_key", message: issueHintFor(key) })),
             });
         }

package/package.json

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