@stalfh233/omc-cli 0.6.15 → 0.6.17

package/dist/batch-call.js

@@ -19,7 +19,57 @@
  * per-tool preflight apply exactly as they do for a single call.
  */
 import { refusalText } from "./cli-contract.js";
+import { createArtifact } from "./artifacts.js";
+import { artifactFetchHint, artifactRoot } from "./command-transport.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 +119,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,13 +145,22 @@ 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) } : {}),
         };
     });
     const entriesInline = entriesSummary.slice(0, ENTRIES_INLINE_LIMIT);
+    const warnings = batchWarnings(options.argsList);
+    const warningsInline = warnings.slice(0, ENTRIES_INLINE_LIMIT);
+    const detailOmitted = entriesSummary.length > entriesInline.length || warnings.length > warningsInline.length;
+    const detailArtifact = detailOmitted
+        ? createArtifact(artifactRoot(), JSON.stringify({ entries: entriesSummary, warnings }, null, 2) + "\n")
+        : undefined;
     return {
         exitCode: failed > 0 ? 1 : 0,
         result: {
@@ -112,9 +174,17 @@ export async function runBatchCall(options) {
             // 每条一行摘要（index/ok/bizObjectId）——不是完整信封，但足以回答
             // 「第 3 条建成了吗、它的 id 是什么」。失败项另有 failures 带完整原因。
             entries: entriesInline,
-            ...(entries.length > entriesInline.length
-                ? { entriesOmitted: entries.length - entriesInline.length, entriesHint: `条目超过 ${ENTRIES_INLINE_LIMIT} 条，只内联前 ${ENTRIES_INLINE_LIMIT} 条摘要；完整结果走 detailArtifactId / omc artifact get` }
-                : {}),
+            ...(warnings.length > 0 ? {
+                warnings: warningsInline,
+                ...(warnings.length > warningsInline.length ? { warningsOmitted: warnings.length - warningsInline.length } : {}),
+            } : {}),
+            ...(entriesSummary.length > entriesInline.length ? { entriesOmitted: entriesSummary.length - entriesInline.length } : {}),
+            ...(detailArtifact !== undefined ? {
+                detailArtifactId: detailArtifact.artifactId,
+                sha256: detailArtifact.sha256,
+                fetch: artifactFetchHint(detailArtifact.artifactId),
+                entriesHint: `条目或预检警告超过 ${ENTRIES_INLINE_LIMIT} 条，只内联前 ${ENTRIES_INLINE_LIMIT} 条；完整结果见 detailArtifactId`,
+            } : {}),
             // Only failures carry full per-entry detail: echoing 8 full success
             // envelopes would rebuild exactly the wall of text this command exists
             // to remove.

package/dist/capability-overview.js

@@ -123,7 +123,7 @@ const SURFACES = [
     },
     {
         id: "workflow",
-        title: "流程模板",
+        title: "流程模板 + 组织与权限",
         lane: LANES.workflow,
         description: "流程模板生命周期：get_draft/get_published、create、update、publish、bindRule、delete、workitem.list。**含组织/部门/角色/权限范围（org.* 工具）**：部门树、角色组/角色、用户搜索、成员与管理范围（userScope）——流程参与人/可见性的候选来源。",
         operations: ["create", "update", "publish", "bindRule", "delete"],
@@ -193,7 +193,7 @@ const CAPABILITY_ALIASES = Object.freeze({
     businessrule: ["business-rules", "B1-businessrule"],
     "rule-lifecycle": ["rule-lifecycles", "S25-rule-lifecycle"],
     // r28h F1/F7: org.* lives under workflow; aliases let "我要管部门/组织" hit it.
-    workflow: ["workflows", "W7-S29-greenfield", "org", "organization", "organisation", "组织", "组织架构"],
+    workflow: ["workflows", "W7-S29-greenfield", "org", "organization", "permission", "role", "权限", "角色", "组织"],
     onlinejs: ["online-js"],
     programming: ["backend-online-coding", "programming-online-dev", "在线开发", "在线编码"],
     bizservice: ["bizservices", "B2-registration"],
@@ -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);
@@ -1632,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);
@@ -1656,7 +1670,10 @@ function cmdGraphReferences(kind, code, transport) {
 function cmdGraphStatus(transport) {
     try {
         const status = readGraphStatus();
-        return emitResult({ status: "ok", index: status.index, dbBytes: status.dbBytes, gaps: status.gaps }, transport);
+        // r31a-F16：这里是**第四个**白名单式重建（前三次：compact() 投影、references
+        // 覆盖声明、mcp-graph 的 explore）。白名单每漏一个键就等于没修，且不会被任何
+        // 单测发现——所以改成展开，新增字段自动透传。
+        return emitResult({ status: "ok", ...status }, transport);
     }
     catch (error) {
         if (error instanceof GraphIndexAbsentError)
@@ -2145,7 +2162,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);
@@ -2513,8 +2530,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/compute.js

@@ -189,7 +189,7 @@ export async function cmdCompute(args) {
     let result;
     let exitCode;
     try {
-        ({ result, exitCode } = await runToolCall("datarule.create", { args: createArgs, requestId: request, environment }));
+        ({ result, exitCode } = await runToolCall("datarule.create", { args: createArgs, requestId: request, environment, print: () => undefined }));
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);

package/dist/field-families.js

@@ -64,7 +64,7 @@ export function relationDisplayFieldCode(type, options) {
     const displayField = options.displayField;
     return typeof displayField === "string" && displayField.trim() ? displayField.trim() : undefined;
 }
-export const choicesArg = z.array(z.string()).optional().describe('allowed values for text-choice families (RADIO / CHECKBOX / DROPDOWN_BOX / DROPDOWN_MULTI_BOX), e.g. ["正常","异常","待复检"]。注意：SELECTION(5) 是人员/部门混合选择器，不接受 choices，文本单选请用 DROPDOWN_BOX/RADIO');
+export const choicesArg = z.array(z.string()).optional().describe('allowed values for text-choice families, e.g. ["正常","异常","待复检"]。注意：SELECTION(5) 是人员/部门混合选择器，不接受 choices；文本单选族随版本不同，拒绝信息会列当前 live 集');
 function jsonString() {
     return z.string().refine((value) => {
         if (value === "")
@@ -830,6 +830,43 @@ export function assertFieldFamilyAllowed(args) {
     // works if the preflight gate is the same gate the write uses.
     assertNumericalScale(normalized, options);
 }
+/**
+ * Reject the platform's accept-then-drop org-selector+choices shapes before write.
+ *
+ * 三个组织选择器族同语义（SELECTION 混合 / STAFF_SELECTOR 人员 / DEPARTMENT_SELECTOR
+ * 部门）：choices 都会被平台静默丢弃，字段建成后写任何 choices 值都 50000 无明细。
+ * r37（2026-11-07）之前 SELECTION 走的是 execute 路径的 capability-out-of-coverage
+ * （citation.reason 才说不接受 choices），STAFF/DEPARTMENT 走 live 集拒绝——同一语义
+ * 三个族两种 blocker。统一收敛到这里：同语义 = 同 blocker（含 options.choices 形态，
+ * 那是 F14 真机撞出来的：字段落库、field.list 还回显 choices、运行面才炸）。
+ */
+const ORG_SELECTOR_TYPES = new Set([
+    FIELD_PROPERTY_TYPES.SELECTION,
+    FIELD_PROPERTY_TYPES.STAFF_SELECTOR,
+    FIELD_PROPERTY_TYPES.DEPARTMENT_SELECTOR,
+]);
+export function assertSelectionChoicesAllowed(args) {
+    const options = args.options;
+    const hasTopLevelChoices = args.choices !== undefined;
+    const hasOptionsChoices = options !== null && typeof options === "object" && !Array.isArray(options)
+        && Object.prototype.hasOwnProperty.call(options, "choices");
+    if (!hasTopLevelChoices && !hasOptionsChoices)
+        return;
+    const raw = args.propertyType;
+    const type = typeof raw === "number" && Number.isInteger(raw)
+        ? raw
+        : typeof raw === "string" && raw in FIELD_PROPERTY_TYPES
+            ? FIELD_PROPERTY_TYPES[raw]
+            : undefined;
+    if (type === undefined || !ORG_SELECTOR_TYPES.has(type))
+        return;
+    const family = typeof raw === "string" ? raw : String(type);
+    throw new ToolRefusalError({
+        status: "refused",
+        blocker: "field-choices-family-mismatch",
+        message: `${family} 是组织选择器（人员/部门），choices 会被平台静默丢弃；字段虽会建成，但写入任何 choices 值都会返回 50000 且无明细。选人/部门请使用不带 choices 的本族字段（值走引用）；文本单选族随版本不同，请先看 omc describe field.create --param propertyType，拒绝信息会列当前 live 集。`,
+    });
+}
 function refuseFieldOptions(reason, message) {
     const citation = {
         code: "capability-out-of-coverage",

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

@@ -46,10 +46,18 @@ function nodeSqlite() {
  *   staleness is handled by reporting pulledAt + identity, refreshed by an
  *   explicit re-pull (no incremental watermarks, no write-back hooks).
  */
-const GRAPH_SCHEMA_VERSION = "4";
+const GRAPH_SCHEMA_VERSION = "5";
 const STALE_LOCK_MS = 15 * 60 * 1000;
 export const DEFAULT_PULL_CONCURRENCY = 16;
 export const MAX_PULL_CONCURRENCY = 32;
+/** 索引超过这个天数就提示刷新（配置类查询，1 天足够新）。 */
+export const STALE_INDEX_DAYS = 1;
+export function indexAgeDays(pulledAtIso, now = Date.now()) {
+    const pulled = Date.parse(pulledAtIso);
+    if (Number.isNaN(pulled))
+        return 0;
+    return Math.max(0, Math.floor((now - pulled) / 86_400_000));
+}
 export class GraphIndexAbsentError extends Error {
     constructor(message) {
         super(message);
@@ -179,13 +187,39 @@ export async function pullRuleGraph(session, concurrency = DEFAULT_PULL_CONCURRE
     // zero-guard) wedge the scheduler.
     const scope = await resolveApplicationScope(session, undefined).catch(() => undefined);
     const applicationCode = scope?.code ?? "";
-    const schemaCodes = flattenTreeRows(wireRows((await wireCall(session, { path: ENDPOINTS.applicationTree, query: { appCode: applicationCode } })).data))
-        .filter((row) => row.type === "BizModel" && typeof row.code === "string" && row.code !== "")
-        .map((row) => String(row.code))
-        .sort();
+    const gaps = [];
+    const treeRows = flattenTreeRows(wireRows((await wireCall(session, { path: ENDPOINTS.applicationTree, query: { appCode: applicationCode } })).data));
+    const modelEntities = treeRows.filter((row) => row.type === "BizModel" && typeof row.code === "string" && row.code !== "").map((row) => ({ schemaCode: String(row.code), name: String(row.name ?? row.code) })).sort((a, b) => a.schemaCode.localeCompare(b.schemaCode));
+    const schemaCodes = modelEntities.map((row) => row.schemaCode);
+    const fields = [];
+    const services = [];
+    await Promise.all(schemaCodes.map(async (schemaCode) => {
+        try {
+            const rows = wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode, isPublish: "true" } })).data);
+            for (const row of rows) {
+                const code = String(row.code ?? row.propertyCode ?? "");
+                if (code)
+                    fields.push({ schemaCode, code, name: String(row.name ?? row.propertyName ?? code) });
+            }
+        }
+        catch (error) {
+            gaps.push({ kind: "field-list", ref: schemaCode, note: error instanceof Error ? error.message : String(error) });
+        }
+    }));
+    try {
+        await wireCall(session, { path: ENDPOINTS.bizServiceCategoryList });
+        const rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceListByCategoryId, query: { categoryId: "" } })).data);
+        for (const row of rows) {
+            const code = String(row.code ?? "");
+            if (code)
+                services.push({ code, name: String(row.name ?? code) });
+        }
+    }
+    catch (error) {
+        gaps.push({ kind: "service-list", ref: "all", note: error instanceof Error ? error.message : String(error) });
+    }
     const rules = [];
     const edges = [];
-    const gaps = [];
     let parseFailures = 0;
     let dataruleCount = 0;
     let viewCount = 0;
@@ -375,6 +409,9 @@ export async function pullRuleGraph(session, concurrency = DEFAULT_PULL_CONCURRE
         },
         rules,
         edges,
+        models: modelEntities,
+        fields: fields.sort((a, b) => `${a.schemaCode}/${a.code}`.localeCompare(`${b.schemaCode}/${b.code}`)),
+        services: services.sort((a, b) => a.code.localeCompare(b.code)),
         gaps,
         scanned: { models: schemaCodes.length, rules: rules.length, datarules: dataruleCount, views: viewCount, parseFailures },
         timings: { listMs, readMs, totalMs: Date.now() - totalStart },
@@ -489,7 +526,10 @@ export async function publishGraphPull(session, concurrency = DEFAULT_PULL_CONCU
           via TEXT NOT NULL
         );
         CREATE INDEX edges_lookup ON edges(kind, code);
-        CREATE TABLE gaps (kind TEXT NOT NULL, ref TEXT NOT NULL, note TEXT);
+         CREATE TABLE gaps (kind TEXT NOT NULL, ref TEXT NOT NULL, note TEXT);
+         CREATE TABLE models (schema_code TEXT PRIMARY KEY, name TEXT NOT NULL);
+         CREATE TABLE fields (schema_code TEXT NOT NULL, code TEXT NOT NULL, name TEXT NOT NULL);
+         CREATE TABLE services (code TEXT PRIMARY KEY, name TEXT NOT NULL);
       `);
                 const insertMeta = db.prepare("INSERT INTO meta (key, value) VALUES (?, ?)");
                 // `applicationResolution` is an object; String(value) would persist
@@ -506,12 +546,21 @@ export async function publishGraphPull(session, concurrency = DEFAULT_PULL_CONCU
                 const insertGap = db.prepare("INSERT INTO gaps (kind, ref, note) VALUES (?, ?, ?)");
                 for (const gap of data.gaps)
                     insertGap.run(gap.kind, gap.ref, gap.note ?? null);
+                const insertModel = db.prepare("INSERT INTO models (schema_code, name) VALUES (?, ?)");
+                for (const row of data.models)
+                    insertModel.run(row.schemaCode, row.name);
+                const insertField = db.prepare("INSERT INTO fields (schema_code, code, name) VALUES (?, ?, ?)");
+                for (const row of data.fields)
+                    insertField.run(row.schemaCode, row.code, row.name);
+                const insertService = db.prepare("INSERT INTO services (code, name) VALUES (?, ?)");
+                for (const row of data.services)
+                    insertService.run(row.code, row.name);
                 // FTS5 mirrors rules (code+name) for `graph search`; one rebuild after
                 // the bulk insert is cheaper than per-row triggers on a wholesale rebuild.
                 db.exec(`
-        CREATE VIRTUAL TABLE rules_fts USING fts5(rule_code, name, content='rules', content_rowid='rowid');
-        INSERT INTO rules_fts(rules_fts) VALUES('rebuild');
-      `);
+         CREATE VIRTUAL TABLE rules_fts USING fts5(rule_code, name, content='rules', content_rowid='rowid');
+          INSERT INTO rules_fts(rules_fts) VALUES('rebuild');
+        `);
                 db.exec("COMMIT;");
             }
             finally {
@@ -544,6 +593,11 @@ function openGraphIndex() {
             throw new GraphIndexAbsentError(`索引 schema 版本不匹配（${meta.schemaVersion} ≠ ${GRAPH_SCHEMA_VERSION}）；重跑 omc graph pull`);
         const ruleCount = db.prepare("SELECT COUNT(*) AS n FROM rules").get().n;
         const modelCount = db.prepare("SELECT COUNT(DISTINCT schema_code) AS n FROM rules").get().n;
+        const entityCounts = {
+            models: db.prepare("SELECT COUNT(*) AS n FROM models").get().n,
+            fields: db.prepare("SELECT COUNT(*) AS n FROM fields").get().n,
+            services: db.prepare("SELECT COUNT(*) AS n FROM services").get().n,
+        };
         const edgeRows = db.prepare("SELECT kind, COUNT(*) AS n FROM edges GROUP BY kind").all();
         const edges = {};
         for (const row of edgeRows)
@@ -555,6 +609,8 @@ function openGraphIndex() {
             byKind[row.kind] = row.n;
             gapCount += row.n;
         }
+        const pulledAtIso = meta.pulledAtIso ?? "";
+        const ageDays = indexAgeDays(pulledAtIso);
         return {
             db,
             summary: {
@@ -564,10 +620,17 @@ function openGraphIndex() {
                 // such key, so this stays optional rather than failing the read.
                 ...(meta.applicationResolution ? { applicationResolution: parseApplicationResolution(meta.applicationResolution) } : {}),
                 identityFingerprint: meta.identityFingerprint ?? "",
-                pulledAtIso: meta.pulledAtIso ?? "",
+                pulledAtIso,
                 freshness: gapCount === 0 ? "complete" : "partial",
+                ageDays,
+                // r31a-F16：旧索引 + complete 标签 = 静默错答。给可直接照抄的刷新命令，
+                // 并明确「complete 只指扫描无缺口」。
+                ...(ageDays >= STALE_INDEX_DAYS
+                    ? { staleWarning: `索引是 ${ageDays} 天前的快照（pulledAt ${pulledAtIso}）；freshness:"complete" 只表示扫描无缺口、不表示最新。先 \`omc graph pull --env ${meta.environmentName ?? "<env>"}\` 再查，或给结论加时效限定` }
+                    : {}),
                 models: modelCount,
                 rules: ruleCount,
+                entities: entityCounts,
                 edges,
                 gaps: { count: gapCount, byKind },
             },
@@ -578,6 +641,17 @@ function openGraphIndex() {
         throw error instanceof GraphIndexAbsentError ? error : new GraphIndexAbsentError(`索引不可读（schema 不匹配或文件损坏）：${error instanceof Error ? error.message : String(error)}；重跑 omc graph pull`);
     }
 }
+/**
+ * r35a-F4 / r35a-F4b（真机 2026-11-06）：探针拿 `matches:[]` 差点把一个**被表单引用**
+ * 的字段判成「可安全删除」，紧接着发现 `graph impact` 的 `totals` 全 0 也有同样误读风险。
+ * 三个面（CLI references / CLI impact / MCP explore）必须共用同一份声明——
+ * 分散定义就会被漏掉一处（MCP 面第一版就漏了）。
+ */
+export const GRAPH_COVERAGE = Object.freeze({
+    scanned: Object.freeze(["businessrule", "datarule", "listview"]),
+    notScanned: Object.freeze(["form", "workflow.permissions", "workflow.bindings", "onlinejs", "rule.conditions"]),
+    note: "零命中/全零 totals 只代表 scanned 面没有命中；notScanned 面（尤其 form 与 workflow.permissions）未扫描，不可据此判定可安全删除或无影响",
+});
 /**
  * Zero-hit disambiguation (2026-10-31 capability-test friction, hit twice in
  * one session): querying `impact field mcc_supplier` returns an empty result
@@ -607,16 +681,22 @@ export function queryGraphReferences(kind, code) {
             via: row.via,
         }));
         const gapped = summary.gaps.count > 0;
+        // r35a-F4（真机 2026-11-06）：探针拿 matches:[] 差点把一个**被表单引用**的
+        // 字段判成「可安全删除」——note 只说了「不含规则条件叶子/流程绑定」，从没
+        // 明说表单与流程权限表不在扫描范围。散文字段不承担安全契约：这里给结构化
+        // coverage，让「没人引用」与「这一面没扫」在机器可读层面可分。
+        const coverage = GRAPH_COVERAGE;
         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") ?? ""),
                 }
                 : {}),
@@ -633,7 +713,14 @@ export function readGraphStatus() {
     const { db, summary } = openGraphIndex();
     try {
         const gaps = db.prepare("SELECT kind, ref, note FROM gaps ORDER BY kind, ref LIMIT 50").all();
-        return { index: summary, dbBytes: statSync(graphDbPath()).size, gaps };
+        const dbPath = graphDbPath();
+        return {
+            index: summary,
+            dbBytes: statSync(dbPath).size,
+            dbPath,
+            dbId: sha256(dbPath).slice(0, 12),
+            gaps,
+        };
     }
     finally {
         db.close();
@@ -651,6 +738,11 @@ export function searchGraphRules(term, limit = 20) {
     try {
         const tokens = term.trim().split(/\s+/).filter((token) => token !== "");
         let matches = [];
+        const entityMatches = {
+            model: { count: 0, total: 0, items: [] },
+            field: { count: 0, total: 0, items: [] },
+            service: { count: 0, total: 0, items: [] },
+        };
         if (tokens.length > 0) {
             const quoted = tokens.map((token, index) => `"${token.replaceAll('"', '""')}"${index === tokens.length - 1 ? "*" : ""}`).join(" ");
             const rows = db
@@ -673,13 +765,24 @@ export function searchGraphRules(term, limit = 20) {
                     refs,
                 };
             });
+            const searchEntity = (countSql, rowsSql, params, map) => {
+                const total = Number(db.prepare(countSql).get(...params).n);
+                const rows = db.prepare(rowsSql).all(...params, limit);
+                return { count: rows.length, total, items: rows.map(map), ...(rows.length < total ? { truncated: true } : {}) };
+            };
+            entityMatches.model = searchEntity("SELECT COUNT(*) AS n FROM models WHERE instr(name, ?) > 0 OR instr(schema_code, ?) > 0", "SELECT schema_code, name FROM models WHERE instr(name, ?) > 0 OR instr(schema_code, ?) > 0 ORDER BY schema_code LIMIT ?", [term.trim(), term.trim()], (row) => ({ schemaCode: row.schema_code, name: row.name }));
+            entityMatches.field = searchEntity("SELECT COUNT(*) AS n FROM fields WHERE instr(name, ?) > 0 OR instr(code, ?) > 0", "SELECT schema_code, code, name FROM fields WHERE instr(name, ?) > 0 OR instr(code, ?) > 0 ORDER BY schema_code, code LIMIT ?", [term.trim(), term.trim()], (row) => ({ schemaCode: row.schema_code, code: row.code, name: row.name }));
+            entityMatches.service = searchEntity("SELECT COUNT(*) AS n FROM services WHERE instr(name, ?) > 0 OR instr(code, ?) > 0", "SELECT code, name FROM services WHERE instr(name, ?) > 0 OR instr(code, ?) > 0 ORDER BY code LIMIT ?", [term.trim(), term.trim()], (row) => ({ code: row.code, name: row.name }));
         }
         const gapped = summary.gaps.count > 0;
         return {
             term,
             rules: matches,
+            matches: entityMatches,
             index: summary,
-            ...(matches.length === 0
+            coverage: { scanned: ["rule.code", "rule.name", "model.code", "model.name", "field.code", "field.name", "service.code", "service.name"], notScanned: ["rule.body", "form", "workflow.permissions"], note: "检索覆盖规则与实体的 code/name；规则体、表单与流程权限未扫描" },
+            ...(term.trim() !== "" && !/^[A-Za-z][A-Za-z0-9_.-]*$/.test(term.trim()) ? { note: "疑似业务词；本工具同时检索实体 name/code 与规则 code/name，引用明细请使用匹配到的 code 再查 references/impact" } : {}),
+            ...(matches.length === 0 && entityMatches.model.total === 0 && entityMatches.field.total === 0 && entityMatches.service.total === 0
                 ? {
                     note: tokens.length === 0
                         ? "检索词为空"
@@ -757,11 +860,12 @@ export function impactGraph(kind, code) {
             listviews: listViewHits.slice(0, 20).map((hit) => ({ schemaCode: hit.schema_code, viewCode: hit.view_code ?? "", via: hit.via })),
             totals: { rules: hop1.length, datarules: dataruleHits.length, listviews: listViewHits.length, touchedServices: services.size, touchedModels: models.size, touchedFields: fields.size },
             index: summary,
+            coverage: GRAPH_COVERAGE,
             ...(hop1.length === 0 && dataruleHits.length === 0 && listViewHits.length === 0
                 ? {
                     note: (gapped
                         ? "零命中，但索引存在扫描缺口——不可作为「无影响」证明；先 omc graph pull 重建再查"
-                        : "零命中=索引覆盖范围内没有引用它（规则面+数据规则面+视图列/排序/条件面；流程绑定暂不在索引内）") +
+                        : "零命中=仅 scanned 面（规则/数据规则/视图）没有影响；form（表单控件）与 workflow.permissions 未扫描，见 coverage.notScanned——不可据此判定「删除无影响」") +
                         (zeroHitKindHint(db, kind, code, "impact") ?? ""),
                 }
                 : {}),