@stalfh233/omc-cli 0.6.15 → 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);
@@ -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);
@@ -2145,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);
@@ -2513,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/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/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/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/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
@@ -3205,7 +3223,7 @@ export function registerWorkflowLane(tools) {
                 ...("unfilteredTotal" in page && page.unfilteredTotal !== undefined ? { unfilteredTotal: page.unfilteredTotal } : {}),
                 items,
             };
-        }),
+        }, { compact: workItemListCompactProjection }),
     }));
     tools.push(defineTool({
         name: "workflow.instanceActivity",

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

@@ -171,6 +171,22 @@ function contextualClosestKey(toolName, key, schemaKeys) {
         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;
@@ -218,6 +234,8 @@ export function parseToolInput(tool, input) {
         const unknown = Object.keys(normalized).filter((key) => !schemaKeys.has(key));
         if (unknown.length > 0) {
             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
@@ -228,7 +246,7 @@ 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];
@@ -247,8 +265,8 @@ export function parseToolInput(tool, input) {
                 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.15",
+  "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.15",
+    "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.15"
+    "@stalfh233/omc-fake-platform": "0.6.16"
   }
 }