@stalfh233/omc-cli 0.4.55 → 0.4.57

package/dist/bizservice-config.js

@@ -319,6 +319,14 @@ export function compileMethodConfigPlain(adapterCode, methodConfig) {
         config.requestBodyType = encodeEnumIndex(config.requestBodyType, RESTFUL_REQUEST_BODY_TYPES, "requestBodyType");
         if (typeof config.url !== "string" || !config.url)
             refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, "RESTFUL 方法 url 必须是非空字符串（相对路径与服务 commonlist.url 拼接）", { key: "url" });
+        // Prefix × auth matrix (live 2026-10-18, SubCon): `/openapi/**` is spliced
+        // to `/api/openapi/**` (single layer) and authenticates with the OAuth2
+        // client (`xclient`); `/api/**` becomes `/api/api/**` (double layer) and
+        // authenticates as the USER — mixing them answers 401 权限不够. Two hard
+        // rules are unambiguous on their own: an unauthenticated prefix must never
+        // carry a 二开 interface, and externalLink is never a business endpoint.
+        if (/^\/?externalLink/i.test(config.url))
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.methodConfigInvalid, "禁止用 /externalLink 等免鉴权前缀承载二开接口（能通但方向错误）；二开接口走 /openapi/** + xclient", { key: "url", url: config.url });
         // Designer parity: the rule designer's RESTFUL method config also carries
         // `connectTime` / `retryTimes` (string seconds/count, designer defaults
         // "10"/"3"); the 绑定业务方法 dialog and the runtime read them, so a
@@ -401,7 +409,19 @@ export function compileParameterFace(adapterCode, parameters, label) {
     if (!Array.isArray(parameters))
         refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${label} 必须是结构化参数数组（ParameterModel[]）`, { label });
     const defaultRequired = isOutputFace(label) ? false : undefined;
-    const normalized = parameters.map((parameter, index) => compileParameter(adapterCode, parameter, label, `${label}[${index}]`, index, defaultRequired));
+    // Live 2026-10-18 (SubCon): a 7-method registration failed one parameter at a
+    // time across two rounds — the whole batch was rewritten for a single enum
+    // typo, then again for a missing output position. Collect EVERY violation and
+    // refuse once with the full list, so one pass fixes the whole face.
+    const violations = [];
+    const normalized = parameters.map((parameter, index) => compileParameter(adapterCode, parameter, label, `${label}[${index}]`, index, defaultRequired, violations));
+    if (violations.length > 0)
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid,
+            message: `${label} 参数面有 ${violations.length} 处非法项（一次性列出，逐项修正后一次重试）：` + violations.map((v) => `${v.path}${v.code ? ` (${v.code})` : ""}: ${v.message}`).join("；"),
+            issues: violations,
+        });
     return JSON.stringify(normalized);
 }
 /** True when `label` names the RETURN parameter face (outputParametersJson). */
@@ -417,32 +437,51 @@ function isOutputFace(label) {
  * leaf → 1000 PROPERTY, a node with subParameters → 1002 OBJECT) and
  * `description`. RESTFUL additionally requires configJson.position.
  */
-function compileParameter(adapterCode, parameter, label, path, index, defaultRequired) {
-    if (!isRecord(parameter))
-        refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path} 必须是对象`, { label, index });
+function compileParameter(adapterCode, parameter, label, path, index, defaultRequired, violations) {
+    const collect = (message, code) => {
+        if (violations)
+            violations.push({ path, ...(code ? { code } : {}), message });
+        else
+            refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path}${code ? ` (${code})` : ""}: ${message}`, { label, index, ...(code ? { code } : {}) });
+    };
+    if (!isRecord(parameter)) {
+        collect("必须是对象");
+        return {};
+    }
     if (typeof parameter.code !== "string" || !parameter.code)
-        refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path} 缺少 code（绑定校验按 code 对账）`, { label, index });
+        collect("缺少 code（绑定校验按 code 对账）");
     if (parameter.required !== undefined && typeof parameter.required !== "boolean")
-        refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path}.required 必须是布尔（缺席=未声明必填，不会被补成 false）`, { label, index });
+        collect("required 必须是布尔（缺席=未声明必填，不会被补成 false）");
     const position = parameterPosition(parameter);
+    const validPositions = Object.values(RESTFUL_PARAMETER_POSITIONS);
+    const positionIsValid = (typeof position === "number" && Number.isInteger(position) && position in RESTFUL_PARAMETER_POSITIONS) ||
+        (typeof position === "string" && validPositions.includes(position));
     if (adapterCode === "RESTFUL") {
         if (position === undefined)
-            refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path} (${parameter.code}) 缺 configJson.position —— RESTFUL 参数无 position 在 invoke 时 NPE（RestProtocolAdapterRuntimeServiceImpl.java:197）`, { label, index, code: parameter.code });
-        if (position === 1 || position === "URL_VARIABLE")
-            refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path} (${parameter.code}) position=URL_VARIABLE 被运行时拒绝（501007，无对应分支）；用 QUERY_PARAMS/REQUEST_HEADER/REQUEST_BODY/PATH_PARAMS`, { label, index, code: parameter.code });
+            collect("缺 configJson.position —— RESTFUL 参数无 position 在 invoke 时 NPE（RestProtocolAdapterRuntimeServiceImpl.java:197）", typeof parameter.code === "string" ? parameter.code : undefined);
+        else if (!positionIsValid)
+            collect(`position 枚举名 ${String(position)} 不在已取证集合 ${validPositions.join("|")} 内（REQUEST_PARAM 不存在）`, typeof parameter.code === "string" ? parameter.code : undefined);
+        else if (position === 1 || position === "URL_VARIABLE")
+            collect("position=URL_VARIABLE 被运行时拒绝（501007，无对应分支）；用 QUERY_PARAMS/REQUEST_HEADER/REQUEST_BODY/PATH_PARAMS", typeof parameter.code === "string" ? parameter.code : undefined);
     }
     // Platform canonical: `ParameterModel.configJson` is a JSON STRING column
     // whose content is the nested config OBJECT with the WIRE INTEGER position
     // (platform built-ins: "configJson":{"position":3}). Encode the enum and
     // emit the object form; a string input is parsed so we never double-encode.
     const configInput = isRecord(parameter.configJson) ? parameter.configJson : typeof parameter.configJson === "string" ? safeParse(parameter.configJson) : undefined;
-    const configJson = adapterCode === "RESTFUL"
-        ? { ...(isRecord(configInput) ? configInput : {}), position: encodeEnumIndex(position, RESTFUL_PARAMETER_POSITIONS, "position") }
-        : parameter.configJson;
-    const bizPropertyType = resolveBizPropertyType(parameter, label, index, path);
-    const externParameterType = resolveExternParameterType(parameter, label, index);
+    let configJson = parameter.configJson;
+    if (adapterCode === "RESTFUL") {
+        const usable = positionIsValid && position !== 1 && position !== "URL_VARIABLE";
+        configJson = usable
+            ? { ...(isRecord(configInput) ? configInput : {}), position: encodeEnumIndex(position, RESTFUL_PARAMETER_POSITIONS, "position") }
+            : isRecord(configInput)
+                ? configInput
+                : parameter.configJson;
+    }
+    const bizPropertyType = resolveBizPropertyType(parameter, label, index, path, collect);
+    const externParameterType = resolveExternParameterType(parameter, label, index, collect);
     const subParameters = Array.isArray(parameter.subParameters)
-        ? parameter.subParameters.map((sub, subIndex) => compileParameter(adapterCode, sub, label, `${path}.subParameters[${subIndex}]`, subIndex, defaultRequired))
+        ? parameter.subParameters.map((sub, subIndex) => compileParameter(adapterCode, sub, label, `${path}.subParameters[${subIndex}]`, subIndex, defaultRequired, violations))
         : parameter.subParameters;
     return {
         ...parameter,
@@ -457,24 +496,35 @@ function compileParameter(adapterCode, parameter, label, path, index, defaultReq
     };
 }
 /** Resolve/validate a parameter's `bizPropertyType` (int index or enum name). Absent → refuse (fail-closed). */
-function resolveBizPropertyType(parameter, label, index, path) {
+function resolveBizPropertyType(parameter, label, index, path, collect) {
     const raw = parameter.bizPropertyType;
+    const fail = (message) => {
+        if (collect) {
+            collect(message);
+            return BIZ_PROPERTY_TYPE_NAMES.SHORT_TEXT;
+        }
+        refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path} (${parameter.code}) ${message}`, { label, index, code: parameter.code });
+    };
     if (raw === undefined || raw === null)
-        refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path} (${parameter.code}) 缺 bizPropertyType（参数类型）——业务集成参数必须有类型，否则业务规则按类型绑定失败、参数无法映射；用 BIZ_PROPERTY_TYPES 索引或枚举名（SHORT_TEXT/NUMERICAL/RADIO/DROPDOWN_BOX…）`, { label, index, code: parameter.code });
+        return fail("缺 bizPropertyType（参数类型）——业务集成参数必须有类型，否则业务规则按类型绑定失败、参数无法映射；用 BIZ_PROPERTY_TYPES 索引或枚举名（SHORT_TEXT/NUMERICAL/RADIO/DROPDOWN_BOX…）");
     if (typeof raw === "number" && Number.isInteger(raw) && raw in BIZ_PROPERTY_TYPES)
         return raw;
     if (typeof raw === "string" && raw in BIZ_PROPERTY_TYPE_NAMES)
         return BIZ_PROPERTY_TYPE_NAMES[raw];
-    refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${path} (${parameter.code}) bizPropertyType 必须是合法字段类型（整数索引或枚举名，如 SHORT_TEXT/NUMERICAL/RADIO/DROPDOWN_BOX）——缺失或有误会破坏业务规则按类型绑定`, { label, index, code: parameter.code });
+    return fail("bizPropertyType 必须是合法字段类型（整数索引或枚举名，如 SHORT_TEXT/NUMERICAL/RADIO/DROPDOWN_BOX）——缺失或有误会破坏业务规则按类型绑定");
 }
 /** Resolve/validate a parameter's `externParameterType` (int index or name); default leaf=PROPERTY(1000)/parent=OBJECT(1002). */
-function resolveExternParameterType(parameter, label, index) {
+function resolveExternParameterType(parameter, label, index, collect) {
     const raw = parameter.externParameterType;
     if (raw !== undefined) {
         if (typeof raw === "number" && Number.isInteger(raw) && raw in EXTERN_PARAMETER_TYPES)
             return raw;
         if (typeof raw === "string" && raw in EXTERN_PARAMETER_NAMES)
             return EXTERN_PARAMETER_NAMES[raw];
+        if (collect) {
+            collect("externParameterType 必须是 PROPERTY(1000)/LIST(1001)/OBJECT(1002) 的整数索引或枚举名");
+            return EXTERN_PARAMETER_NAMES.PROPERTY;
+        }
         refuse(BIZSERVICE_CONFIG_BLOCKERS.parameterFaceInvalid, `${label}[${index}] (${parameter.code}) externParameterType 必须是 PROPERTY(1000)/LIST(1001)/OBJECT(1002) 的整数索引或枚举名`, { label, index, code: parameter.code });
     }
     const hasChildren = Array.isArray(parameter.subParameters) && parameter.subParameters.length > 0;

package/dist/cli.js

@@ -209,7 +209,24 @@ async function cmdDoctor(store, environment, serviceCode) {
     }
     catch (error) {
         ok = false;
-        steps.push(`自检      FAIL ${redactText(error.message, [])}`);
+        // Distinguish "the project has not pinned an environment" (usable once you
+        // name one) from "the platform is unreachable" — conflating them sent a
+        // sandbox probe guessing environment names five times (r18).
+        const message = redactText(error.message, []);
+        let configured = "";
+        try {
+            configured = store.listEnvironments().map((item) => item.name).join("、");
+        }
+        catch {
+            configured = "";
+        }
+        const kind = /no default environment|not configured|unknown environment|not configured in omc\.config\.json/i.test(message)
+            ? "env-not-pinned"
+            : "env-unreachable";
+        steps.push(`自检      FAIL ${message}`);
+        steps.push(kind === "env-not-pinned"
+            ? `环境      ${kind}  已配置环境：${configured || "(none)"}；用 omc env list 查看，再以 --env <name> 指定或 omc setup 绑定；对象不存在（modelPresent:false）不是环境错误`
+            : `环境      ${kind}  环境已配置但平台不可达；先查网络/服务，不要改环境名试错（已配置：${configured || "(none)"}）`);
     }
     for (const line of steps)
         console.error(line);
@@ -935,6 +952,25 @@ async function main() {
     command.command("setup").option("--list").option("--edit <environment>").option("--remove <environment>").action(async (options) => {
         commandExitCode = await cmdSetup(new ConfigStore(defaultPaths()), [...(options.list ? ["--list"] : []), ...(options.edit ? ["--edit", options.edit] : []), ...(options.remove ? ["--remove", options.remove] : [])]);
     });
+    command.command("env [action]").option("--json").action(async (action, options) => {
+        // Read-only inventory of configured environment names. r18: the sandbox
+        // guessed names instead of listing them; doctor's wording now points here.
+        const store = new ConfigStore(defaultPaths());
+        if (action !== undefined && action !== "list") {
+            console.error("用法：omc env list [--json]");
+            commandExitCode = CLI_EXIT_CODES.invalidInput;
+            return;
+        }
+        const rows = store.listEnvironments().map((item) => ({ name: item.name, baseUrl: item.profile.baseUrl, applicationCode: item.profile.applicationCode, isDefault: item.profile.isDefault === true, writable: item.profile.writable !== false }));
+        if (options.json)
+            process.stdout.write(JSON.stringify({ ok: true, environments: rows }, null, 2) + "\n");
+        else if (rows.length === 0)
+            console.error("(none configured; run omc setup)");
+        else
+            for (const row of rows)
+                console.error(`${row.name}${row.isDefault ? " (default)" : ""}  ${row.baseUrl}  app=${row.applicationCode}${row.writable ? "" : "  [read-only]"}`);
+        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("--max-output-bytes <bytes>").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.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"] : [])];

package/dist/lanes/b2-registration-contract.js

@@ -129,11 +129,11 @@ export const B2_LANE_CONTRACT = Object.freeze({
         }),
         "method.update": Object.freeze({
             scope: "method update readback",
-            description: "原地更新业务集成方法（`/bizservice/method/update`）：方法 configJson 由工具 AES 加密，参数面结构化序列化并回读；保留方法身份与规则引用。",
+            description: "原地更新业务集成方法（`/bizservice/method/update`），RESTFUL 参数 position 仅 QUERY_PARAMS|URL_VARIABLE|REQUEST_HEADER|REQUEST_BODY|PATH_PARAMS（写入名字、读回整数索引），非法项一次性全列。方法 configJson 由工具 AES 加密，参数面结构化序列化并回读；保留方法身份与规则引用。",
         }),
         "method.create": Object.freeze({
             scope: "method create readback",
-            description: "在**已存在的业务服务**下新增方法（`/bizservice/method/create`）：新写一个扩展接口通常不是新建服务，而是往已有服务里加方法。服务不存在 → refused（新增服务用 `service.register`）；方法已存在 → refused（改用 `method.update`）。configJson 由工具 AES 加密，参数面结构化序列化并回读。**RESTFUL 参数面**：入参与出参的每个参数都要 `configJson.position`，合法值只有 `QUERY_PARAMS | URL_VARIABLE | REQUEST_HEADER | REQUEST_BODY | PATH_PARAMS`（`REQUEST_PARAM` 不存在；`URL_VARIABLE` 运行时 501007 被拒）。平台注入的常量头（如 X-LowCode-Corpid）标 `required:false`，否则 method.test 会按缺参 fail-closed。写入用枚举名，读回是整数索引（0 QUERY_PARAMS / 1 URL_VARIABLE / 2 REQUEST_HEADER / 3 REQUEST_BODY / 4 PATH_PARAMS）。",
+            description: "在**已存在的业务服务**下新增方法（`/bizservice/method/create`），RESTFUL 参数 position 仅 QUERY_PARAMS|URL_VARIABLE|REQUEST_HEADER|REQUEST_BODY|PATH_PARAMS，入参与出参都必带，常量头 required:false，非法项一次性全列。新写一个扩展接口通常不是新建服务，而是往已有服务里加方法。服务不存在 → refused（新增服务用 `service.register`）；方法已存在 → refused（改用 `method.update`）。configJson 由工具 AES 加密，参数面结构化序列化并回读。**RESTFUL 参数面**：入参与出参的每个参数都要 `configJson.position`，合法值只有 `QUERY_PARAMS | URL_VARIABLE | REQUEST_HEADER | REQUEST_BODY | PATH_PARAMS`（`REQUEST_PARAM` 不存在；`URL_VARIABLE` 运行时 501007 被拒）。平台注入的常量头（如 X-LowCode-Corpid）标 `required:false`，否则 method.test 会按缺参 fail-closed。写入用枚举名，读回是整数索引（0 QUERY_PARAMS / 1 URL_VARIABLE / 2 REQUEST_HEADER / 3 REQUEST_BODY / 4 PATH_PARAMS）。",
         }),
         "method.delete": Object.freeze({
             scope: "method delete readback",

package/dist/lanes/b2-registration.js

@@ -61,9 +61,10 @@ function safeParseArray(value) {
 function parseDeclaredParameterCodes(inputParametersJson) {
     const parsed = typeof inputParametersJson === "string" ? safeParseArray(inputParametersJson) : Array.isArray(inputParametersJson) ? inputParametersJson : undefined;
     if (!parsed)
-        return { all: [], required: [] };
+        return { all: [], required: [], constants: [] };
     const all = [];
     const required = [];
+    const constants = [];
     for (const entry of parsed) {
         if (!entry || typeof entry !== "object")
             continue;
@@ -73,8 +74,12 @@ function parseDeclaredParameterCodes(inputParametersJson) {
         all.push(code);
         if (entry.required === true)
             required.push(code);
+        // codeType 0 = CONST: the platform injects the value; a null/blank test
+        // value is a declaration problem, not a missing business input.
+        if (entry.codeType === 0 || entry.codeType === "0")
+            constants.push(code);
     }
-    return { all, required };
+    return { all, required, constants };
 }
 /**
  * Ticket T08 — readback face for a service LIST row: an explicit field
@@ -1280,6 +1285,18 @@ export function registerB2Lane(tools) {
         const missing = face.required.filter((code) => !(code in args.testInputParametersMap));
         if (missing.length > 0)
             throw new ToolRefusalError({ status: "refused", blocker: "bizservice-test-param-missing", message: `试跑缺必填入参：${missing.join("、")}（按方法声明参数面 fail-closed，零试跑调用）`, missing });
+        // Live 2026-10-18 (SubCon): the test readback echoed
+        // {"x-lowcode-enginecode":null,...} and the caller only understood it
+        // after eating a 401. Flag declared CONST parameters supplied as
+        // null/blank BEFORE the wire: the platform injects them, so a null here
+        // means "the declaration/injection is wrong", not "the test input is
+        // missing".
+        const blankConstants = face.constants.filter((code) => {
+            if (!(code in args.testInputParametersMap))
+                return true;
+            const value = args.testInputParametersMap[code];
+            return value === null || value === undefined || (typeof value === "string" && value.trim() === "");
+        });
         const unknown = supplied.filter((code) => !face.all.includes(code));
         if (unknown.length > 0)
             throw new ToolRefusalError({ status: "refused", blocker: "bizservice-test-param-unknown", message: `试跑携带未声明参数：${unknown.join("、")}（方法参数面只有 ${face.all.join("、") || "(空)"}；不猜不透传，零试跑调用）`, unknown });
@@ -1329,6 +1346,7 @@ export function registerB2Lane(tools) {
                 result: performed.data,
                 configUnchanged,
                 externalSuccess,
+                ...(blankConstants.length ? { constantHeaderWarnings: blankConstants, constantHeaderHint: "平台注入的常量参数在试跑回显为 null/空——先确认参数声明 codeType:0 + bizCode（并为它们标 required:false）；出现 401/EngineCode 空头时优先查这里，而不是改业务入参" } : {}),
                 ...(resultBodyErrcode === undefined ? {} : { resultBodyErrcode }),
                 ...(externalSuccess ? {} : { externalFailure }),
             },

package/dist/lanes/businessrule.js

@@ -74,7 +74,8 @@ export function registerBusinessRuleLane(tools) {
         inputSchema: {
             environment: environmentArg,
             schemaCode: z.string().min(1),
-            full: z.boolean().optional().describe("行内联完整字段（id/createdTime/creator/…，并跳过 detailFile 外置）；默认行只有 code/name/enabled/status/ruleVersion/defaultRule/latestPublished——平台预置触发行（defaultRule:true）客户端自滤"),
+            onlyCustom: z.boolean().optional().describe("只回自建规则（defaultRule!==true），滤掉平台预置触发行——读面收窄，省 token"),
+            full: z.boolean().optional().describe("行内联完整字段（id/createdTime/creator/…，并跳过 detailFile 外置）；默认行只有 code/name/enabled/status/ruleVersion/defaultRule/latestPublished"),
             capability: capabilityArg,
         },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
@@ -85,9 +86,11 @@ export function registerBusinessRuleLane(tools) {
             // with full:true (the old 14-key row). rule.get resolves by business
             // 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;
             return {
                 schemaCode: args.schemaCode,
-                rules: rows.map((row) => ({
+                ...(args.onlyCustom === true ? { filtered: { onlyCustom: true, total: rows.length, returned: visible.length } } : {}),
+                rules: visible.map((row) => ({
                     code: row.code,
                     name: row.name,
                     enabled: row.enabled,

package/dist/lanes/runtime-data.js

@@ -499,8 +499,16 @@ export function registerRuntimeDataLane(tools) {
                     const selected = fields ?? Object.keys(data).filter((field) => !["id", "bizObjectId", "schemaCode", "sequenceStatus", "createdTime", "updatedTime", "creator", "updater"].includes(field));
                     return { id: row.bizObjectId ?? row.id ?? data.id, fields: Object.fromEntries(selected.map((field) => [field, data[field] ?? null])) };
                 });
+                // Live 2026-10-19: when a model has NO configured list view, the
+                // platform projects only system columns — every business field comes
+                // back null while `data.load` shows the real values. That reads as
+                // "the write failed". Detect an all-null business projection (items
+                // present, zero non-null business values) and say so.
+                const businessKeys = fields ?? Object.keys(items[0]?.fields ?? {}).filter((field) => !["id", "bizObjectId", "schemaCode", "sequenceStatus", "createdTime", "updatedTime", "creator", "updater", "name"].includes(field));
+                const projectionEmpty = items.length > 0 && businessKeys.length > 0 && items.every((item) => businessKeys.every((key) => item.fields[key] === null || item.fields[key] === undefined));
                 const readback = {
                     schemaCode: args.schemaCode,
+                    ...(projectionEmpty ? { projectionWarning: { reason: "business-columns-null", hint: "模型可能未配置列表视图：data.list 只投影列表列，业务列会全为 null；核对写入结果请用 data.load（或先建列表视图）" } } : {}),
                     ...(args.queryCode !== undefined ? { queryCode: args.queryCode } : {}),
                     total: args.showTotal === false ? null : page.total,
                     // This branch is the non-`all` read: the platform's default filter

package/dist/lanes/workflow.js

@@ -914,7 +914,21 @@ async function childTableFieldsOf(session, schemaCode) {
     };
     const rows = (await read("false")).length > 0 ? await read("false") : await read("true");
     return rows
-        .map((row) => ({ code: String(row.code ?? row.propertyCode ?? ""), name: String(row.name ?? row.code ?? ""), isChild: Number(row.type ?? row.propertyType ?? 0) === 8 || String(row.type ?? row.propertyType ?? "").toUpperCase() === "CHILD_TABLE" || row.subSchema !== undefined }))
+        .map((row) => {
+        const type = row.propertyType ?? row.type ?? 0;
+        // Live 2026-10-19: the list face carries `subSchema: null` on EVERY row,
+        // so `subSchema !== undefined` classified every scalar/relation field as
+        // a child table and refused `required` with a false reason. Only a
+        // NON-EMPTY subSchema marks a child table (plus the real type code:
+        // propertyType 8 = CHILD_TABLE / SHEET).
+        const subSchema = row.subSchema;
+        const hasSubSchema = subSchema !== undefined && subSchema !== null && String(subSchema).trim() !== "";
+        const isChild = Number(type) === 8 ||
+            String(type).toUpperCase() === "CHILD_TABLE" ||
+            String(type).toUpperCase() === "SHEET" ||
+            hasSubSchema;
+        return { code: String(row.code ?? row.propertyCode ?? ""), name: String(row.name ?? row.code ?? ""), isChild };
+    })
         .filter((row) => row.isChild && row.code !== "");
 }
 const CHILD_TABLE_LIST_BUTTONS = [

package/dist/recipes/b2-registration.js

@@ -80,8 +80,77 @@ const bizserviceSelfCallCorp = Object.freeze({
     ],
     requiresEnvironmentDerivedIds: false,
 });
+const methodCreateRestfulGet = Object.freeze({
+    id: "method-create-restful-get",
+    title: "给既有服务加一个 RESTFUL GET 方法（query 参数 + 常量头 + 出参 position）",
+    status: "offline-valid",
+    tool: "method.create",
+    args: {
+        environment,
+        serviceCode: "<service_code>",
+        methodCode: "querySupplier",
+        name: "供应商查询",
+        methodConfig: { httpType: "Get", requestBodyType: "JSON", url: "/openapi/supplier/query", frontEndExtensionEnable: true },
+        methodInputParameters: [
+            { code: "keyword", name: "关键字", required: true, configJson: { position: "QUERY_PARAMS" } },
+            { code: "x-lowcode-corpId", name: "企业ID（平台注入常量）", required: false, codeType: 0, bizCode: "<corpId>", configJson: { position: "REQUEST_HEADER" } },
+        ],
+        methodOutputParameters: [{ code: "name", name: "供应商名称", configJson: { position: "REQUEST_BODY" } }],
+    },
+    preconditions: ["服务已存在（method.create 只加方法）；methodCode 未存在；RESTFUL 每个入参与出参都带 configJson.position"],
+    conditionalRequirements: [
+        "position 仅 QUERY_PARAMS/URL_VARIABLE/REQUEST_HEADER/REQUEST_BODY/PATH_PARAMS；URL_VARIABLE 运行时 501007",
+        "平台注入常量头标 required:false，否则 method.test 缺参 fail-closed；常量值放 codeType:0 + bizCode",
+        "方法 url 走 /openapi/**（单层 + xclient）；/api/** 是双层用户态，混用鉴权即 401",
+    ],
+    priorToolReferences: [
+        { tool: "service.get", args: { environment, serviceCode: "<service_code>" }, purpose: "确认服务存在、adapterCode=RESTFUL，并照抄既有方法的 url/auth 形状" },
+    ],
+    dryRun: { supported: true, command: `omc call method.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 只做参数面本地预检，零 wire" },
+    expectedReadback: { performed: { errcode: 0 }, readback: { methodPresent: true }, next: ["method.get 复核参数面（position 读回为整数索引）"] },
+    refusalRecovery: [
+        { code: "bizservice-parameter-face-invalid", action: "按 issues 一次性修完全部非法项；position 枚举名拼写见 summary" },
+        { code: "duplicate-method", action: "方法已存在；改用 method.update" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: true,
+    prerequisiteData: { source: "service.get", fields: ["serviceCode", "adapterCode"] },
+});
+const methodCreateRestfulPost = Object.freeze({
+    id: "method-create-restful-post",
+    title: "给既有服务加一个 RESTFUL POST 方法（JSON body）",
+    status: "offline-valid",
+    tool: "method.create",
+    args: {
+        environment,
+        serviceCode: "<service_code>",
+        methodCode: "saveSupplier",
+        name: "供应商保存",
+        methodConfig: { httpType: "Post", requestBodyType: "JSON", url: "/openapi/supplier/save", frontEndExtensionEnable: true },
+        methodInputParameters: [{ code: "body", name: "供应商对象", required: true, configJson: { position: "REQUEST_BODY" } }],
+        methodOutputParameters: [{ code: "id", name: "主键", configJson: { position: "REQUEST_BODY" } }],
+    },
+    preconditions: ["服务已存在；methodCode 未存在；POST 入参 position=REQUEST_BODY，requestBodyType=JSON"],
+    conditionalRequirements: [
+        "出参也必须带 position（缺它会写成功但 invoke NPE）",
+        "方法 url 走 /openapi/** + xclient；不要用 /externalLink 免鉴权前缀",
+    ],
+    priorToolReferences: [
+        { tool: "service.get", args: { environment, serviceCode: "<service_code>" }, purpose: "照抄同 adapter 既有方法的 url 前缀与鉴权" },
+    ],
+    dryRun: { supported: true, command: `omc call method.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 零 wire" },
+    expectedReadback: { performed: { errcode: 0 }, readback: { methodPresent: true }, next: ["method.test 跑一条最小实参"] },
+    refusalRecovery: [
+        { code: "bizservice-parameter-face-invalid", action: "按 issues 一次性修全" },
+        { code: "duplicate-method", action: "改用 method.update" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: true,
+    prerequisiteData: { source: "service.get", fields: ["serviceCode", "adapterCode"] },
+});
 export const B2_METADATA = Object.freeze({
     "service.register": Object.freeze({ recipes: [restfulQueryService], relatedTools: ["service.category.list", "service.adapter_config", "service.get", "method.get"] }),
     "method.update": Object.freeze({ recipes: [bizserviceSelfCallCorp], relatedTools: ["method.get", "method.create", "service.get"] }),
+    "method.create": Object.freeze({ recipes: [methodCreateRestfulGet, methodCreateRestfulPost], relatedTools: ["method.get", "method.update", "service.get", "method.test"] }),
 });
 //# sourceMappingURL=b2-registration.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stalfh233/omc-cli",
-  "version": "0.4.55",
+  "version": "0.4.57",
   "description": "CloudPivot 8.6 configuration capability CLI — governed, fail-closed, coverage-manifest bounded.",
   "type": "module",
   "bin": {
@@ -50,9 +50,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@stalfh233/omc-fake-platform": "0.4.55",
+    "@stalfh233/omc-fake-platform": "0.4.57",
     "commander": "14.0.3",
-    "omc-core": "0.4.55",
+    "omc-core": "0.4.57",
     "proper-lockfile": "4.1.2",
     "write-file-atomic": "6.0.0",
     "zod": "^3.23.8",

package/skills/omc-business-configuration.md

@@ -238,7 +238,8 @@ omc call service.get --env local --args '{"serviceCode":"omc_demo_restful"}'
 - **写侧用名字、读侧是整数索引**（`{"position":2}` = `REQUEST_HEADER`）——核对时不要因类型变化误判"没写进去"。映射以写入名为准。
 - **常量头（平台注入，如 `X-LowCode-Corpid`/`X-LowCode-EngineCode`）标 `required:false`**：标成必填会让 `method.test` 判缺参而 fail-closed；常量值放 `codeType:0` + `bizCode`。
 - `method.test` 缺常量头时拒跑是设计：要么先补齐实参，要么把常量声明为 `required:false`。
-- 一次性把**全部**非法参数项改完再重试；逐项失败会按方法数放大往返。
+- 一次性把**全部**非法参数项改完再重试；0.4.56 起校验会一次列出全部非法项（`issues[]`）。
+- **请求头与查询参数都写在方法参数面**（`REQUEST_HEADER` / `QUERY_PARAMS`），不要另外写代码拦截器注入；平台按参数面注入，声明处就是事实源。
 
 ### 方法 URL 前缀 × 鉴权方式（混用即 401）
 

package/skills/omc-refusals.md

@@ -105,11 +105,12 @@ process exits), then retry. This guards concurrency, not approval.
 
 ## 8. Runtime / gateway errors (not tool refusals, same discipline)
 
-- `401 权限不够` (bizservice invoke / manual call) → check **URL prefix × auth** first: `/openapi/**` uses `xclient` (Client Credentials); `/api/api/**` uses user-identity token. Mixing them is a guaranteed 401. Compare with an existing successful service under the same adapter (`service.get` → method url).
-- `500` with no errcode, body only `header:X-LowCode-EngineCode should not be empty!` → add the multi-tenant header; not a business error.
-- `404 Not Found ... openresty` / `当前业务方法绑定的API在服务端找不到` → the method url prefix/layer count is wrong (double/triple `/api`); fix per the matrix, don't keep re-editing the url.
-- `position` read back as an integer while written as an enum name → read-side encoding, not a failed write.
-- **Version evidence missing**：先区分 **`pcServerUrl` 缺失**（读取耦合缺陷，0.4.54 已修，不再 fail-closed）与 **`systemVersion` 真缺失**（此时 fail-closed 正确）。不要伪造 8.6 版本。
+- `401 权限不够`（业务集成）→ 先查**前缀×鉴权**：`/openapi/**` 用 `xclient`，`/api/api/**` 用用户 token；混用必 401。对照同 adapter 既有成功服务（`service.get` 的方法 url）。
+- `500` 且仅 `X-LowCode-EngineCode should not be empty` → 补多租户头，不是业务错误。
+- `404 openresty` / `API 在服务端找不到` → url 层数不对（双层/三层 `/api`），按矩阵改一次，别反复试。
+- `position` 读回整数、写入枚举名 → 读侧编码，不是没写进去。
+- 版本证据缺失：先分 `pcServerUrl` 缺失（读取耦合，0.4.54 已修）与 `systemVersion` 真缺失（fail-closed 正确）；不要伪造 8.6。
+- `401/403` 且 body 是 HTML/空 → 网关层，不是业务拒绝；停手索要一条可运行样例，别继续改载荷。
 
 ## 9. Input / target
 

package/skills/omc-write-hazards.md

@@ -38,6 +38,14 @@ omc help omc-write-hazards
 - **运行时写值的最小形状**（组合出错只会得到一个不透明的 `50000`/NPE，逐一最小化再合）：单选关联(9) → id 字符串 `"<id>"`；**人员/组织(50/51/60/61) → `[{"id":"<id>","type":3,"name":"<名>"}]`，`type` 必填且为整数**（缺/非整数 → `BizField.parseFromClient` 拆箱 NPE→50000；用户=3、部门=1）；日期(3) → 字符串 `"2026-09-30 10:00:00"`；子表(8) → 行对象数组 `[{"<子列code>":<值>, ...}]`。先各写一条最小行通过，再组合。
 - **DATE(3) 字段的 `options.format` 必须是平台大写枚举**（`YYYY-MM-DD`、`YYYY-MM-DD HH:mm:ss`、`YYYY年MM月DD日`…），**不是 Java 的 `yyyy-MM-dd`**：平台 `DateBizField` 按字面比较，Java 写法能创建字段但**首次运行时 save 稳定 `50000`（`不支持的format`）**（2026-09-30 R5 实测）。`field.create`/`intent` 会就地拒绝非枚举值。
 
+## 业务规则与流程事件（源码实证，1.1.25）
+
+- **`Create` 的触发判定是「旧状态→新状态」**：旧 `DRAFT` 且新 `PROCESSING` 或 `COMPLETED`（`DomainServiceImpl#getDefaultRuleCode`）。所以无流程模型一调 `data.submit`（→COMPLETED）**和流程表单提交（DRAFT→PROCESSING）都触发 Create**；`data.save` 存草稿不触发。不要因为"目标表没变化"就断言规则没触发。
+- **副作用缺失归因三步**：先查执行记录（`h_log_biz_service` 按服务/方法/时间，或容器日志）→ ①无调用=规则/触发问题 ②有调用但失败=参数/权限/业务异常 ③调用成功但不可见=视图投影/事务未提交/查询条件。禁止只看目标表。
+- **BIZ_ACTION 判成功只看传输**：REST 适配器解析响应后直接返回，**不校验 `errcode`**。扩展接口回 `{"errcode":50000}` + HTTP 200 会被当成节点成功（日志 `biz action node execute successful`）。要阻断必须走表单 `onValidate` 或数据规则，不能靠业务返回码。
+- **流程事件处理器吞异常**：`start`/`end`/`cancel`/`activate` 中的 BIZ_ACTION 抛异常时，`InstanceContext#processingBusiness` 只记 `processingBusiness error.` 并返回失败结果，**流程继续**。事件处理器不能做"提交前拦截"。
+- **禁写当前单据**：BIZ_ACTION 是 HTTP 自调用，外层事务已持行锁；同事务更新当前单据会等到 15s 超时并整条回滚。副作用写独立表；需要留痕用独立事务/异步重建 `RequestContext`。
+
 ## 运行数据读取的默认过滤
 
 - `data.list` **默认不含 DRAFT**（`total` 也只算 COMPLETED）：清测试数据时 `total:0` 不代表没有残留。核对/清理一律显式 `{"all":true,"showTotal":true}`，或读回体里的过滤标注。`data.load` 用于单行核对。