@stalfh233/omc-cli 0.6.1 → 0.6.3

package/dist/capability-overview.js

@@ -107,7 +107,7 @@ const SURFACES = [
         operations: ["list", "get", "save"],
         requires: ["field"],
         intent: { level: "partial", note: "声明式支持数据事件规则与定时任务：紧凑 actions 或 nodeGraph 透传（BRANCH/BIZ_ACTION/定时图用透传）；写 route.save + rule.enable/disable。" },
-        notes: "数据事件只分发到平台预置 code 行（Create/Update/Delete）；自定义 ruleCode 需按钮/流程/定时/显式触发。**「每天定时执行」= 定时任务 TIMING_TASK（平台原生，非外部定时器、非在线 JS）**：`rule.save` 传含 SCHEDULER 节点 + `schedulerSetting`（`bizRuleType:2`）的 nodeGraph，见 `omc describe rule.save --example rule-timing-task`。保存≠可见，需 rule.enable；绑定 BizMethod 前先有已发布业务集成方法。",
+        notes: "数据事件只分发到平台预置 code 行（Create/Update/Delete）；自定义 ruleCode 需按钮/流程/定时/显式触发。**「每天定时执行」= 定时任务 TIMING_TASK（平台原生，非外部定时器、非在线 JS）**：`rule.save` 传含 SCHEDULER 节点 + `schedulerSetting`（`bizRuleType:2`）的 nodeGraph。**定时改数据**（GET_LIST + UPDATE 动作节点）见 `--example rule-timing-task`；**定时调业务集成方法**（SCHEDULER-only + `dataSourceType:BIZ_SERVICE` + `methodMapping` 含应用编码 methodCode）见 `--example rule-timing-bizservice`。保存≠可见，需 rule.enable；绑定 BizMethod 前先有已发布业务集成方法。",
     },
     {
         id: "rule-lifecycle",

package/dist/cli-output.js

@@ -110,6 +110,11 @@ function withRepeatWarning(value) {
     const status = String(envelope.status ?? "");
     if (status !== "refused" && status !== "error" && status !== "uncertain")
         return value;
+    // A5（GitLab #15）：auth-config（凭据缺失/配置问题）不是参数形状问题——
+    // 「不要微调参数重试」的提示会把排查方向带偏，实测连续 6 次失败全在改形状。
+    const errorRecord = envelope.error && typeof envelope.error === "object" ? envelope.error : undefined;
+    if (typeof errorRecord?.code === "string" && errorRecord.code === "auth-config")
+        return value;
     const result = envelope.result && typeof envelope.result === "object" ? envelope.result : undefined;
     const blocker = typeof result?.blocker === "string" ? result.blocker : typeof envelope.blocker === "string" ? envelope.blocker : undefined;
     const prior = priorRepeatedFailures(currentUsageCommand(), blocker);

package/dist/cli.js

@@ -232,6 +232,18 @@ async function cmdDoctor(store, environment, serviceCode) {
                 steps.push(`许可证    FAIL 许可证面探测失败：${redactText(error.message, [])}`);
             }
         }
+        // A5（GitLab #15）：doctor 此前只体检当前环境，其他环境「列得出、没凭据」
+        // 完全不可见——补一行全环境凭据矩阵（存在性探测，不触碰值）。
+        try {
+            const envRows = store.listEnvironments().map((item) => ({ name: item.name, credential: store.hasCredential(item.name) }));
+            const missingEnvs = envRows.filter((row) => !row.credential);
+            steps.push(missingEnvs.length === 0
+                ? `环境凭据  ok  ${envRows.map((row) => row.name).join("、")} 全部在位`
+                : `环境凭据  WARN ${missingEnvs.map((row) => row.name).join("、")} 无凭据——调用会回 auth-config（不是参数问题）；omc env list 可核对，omc setup 补`);
+        }
+        catch {
+            // 环境清单读不到不阻断体检主链路
+        }
         // T09 — optional per-service credential shape check (--service <code>).
         // Non-fatal: a masked/placeholder credential does not make the ENVIRONMENT
         // unhealthy; it explains why that service's calls would 401/500. Findings
@@ -450,7 +462,12 @@ async function cmdCall(store, args) {
     // every list read that only wanted one column paid a second artifact round.
     // `--jq` is the same path projection plus `[]` fan-out; a bare `--jq` is the
     // key inventory (the same muscle memory as `artifact get <id> --jq`).
-    const extractPaths = [...argvValues(args, "--extract"), ...argvValues(args, "--jq")];
+    const extractPaths = [...argvValues(args, "--extract"), ...argvValues(args, "--jq")]
+        // A3（GitLab #15）：逗号多路径——一张 9 列表此前要 9 次 artifact get。
+        // 路径语法（点式/下标/切片/[]/按键）不含逗号，拆分无歧义。
+        .flatMap((path) => path.split(","))
+        .map((path) => path.trim())
+        .filter(Boolean);
     // `artifact get` uses `--keys`; `call` only had `--extract-keys`, so the muscle
     // memory failed with "unknown option '--keys'" (r16 P7). Accept both.
     const extractKeys = args.includes("--extract-keys") || args.includes("--keys") || args.some((token, index) => token === "--jq" && (args[index + 1] === undefined || args[index + 1].startsWith("--")));
@@ -520,7 +537,7 @@ async function cmdCall(store, args) {
         // Keep the REJECTED path on stderr only: the machine envelope must not leak
         // host layout (ticket 103), so it carries the root plus the bare file name.
         const rejectedName = typeof argsFile === "string" ? basename(resolve(configRoot, argsFile)) : "";
-        writeEnvelope(envelope("error", {}, request, { code: "invalid-input", message: outOfRoot ? `--args-file 必须位于配置根内（配置根 ${configRoot}${rejectedName ? `；本次文件 ${rejectedName}` : ""}）` : detail, retryable: false, ...(outOfRoot ? { configurationRoot: configRoot } : {}) }));
+        writeEnvelope(envelope("error", {}, request, { code: "invalid-input", message: outOfRoot ? `--args-file 必须位于配置根内（配置根 ${configRoot}${rejectedName ? `；本次文件 ${rejectedName}` : ""}）。免落盘替代：--args - 从 stdin 读 JSON（echo '<json>' | omc call <tool> --args -），或把文件放进配置根后再引用；限制是为了防参数文件携带凭据被收进会话产物` : detail, retryable: false, ...(outOfRoot ? { configurationRoot: configRoot } : {}) }));
         return CLI_EXIT_CODES.invalidInput;
     }
     const registry = buildToolRegistry();
@@ -713,9 +730,21 @@ async function cmdArtifactGet(id, transport, options = {}) {
             return emitTransportResult(result, transport);
         }
         if (options.jq !== undefined) {
-            const projected = projectArtifactPath(artifact.content.toString("utf8") === "" ? undefined : content, options.jq);
+            // A3（GitLab #15）：逗号多路径——一次取多列（projections 数组），单路径形态不变。
+            const jqPaths = options.jq.split(",").map((path) => path.trim()).filter(Boolean);
+            const artifactContent = artifact.content.toString("utf8") === "" ? undefined : content;
+            if (jqPaths.length > 1) {
+                const projections = jqPaths.map((path) => {
+                    const projected = projectArtifactPath(artifactContent, path);
+                    return projected.missed
+                        ? { path, content: null, pathMiss: true, missedAt: projected.at, available: projected.available }
+                        : { path, content: projected.content ?? null, ...(projected.mapped !== undefined ? { mapped: projected.mapped } : {}), ...(projected.missedEntries !== undefined ? { missedEntries: projected.missedEntries } : {}) };
+                });
+                return emitTransportResult({ status: "ok", artifactId: id, sha256: artifact.sha256, projections, ...(projections.some((entry) => entry.pathMiss) ? { unanswered: true, hint: "逗号多路径中部分路径未命中（见各 projection.pathMiss/missedAt/available）；路径语法：点式 a.b、下标 a[0]、切片 a[0:6]、数组映射 items[].fields.x、按键选择 rules[code=Create]" } : {}) }, transport);
+            }
+            const projected = projectArtifactPath(artifactContent, options.jq);
             return emitTransportResult(projected.missed
-                ? { status: "ok", artifactId: id, sha256: artifact.sha256, path: options.jq, content: null, pathMiss: true, missedAt: projected.at, available: projected.available, unanswered: true, hint: `路径未命中段 "${projected.at}"——available 是该层可用的键/范围；方括号下标（a[0]）与点式（a.0）等价；[] 映射数组（items[].fields.x）；按键选择 rules[code=Create]` }
+                ? { status: "ok", artifactId: id, sha256: artifact.sha256, path: options.jq, content: null, pathMiss: true, missedAt: projected.at, available: projected.available, unanswered: true, hint: `路径未命中段 "${projected.at}"——available 是该层可用的键/范围；方括号下标（a[0]）与点式（a.0）等价；[] 映射数组（items[].fields.x）；按键选择 rules[code=Create]；一次取多列用逗号分隔路径（--jq "a.b,c.d"），本参数是路径选择器、不是 jq 语言（不支持 | 与对象构造）` }
                 : { status: "ok", artifactId: id, sha256: artifact.sha256, path: options.jq, content: projected.content ?? null, ...(projected.mapped !== undefined ? { mapped: projected.mapped } : {}), ...(projected.missedEntries !== undefined ? { missedEntries: projected.missedEntries } : {}) }, transport);
         }
         // r6-onboarding 2026-10-21: 47 artifact fetches, 0 used a projection; the 10
@@ -749,8 +778,34 @@ async function cmdArtifactGet(id, transport, options = {}) {
             }, transport);
         }
         const result = { status: "ok", artifactId: id, sha256: artifact.sha256, content };
-        if (Buffer.byteLength(JSON.stringify(result), "utf8") > transport.maxOutputBytes)
-            return emitTransportResult({ status: "ok", artifactId: id, sha256: artifact.sha256, bytes: artifact.content.length, fetch: artifactFetchHint(id) }, transport);
+        if (Buffer.byteLength(JSON.stringify(result), "utf8") > transport.maxOutputBytes) {
+            // 2026-11-04 r70: `--full` used to fall back to the same bare `fetch`
+            // pointer it had just been asked to bypass — re-running `--full` re-hits
+            // the same ceiling, so a caller that genuinely needs the body loops
+            // forever (observed live: three consecutive `--full` calls returned the
+            // same id with bytes 90K→151K→227K of pointer metadata). Say what
+            // actually happened and give the two projections that DO work.
+            const record = content && typeof content === "object" && !Array.isArray(content) ? content : undefined;
+            const keys = record
+                ? Object.entries(record)
+                    .map(([key, value]) => ({ key, bytes: Buffer.byteLength(JSON.stringify(value) ?? "null", "utf8") }))
+                    .sort((left, right) => right.bytes - left.bytes)
+                    .slice(0, 3)
+                    .map((entry) => entry.key)
+                : [];
+            return emitTransportResult({
+                status: "ok",
+                artifactId: id,
+                sha256: artifact.sha256,
+                bytes: artifact.content.length,
+                fullRejected: true,
+                reason: `整包 ${Math.round(artifact.content.length / 1024)}KB 超过本通道输出上限 ${transport.maxOutputBytes}B；--full 无法一次返回，再跑一次结果相同`,
+                ...(keys.length > 0 ? { keysCommand: `omc artifact get ${id} --keys ${keys.join(",")}`, sampledKeys: keys } : {}),
+                jqCommand: `omc artifact get ${id} --jq '<path>'`,
+                raiseCeilingCommand: `omc artifact get ${id} --full --max-output-bytes ${Math.max(artifact.content.length + 1024, transport.maxOutputBytes * 2)}`,
+                hint: "二选一：用 --jq/--keys 取你真正需要的那部分（推荐），或显式抬高 --max-output-bytes",
+            }, transport);
+        }
         return emitTransportResult(result, transport);
     }
     catch (error) {
@@ -1580,14 +1635,16 @@ async function main() {
             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 }));
+        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, credential: store.hasCredential(item.name) ? "ok" : "missing" }));
         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)");
+        // A5（GitLab #15）：credential: missing 的环境列得出、调不通（auth-config）——
+        // 标注出来，防把"没凭据"误判成"参数写错"。
         else
             for (const row of rows)
-                console.error(`${row.name}${row.isDefault ? " (default)" : ""}  ${row.baseUrl}  app=${row.applicationCode}${row.writable ? "" : "  [read-only]"}`);
+                console.error(`${row.name}${row.isDefault ? " (default)" : ""}  ${row.baseUrl}  app=${row.applicationCode}${row.writable ? "" : "  [read-only]"}${row.credential === "ok" ? "" : "  [credential: missing → omc setup]"}`);
         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); });

package/dist/config-store.js

@@ -195,6 +195,23 @@ export class ConfigStore {
             throw new ConfigurationError(`credentials store has no entry for environment ${name}`);
         return credential;
     }
+    /**
+     * A5（GitLab #15）：凭据**存在性**探测（只回 boolean，永不触碰值——凭据卫生）。
+     * env list / doctor 用它标注哪些环境真的可用，防「列得出、调不通」的方向性误判。
+     */
+    hasCredential(name) {
+        if (process.env.OMC_CLOUDPIVOT_CREDENTIAL)
+            return true;
+        if (!existsSync(this.paths.credentialsPath))
+            return false;
+        try {
+            const parsed = JSON.parse(readFileSync(this.paths.credentialsPath, "utf8"));
+            return typeof parsed[name]?.username === "string" && typeof parsed[name]?.password === "string";
+        }
+        catch {
+            return false;
+        }
+    }
     writeCredential(name, credential) {
         mkdirSync(dirname(this.paths.credentialsPath), { recursive: true });
         const existing = existsSync(this.paths.credentialsPath)

package/dist/endpoints.js

@@ -91,6 +91,11 @@ export const ENDPOINTS = {
     businessRulePublish: "/api/api/app/businessrule/publish",
     businessRuleNodeRunMap: "/api/api/app/businessrule/node_run_map",
     businessRuleEnable: "/api/api/app/businessrule/enable",
+    // 8.6.26 BusinessRuleController.java:517 与 8.1.108 均提供 disable 端点
+    // （body={schemaCode,ruleCode}）。rule.disable 直打此端点——此前走
+    // businessrule/update 拼载荷，正是 2026-11-03 issue #13 在 8.1 上踩出的
+    // 形状脆弱路径（残缺实体 → 无明细 50000）。
+    businessRuleDisable: "/api/api/app/businessrule/disable",
     businessRuleDelete: "/api/api/app/businessrule/delete",
     /**
      * Manual execution of a CUSTOM-trigger rule (the list/form button path).

package/dist/lanes/b2-registration.js

@@ -365,11 +365,37 @@ export function registerB2Lane(tools) {
             const row = fetched.data;
             if (!row)
                 return { serviceCode: args.serviceCode, methodCode: args.methodCode, present: false, absent: true, method: null };
+            const adapterCode = adapterCodeOf(serviceRow);
+            const inputParameters = normalizeParameterFaceReadback(adapterCode, decodeJsonColumn(row.inputParametersJson));
+            const outputParameters = normalizeParameterFaceReadback(adapterCode, decodeJsonColumn(row.outputParametersJson));
+            // A2 双面交叉校验（2026-11-03 issue，8.1.108 实测）：get 面（按 id）可能把
+            // DB 实有的参数面读成 "[]"（同服务短参数正常、637 字节 3 参数读空——长度
+            // 相关的平台读缺陷）。list 面同列非空而 get 面为空时，标记
+            // parametersUnreadable 并附 list 面参数，禁止下游按「无参数」处理（曾导致
+            // 把配置正确的入参误判为缺失并重配）。
+            const crossCheck = (column, face, fromListKey) => {
+                const listFace = decodeJsonColumn(listed[column]);
+                const listCount = Array.isArray(listFace) ? listFace.length : 0;
+                if (listCount === 0 || face.length > 0)
+                    return null;
+                return {
+                    parametersUnreadable: true,
+                    listFaceCount: listCount,
+                    getFaceCount: face.length,
+                    hint: `${column} 的 get 面（按 id）读回为空，但 list 面实有 ${listCount} 个参数——平台读缺陷（8.1.108 实测），勿按「无参数」处理；${fromListKey} 是 list 面读回的参数，以其为准复核`,
+                    [fromListKey]: normalizeParameterFaceReadback(adapterCode, listFace),
+                };
+            };
+            const inputCross = crossCheck("inputParametersJson", Array.isArray(inputParameters) ? inputParameters : [], "inputParametersFromList");
+            const outputCross = crossCheck("outputParametersJson", Array.isArray(outputParameters) ? outputParameters : [], "outputParametersFromList");
             const method = {
                 ...row,
-                configJson: maskServiceConfigSecrets(normalizeMethodConfigReadback(adapterCodeOf(serviceRow), decodeJsonColumn(row.configJson))),
-                inputParameters: normalizeParameterFaceReadback(adapterCodeOf(serviceRow), decodeJsonColumn(row.inputParametersJson)),
-                outputParameters: normalizeParameterFaceReadback(adapterCodeOf(serviceRow), decodeJsonColumn(row.outputParametersJson)),
+                configJson: maskServiceConfigSecrets(normalizeMethodConfigReadback(adapterCode, decodeJsonColumn(row.configJson))),
+                inputParameters,
+                outputParameters,
+                ...(inputCross || outputCross
+                    ? { readbackCaveat: { ...(inputCross ?? {}), ...(outputCross ?? {}) } }
+                    : {}),
             };
             return { serviceCode: args.serviceCode, methodCode: args.methodCode, present: true, method };
         }),

package/dist/lanes/businessrule-contract.js

@@ -12,8 +12,12 @@ export const RULE_CREATE_BODY = Object.freeze({
     status: RULE_STATUS.disabled,
     defaultRule: false,
     developmentMode: 0,
+    // 8.1 族实体校验要求结构化默认值（缺席 → 平台落 ""，update 回无明细 50000）；
+    // 8.6 同样接受。与设计器新建规则的落库形状一致（2026-11-03 issue A8）。
+    options: '{"ruleVariable":[]}',
+    extensionSetting: "{}",
 });
-export const RULE_PLATFORM_QUIRK = "enabled is the dispatch truth; status may still read DISABLED after enable — never infer enable state from status";
+export const RULE_PLATFORM_QUIRK = "enabled is the dispatch truth; status may still read DISABLED after enable — never infer enable state from status. Reverse state exists too: enable returning errcode 0 while enabled stays 0 means the ENTITY is incomplete (missing schedulerSetting.methodMapping.methodCode or empty-string options/extensionSetting break the 8.1 update validation) — fix the entity via rule.save, not by retrying enable";
 const RULE_NODE_GRAPH_EXAMPLE = '[{"nodeCode":"Start","nodeName":"开始","nodeType":"START",x,y,height,width},{"nodeCode":"UPDATE_1","nodeType":"UPDATE","targetObjectCode":"<target schemaCode>","inputParam":"_input","updateNodeType":"UPDATE_MODEL","execFormMapping":false,"filterCondition":{"mainConditions":[[{"targetSchemaDataItem":"<target field>","ruleConditionType":"EQ","ruleValueType":"DYNAMIC","currentSchemaDataItem":"<trigger field>"}]],"sheetConditions":[]},"dataActions":[{"targetDataItem":"<target field>","ruleValueType":"DYNAMIC","value":"","ruleActionType":"EQUALS","currentDataItemValue":"<trigger field>"}],x,y,height,width},{"nodeCode":"End","nodeName":"结束","nodeType":"END",x,y,height,width}]';
 export const RULE_NODE_GRAPH_WIRE = Object.freeze({
     inputParam: "_input",

package/dist/lanes/businessrule.js

@@ -8,7 +8,7 @@ import { applicationResolutionOf, applicationScopeHint, flattenTreeRows, resolve
 import { executeRuleSaveWrite, ruleNodeGraphArg } from "../rule-support.js";
 import { defineTool, ToolInputError, ToolRefusalError } from "../tool-types.js";
 import { resolveRuleRowId } from "../identity.js";
-import { wireCall, wireRows } from "../wire.js";
+import { wireCall, wireCallWith404Fallback, wireRows } from "../wire.js";
 import { BUSINESSRULE_LANE_CONTRACT } from "./businessrule-contract.js";
 const RULE_LANE = BUSINESSRULE_LANE_CONTRACT.lane;
 const RULE_TOOLS = BUSINESSRULE_LANE_CONTRACT.tools;
@@ -109,7 +109,16 @@ export function registerBusinessRuleLane(tools) {
             capability: capabilityArg,
         },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
-            const rows = wireRows((await wireCall(session, { path: ENDPOINTS.runtimeBusinessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } })).data);
+            // 版本族备选（2026-11-03 issue A1）：8.6 锚点走 runtime 面；8.1 族
+            // runtime 端点缺席（404）时下探 app 面 `businessrule/list_by_schemacode`。
+            // 仅 404 下探，401/500/业务码拒绝原样上抛。rule.save / rule.enable 的
+            // 读回本就走 app 面，两族都可用。下探发生时在结果里标注命中的端点族，
+            // 让调用方能看见自己不在锚点路径上（排查兼容问题时的关键信号）。
+            let endpointFamily = null;
+            const rows = wireRows((await wireCallWith404Fallback(session, [
+                { path: ENDPOINTS.runtimeBusinessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } },
+                { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } },
+            ], (failed, next) => { endpointFamily = { used: next.path, reason: `${failed.path} HTTP 404（端点在本版本族缺席，已下探）` }; })).data);
             // N2 (r10 noise pass): the default row is the inventory face —
             // code/name/state/publish-version/is-preset. The audit columns
             // (id/createdTime/creator/developmentMode/templateType/…) only ride
@@ -286,6 +295,8 @@ export function registerBusinessRuleLane(tools) {
             schemaCode: z.string().min(1).optional().describe("业务键定位：模型 code（与 ruleCode 同传，免去先 rule.list 取 id）"),
             ruleCode: z.string().min(1).optional().describe("业务键定位：规则 code（如 Create/Update/自定义），与 schemaCode 同传"),
             full: z.boolean().optional().describe("返回原始存储图（含确定性布局 x/y/width/height 与路由 points）；默认返回语义图，确定性布局已投影去掉（可直接重存，保存时会重新生成布局）"),
+            keys: z.array(z.string().min(1)).min(1).optional().describe("工具经济（A6）：只返回列出的顶层键（identity 键 id/code/schemaCode 恒在）。例 ['schedulerSetting'] 只看调度配置，不内联整图——对照生产规则形状时用"),
+            summary: z.boolean().optional().describe("工具经济（A6）：只返回身份与体量摘要（节点数/路由数/schedulerSetting 是否存在），不含 nodes/routes 正文"),
             capability: capabilityArg,
         },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
@@ -375,7 +386,7 @@ export function registerBusinessRuleLane(tools) {
             catch {
                 // 体检失败不破坏读回本身
             }
-            return {
+            const payload = {
                 id: ruleId,
                 absent: false,
                 code: record.code,
@@ -402,6 +413,30 @@ export function registerBusinessRuleLane(tools) {
                 ...(semanticFindings ? { semanticFindings } : {}),
                 ...(staleRow ? { staleRow, effectiveId, staleRowMessage } : {}),
             };
+            // A6 工具经济（2026-11-03 issue）：rule.get 默认内联整图（nodes/routes/
+            // schedulerSetting 全量），对照生产规则形状时往往只要一个键。summary 给
+            // 身份+体量；keys 保留列出的键 + 恒定的 identity 键。两者都作用于投影后
+            // 的返回体，full 语义不变。
+            if (args.summary === true) {
+                return {
+                    id: payload.id, code: payload.code, name: payload.name, schemaCode: payload.schemaCode,
+                    bizRuleType: payload.bizRuleType, enabled: payload.enabled, ruleStatus: payload.ruleStatus,
+                    defaultRule: payload.defaultRule, ruleVersion: payload.ruleVersion,
+                    nodeCount: Array.isArray(payload.nodes) ? payload.nodes.length : 0,
+                    routeCount: Array.isArray(payload.routes) ? payload.routes.length : 0,
+                    schedulerSettingPresent: payload.schedulerSetting !== null && payload.schedulerSetting !== undefined,
+                    schedulerSettingDataSourceType: payload.schedulerSetting && typeof payload.schedulerSetting === "object" && !Array.isArray(payload.schedulerSetting)
+                        ? payload.schedulerSetting.dataSourceType
+                        : undefined,
+                    ...(payload.statusLag ? { statusLag: payload.statusLag, statusNote: payload.statusNote } : {}),
+                };
+            }
+            if (args.keys !== undefined) {
+                const identity = new Set(["id", "code", "schemaCode"]);
+                const wanted = new Set([...args.keys, ...identity]);
+                return Object.fromEntries(Object.entries(payload).filter(([key]) => wanted.has(key)));
+            }
+            return payload;
         }, { full: args.full === true, compact: ruleCompactProjection, target: `rule.get:${args.id ?? `${args.schemaCode}/${args.ruleCode}`}` }),
     }));
     writeTool(tools, "rule.save", RULE_LANE, RULE_TOOLS["rule.save"].scope, RULE_TOOLS["rule.save"].description, {

package/dist/lanes/organization.js

@@ -74,6 +74,83 @@ function deptTypeCode(value) {
     return code;
 }
 const orgQuery = (session) => ({ corpId: session.enterpriseId() });
+/**
+ * Read the role tree (`/role/list?expandAll=true`) and flatten it, keeping the
+ * **id** alongside code/name.
+ *
+ * Why this exists (r70, live 1.1.25): `org.role.list`'s compact projection emits
+ * `code｜name` pairs and drops the id, while `add_role` / `add_role_user` /
+ * `update_ouscope` all want the id. Worse, the platform stores a wrong
+ * `roleGroupId` verbatim (`h_org_role.groupId` is not an FK): passing the group
+ * *code* that the read face shows yields errcode 0 and an orphan role — the row
+ * exists, `role/users` finds it, `role/list` never returns it, `role/get`
+ * answers 50000. Resolving code→id here removes the trap for every caller.
+ */
+async function readRoleTree(session) {
+    const data = (await wireCall(session, {
+        path: ENDPOINTS.organizationRoleList,
+        query: { corpId: session.enterpriseId(), expandAll: "true" },
+    })).data;
+    const groups = [];
+    const roles = [];
+    const childKeys = ["children", "roles", "childRoles", "childList", "list"];
+    const childrenOf = (row) => {
+        for (const key of childKeys) {
+            const value = row[key];
+            if (Array.isArray(value))
+                return value;
+        }
+        return [];
+    };
+    const walk = (rows) => {
+        for (const row of rows) {
+            const kids = childrenOf(row);
+            // A container carries group===true, or has children and no groupId; a leaf
+            // role always carries groupId (mirrors flattenRoleTree's rule).
+            const hasGroupId = row.groupId !== undefined && row.groupId !== null;
+            const isGroup = row.group === true || (!hasGroupId && kids.length > 0);
+            if (!isGroup) {
+                const id = String(row.id ?? "");
+                if (id !== "")
+                    roles.push({ id, code: String(row.code ?? ""), name: String(row.name ?? "") });
+                continue;
+            }
+            groups.push({ id: String(row.id ?? ""), code: String(row.code ?? ""), name: String(row.name ?? "") });
+            if (kids.length > 0)
+                walk(kids);
+        }
+    };
+    walk(wireRows(data));
+    return { groups, roles };
+}
+/**
+ * Resolve a caller-supplied role reference (32-hex id, or the `code` / `name`
+ * that `org.role.list` actually shows) to the platform role id. A reference that
+ * matches nothing is refused with the list of real roles — never written blind.
+ */
+async function resolveRoleRef(session, args, tool) {
+    const requested = args.roleId ?? args.roleCode;
+    if (!requested)
+        throw new ToolInputError({ status: "error", blocker: "tool-input-invalid", tool, message: "需要 roleId 或 roleCode（org.role.list 的 roles 码表给的是 code）" });
+    // An explicit roleCode must resolve — never forward it as an id.
+    if (args.roleId !== undefined && args.roleCode === undefined && /^[0-9a-f]{32}$/i.test(requested))
+        return requested;
+    const { roles } = await readRoleTree(session);
+    const match = roles.find((role) => role.code === requested) ?? roles.find((role) => role.name === requested);
+    if (match)
+        return match.id;
+    // Not a known code/name. `roleId` may still be a valid id the tree does not
+    // surface (e.g. a role in another corp); forward it and let the platform
+    // judge, rather than breaking callers that hold an id we cannot see.
+    if (args.roleId !== undefined)
+        return requested;
+    throw new ToolInputError({
+        status: "error",
+        blocker: "tool-input-invalid",
+        tool,
+        message: `角色 ${requested} 不存在。可用角色：${roles.slice(0, 30).map((role) => `${role.code}（${role.name}）`).join("；")}`,
+    });
+}
 const roleUserId = (row) => String(row.id ?? row.userId ?? row.recId ?? "");
 async function memberRows(session, roleId) {
     const data = (await wireCall(session, {
@@ -226,22 +303,43 @@ export function registerOrganizationLane(tools) {
             },
         };
     });
-    writeTool(tools, "org.role.create", LANE, SCOPES.roleCreate, "创建角色（界面「分组」；`POST organization/role/add_role`）。返回 roleId；code 创建时 null、随后补 SYS<时间戳>，要稳定编码就传 code。", {
+    writeTool(tools, "org.role.create", LANE, SCOPES.roleCreate, "创建角色（界面「分组」；`POST organization/role/add_role`）。返回 roleId；code 创建时 null、随后补 SYS<时间戳>，要稳定编码就传 code。**所属角色组推荐用 `roleGroupCode`（如 SYS_1000000）**：`org.role.list` 的紧凑码表只给 `code｜name`、不显示组 id，而平台对错的 roleGroupId **静默接受**——存进去的值不是真实组 id 时角色会变成看不见的孤儿（r70 实测：在库里、role/users 查得到，role/list 永不返回、role/get 50000）。工具会把 code 归一成真实 id，并在创建后回读可见性。", {
         roleName: z.string().min(1),
-        roleGroupId: z.string().min(1).describe("所属角色组 id（org.role.list 的 groups[].id）"),
+        roleGroupCode: z.string().min(1).optional().describe("所属角色组的 code（org.role.list 的 groups 码表，如 SYS_1000000）或名称。**推荐**；与 roleGroupId 二选一"),
+        roleGroupId: z.string().min(1).optional().describe("所属角色组 id（32 位 hex，只能从 artifact get <role.list 的 detailArtifactId> --jq groups 取到）。误传组 code 时工具会归一成真实 id"),
         roleGroupName: z.string().optional(),
         roleType: z.enum(["SYS", "CUSTOMIZE", "OTHER"]).optional().describe("默认 SYS（平台会把角色统一落成 SYS，见 RoleHelper.createRoleModel）"),
         code: z.string().optional(),
         remarks: z.string().optional(),
         corpId: z.string().min(1).optional().describe("组织 corpId，默认当前登录企业；传 \"other\" 表示非组织分组角色"),
     }, async (session, args) => {
+        if (!args.roleGroupCode && !args.roleGroupId) {
+            throw new ToolInputError({ message: "必须给 roleGroupCode（推荐）或 roleGroupId；先 org.role.list 取 groups 码表" });
+        }
+        const { groups } = await readRoleTree(session);
+        if (groups.length === 0) {
+            throw new ToolRefusalError({ status: "refused", blocker: "wire-shape", message: "org.role.list 未解析出任何角色组；先确认组织树可读，不要盲建角色" });
+        }
+        const requested = args.roleGroupId ?? args.roleGroupCode;
+        const match = groups.find((group) => group.id === requested) ??
+            groups.find((group) => group.code === requested) ??
+            groups.find((group) => group.name === requested);
+        // A code/name that resolves to nothing is a definite typo → refuse.
+        // A 32-hex id absent from the tree may be a group created moments ago in
+        // this same session; let it through and rely on the visibility backstop.
+        if (!match && args.roleGroupCode) {
+            throw new ToolInputError({
+                message: `角色组 ${requested} 不存在。可用组：${groups.map((group) => `${group.code}（id=${group.id}，${group.name}）`).join("；")}`,
+            });
+        }
+        const roleGroupId = match?.id ?? String(requested);
         const corpId = args.corpId ?? session.enterpriseId();
         const data = (await wireCall(session, {
             path: ENDPOINTS.organizationRoleAdd, method: "POST",
             query: orgQuery(session),
             body: {
                 roleName: args.roleName,
-                roleGroupId: args.roleGroupId,
+                roleGroupId,
                 ...(args.roleGroupName ? { roleGroupName: args.roleGroupName } : {}),
                 roleType: args.roleType ?? "SYS",
                 corpId,
@@ -252,15 +350,29 @@ export function registerOrganizationLane(tools) {
         const roleId = String(data?.roleId ?? data?.id ?? "");
         if (!roleId)
             throw new ToolRefusalError({ status: "refused", blocker: "wire-shape", message: "平台未返回 roleId；先 org.role.list 回读确认" });
+        // Backstop against the silent-orphan trap: re-read the tree and report the
+        // truth instead of reporting success for a role nobody can see.
+        const visible = (await readRoleTree(session)).roles.some((role) => role.id === roleId);
         const readbackCorpId = data?.corpId ?? null;
+        const warnings = [];
+        if (!visible) {
+            warnings.push(`角色 ${roleId} 创建后不在 org.role.list 任何组下（孤儿角色）：groupId 很可能没落到真实组 id。请 org.role.delete 后按 roleGroupCode 重建`);
+        }
+        if (readbackCorpId !== null && String(readbackCorpId) !== corpId) {
+            warnings.push(`平台回读 corpId=${String(readbackCorpId)}，与请求的 ${corpId} 不一致`);
+        }
         return {
             performed: { errcode: 0 },
             readback: {
                 roleId,
                 roleName: data?.roleName ?? args.roleName,
                 code: data?.code ?? null,
+                roleGroupId,
+                roleGroupCode: match?.code ?? null,
+                roleGroupName: match?.name ?? null,
+                visibleInRoleList: visible,
                 corpId: readbackCorpId,
-                ...(readbackCorpId === null || String(readbackCorpId) === corpId ? {} : { warning: `平台回读 corpId=${String(readbackCorpId)}，与请求的 ${corpId} 不一致` }),
+                ...(warnings.length > 0 ? { warning: warnings.join("；") } : {}),
             },
         };
     });
@@ -634,21 +746,23 @@ export function registerOrganizationLane(tools) {
             return { userId: String(args.userId), count: departments.length, departments };
         }),
     }));
-    writeTool(tools, "org.role.delete", LANE, SCOPES.roleDelete, "删除角色（`GET organization/role/strike_out_role?ids=`）。平台**拒绝删除仍有成员的角色**（`-1 角色下已经包含用户数据！`，实测 1.1.25）：默认先读成员数、非空即拒绝并给出人数；`force:true` 才会先逐人移出再删。", {
-        roleId: z.string().min(1),
+    writeTool(tools, "org.role.delete", LANE, SCOPES.roleDelete, "删除角色（`GET organization/role/strike_out_role?ids=`）。平台**拒绝删除仍有成员的角色**（`-1 角色下已经包含用户数据！`，实测 1.1.25）：默认先读成员数、非空即拒绝并给出人数；`force:true` 才会先逐人移出再删。**可用 roleCode 代替 roleId**（org.role.list 的码表只有 code）。", {
+        roleId: z.string().min(1).optional().describe("角色 id（32 位 hex）；与 roleCode 二选一"),
+        roleCode: z.string().min(1).optional().describe("角色 code（org.role.list 的 roles 码表，如 qc_manager）或名称"),
         force: z.boolean().optional().describe("true = 先移出全部成员再删角色"),
     }, async (session, args) => {
-        const rows = await memberRows(session, String(args.roleId));
+        const roleId = await resolveRoleRef(session, { roleId: args.roleId, roleCode: args.roleCode }, "org.role.delete");
+        const rows = await memberRows(session, roleId);
         if (rows.length > 0 && args.force !== true)
             throw new ToolRefusalError({
-                status: "refused", blocker: "role-has-members", roleId: String(args.roleId), members: rows.length,
-                nextCommand: `omc call org.role.delete --args '${JSON.stringify({ roleId: String(args.roleId), force: true })}'`,
+                status: "refused", blocker: "role-has-members", roleId, members: rows.length,
+                nextCommand: `omc call org.role.delete --args '${JSON.stringify({ roleId, force: true })}'`,
                 message: `角色下还有 ${rows.length} 名成员，平台拒绝删除（errmsg：角色下已经包含用户数据）。先 org.role.removeUsers，或传 force:true 让工具移出后再删。`,
             });
         if (rows.length > 0)
-            await removeMembers(session, String(args.roleId), rows.map(roleUserId));
-        await wireCall(session, { path: ENDPOINTS.organizationRoleDelete, query: { ...orgQuery(session), ids: String(args.roleId) } });
-        return { performed: { errcode: 0 }, readback: { roleId: String(args.roleId), deleted: true, removedMembers: rows.length } };
+            await removeMembers(session, roleId, rows.map(roleUserId));
+        await wireCall(session, { path: ENDPOINTS.organizationRoleDelete, query: { ...orgQuery(session), ids: roleId } });
+        return { performed: { errcode: 0 }, readback: { roleId, deleted: true, removedMembers: rows.length } };
     });
     writeTool(tools, "org.roleGroup.delete", LANE, SCOPES.roleGroupDelete, "删除角色组（`GET organization/role/strike_out_role_group?ids=`）。平台**拒绝删除仍含角色的组**（`-1 角色组下已经包含角色数据！`）：默认先数角色、非空即拒绝；`force:true` 会逐个删角色（含其成员）再删组。", {
         roleGroupId: z.string().min(1),
@@ -730,7 +844,8 @@ export function registerOrganizationLane(tools) {
         };
     });
     writeTool(tools, "org.role.addUsers", LANE, SCOPES.addUsers, "加成员并（可选）一次设好管理范围（`add_role_user` + 逐人 `update_ouscope`，一个工具调用）。users[].id 必须是 recId（org.user.search 的 id）；传 `scopes` 会应用到本次新增的每个人。**平台的 add_role_user 虽然收 `ouScope` 但会忽略它**（实测 1.1.25，回读仍为空），所以范围必须单独写——工具内部已按顺序完成。加完回读成员与范围。", {
-        roleId: z.string().min(1),
+        roleId: z.string().min(1).optional().describe("角色 id（32 位 hex）；与 roleCode 二选一"),
+        roleCode: z.string().min(1).optional().describe("角色 code（org.role.list 的 roles 码表）或名称——省掉取 artifact 找 id"),
         users: z.array(z.object({ id: z.string().min(1).describe("用户记录 id（recId）"), name: z.string().min(1) })).min(1),
         scopes: z.array(z.object({
             id: z.string().min(1).describe("部门 id"),
@@ -744,15 +859,16 @@ export function registerOrganizationLane(tools) {
         const users = args.users ?? args.userIds ?? [];
         if (users.length === 0)
             throw new ToolInputError({ status: "error", blocker: "tool-input-invalid", tool: "org.role.addUsers", message: "需要 users（或 userIds）至少一人" });
+        const roleId = await resolveRoleRef(session, { roleId: args.roleId, roleCode: args.roleCode }, "org.role.addUsers");
         await wireCall(session, {
             path: ENDPOINTS.organizationRoleAddUser, method: "POST",
             query: orgQuery(session),
-            body: { roleId: args.roleId, sortKey: args.sortKey ?? 999, userIds: users.map((user) => ({ id: user.id, name: user.name, type: 3, unitType: "3" })) },
+            body: { roleId, sortKey: args.sortKey ?? 999, userIds: users.map((user) => ({ id: user.id, name: user.name, type: 3, unitType: "3" })) },
         });
         const readback = async () => {
             const data = (await wireCall(session, {
                 path: ENDPOINTS.organizationRoleUsers,
-                query: { ...orgQuery(session), roleId: String(args.roleId), page: "0", size: "500" },
+                query: { ...orgQuery(session), roleId: roleId, page: "0", size: "500" },
             })).data;
             return Array.isArray(data?.content) ? data.content : wireRows(data);
         };
@@ -766,11 +882,11 @@ export function registerOrganizationLane(tools) {
             for (const id of added) {
                 await wireCall(session, {
                     path: ENDPOINTS.organizationRoleUpdateOuScope, method: "POST", query: orgQuery(session),
-                    body: { roleId: String(args.roleId), userId: id, unitType: 3, sortKey: args.sortKey ?? 999, ouScopeList },
+                    body: { roleId: roleId, userId: id, unitType: 3, sortKey: args.sortKey ?? 999, ouScopeList },
                 });
                 const scope = wireRows((await wireCall(session, {
                     path: ENDPOINTS.organizationRoleGetOuScope,
-                    query: { ...orgQuery(session), roleId: String(args.roleId), userId: id },
+                    query: { ...orgQuery(session), roleId: roleId, userId: id },
                 })).data);
                 scopeResults.push({ userId: id, scopes: scope.length });
             }
@@ -778,7 +894,7 @@ export function registerOrganizationLane(tools) {
         return {
             performed: { errcode: 0 },
             readback: {
-                roleId: String(args.roleId), added,
+                roleId: roleId, added,
                 ...(missing.length > 0 ? { missing, hint: "这些 recId 未出现在成员列表：确认 id 是 recId、用户未离职/禁用" } : {}),
                 ...(scopeResults.length > 0 ? { scopeResults } : {}),
                 // ouScope 是流程角色参与人解析的过滤维度：平台
@@ -802,12 +918,14 @@ export function registerOrganizationLane(tools) {
         };
     });
     writeTool(tools, "org.role.removeUsers", LANE, SCOPES.removeUsers, "把成员移出角色（`POST organization/role/strike_out_role_user`）。**平台要求 JSON body `{roleId,userIds:[...]}`**——用 query 或 `ids` 会报 10009 `Required request body is missing`（实测 1.1.25）。只移出角色，不删用户。", {
-        roleId: z.string().min(1),
+        roleId: z.string().min(1).optional().describe("角色 id（32 位 hex）；与 roleCode 二选一"),
+        roleCode: z.string().min(1).optional().describe("角色 code（org.role.list 的 roles 码表）或名称"),
         ids: z.array(z.string().min(1)).min(1).describe("要移出的成员 recId 列表"),
     }, async (session, args) => {
+        const roleId = await resolveRoleRef(session, { roleId: args.roleId, roleCode: args.roleCode }, "org.role.removeUsers");
         await wireCall(session, {
             path: ENDPOINTS.organizationRoleRemoveUser, method: "POST", query: orgQuery(session),
-            body: { roleId: String(args.roleId), userIds: args.ids },
+            body: { roleId, userIds: args.ids },
         });
         const data = (await wireCall(session, {
             path: ENDPOINTS.organizationRoleUsers,
@@ -818,7 +936,8 @@ export function registerOrganizationLane(tools) {
         return { performed: { errcode: 0 }, readback: { roleId: String(args.roleId), removed: args.ids.filter((id) => !present.has(id)), stillPresent: args.ids.filter((id) => present.has(id)), total: data?.totalElements ?? rows.length } };
     });
     writeTool(tools, "org.role.setUserScope", LANE, SCOPES.setScope, "设置成员管理范围（`POST organization/role/update_ouscope`）。平台覆盖语义、无回滚：默认读旧值合并（mode:\"merge\"），mode:\"replace\" 才整体替换。unitType 传数字 3（addUsers 里是字符串 \"3\"）。节点 {id,name,type:\"1\",deptPath}。", {
-        roleId: z.string().min(1),
+        roleId: z.string().min(1).optional().describe("角色 id（32 位 hex）；与 roleCode 二选一"),
+        roleCode: z.string().min(1).optional().describe("角色 code（org.role.list 的 roles 码表）或名称"),
         userId: z.string().min(1).describe("成员 recId"),
         scopes: z.array(z.object({
             id: z.string().min(1).describe("部门 id"),
@@ -832,9 +951,10 @@ export function registerOrganizationLane(tools) {
         mode: z.enum(["merge", "replace"]).optional().describe("默认 merge（读旧值合并）；replace = 覆盖整个范围"),
         dryRun: z.boolean().optional(),
     }, async (session, args) => {
+        const roleId = await resolveRoleRef(session, { roleId: args.roleId, roleCode: args.roleCode }, "org.role.setUserScope");
         const before = wireRows((await wireCall(session, {
             path: ENDPOINTS.organizationRoleGetOuScope,
-            query: { ...orgQuery(session), roleId: args.roleId, userId: args.userId },
+            query: { ...orgQuery(session), roleId, userId: args.userId },
         })).data);
         const wanted = args.scopes.map((scope) => ({ id: scope.id, name: scope.name, type: scope.type === undefined ? "1" : String(scope.type), ...(scope.deptPath ? { deptPath: scope.deptPath } : {}) }));
         const merged = args.mode === "replace"
@@ -850,15 +970,15 @@ export function registerOrganizationLane(tools) {
         await wireCall(session, {
             path: ENDPOINTS.organizationRoleUpdateOuScope, method: "POST",
             query: orgQuery(session),
-            body: { roleId: args.roleId, userId: args.userId, unitType: 3, sortKey: 999, ouScopeList: merged },
+            body: { roleId, userId: args.userId, unitType: 3, sortKey: 999, ouScopeList: merged },
         });
         const after = wireRows((await wireCall(session, {
             path: ENDPOINTS.organizationRoleGetOuScope,
-            query: { ...orgQuery(session), roleId: args.roleId, userId: args.userId },
+            query: { ...orgQuery(session), roleId, userId: args.userId },
         })).data).map((row) => ({ id: row.id ?? null, name: row.name ?? null, type: row.type ?? null, deptPath: row.deptPath ?? null }));
         return {
             performed: { errcode: 0 },
-            readback: { roleId: args.roleId, userId: args.userId, mode: args.mode ?? "merge", before: before.length, after: after.length, scopes: after, ...(removed.length > 0 ? { removedScopeIds: removed } : {}) },
+            readback: { roleId, userId: args.userId, mode: args.mode ?? "merge", before: before.length, after: after.length, scopes: after, ...(removed.length > 0 ? { removedScopeIds: removed } : {}) },
         };
     });
 }

package/dist/lanes/rule-lifecycle.js

@@ -119,7 +119,14 @@ export async function executeRuleEnableWrite(session, args) {
                 message: `规则 ${args.ruleCode} 启用时被平台自检拒绝（550018）。${detail.nodeChecks.length > 0 ? `问题节点：${JSON.stringify(detail.nodeChecks).slice(0, 600)}` : "先用 field.list(all:true) 核对引用的字段是否已发布。"}`,
             });
         }
-        throw error;
+        // 版本族备选（2026-11-03 issue A1 更正，8.1.108 实测）：8.1 族没有
+        // `businessrule/publish` 端点（HTTP 404）。已验证的等价路径是
+        // `businessrule/update` 携完整实体 + enabled:true —— 实体完整时一次调用
+        // 同时翻转 enabled 与 status（见 issue 复现脚本）。仅 404 下探，其余原样抛。
+        const publishEndpointAbsent = error instanceof WireError && error.kind === "http-status" && error.diagnostic?.httpStatus === 404;
+        if (!publishEndpointAbsent)
+            throw error;
+        published = await wireCall(session, { path: ENDPOINTS.businessRuleUpdate, method: "POST", body: { ...full, enabled: true, status: "ENABLED" } });
     }
     let enableErrcode = 0;
     let alreadyEnabled = false;
@@ -147,7 +154,10 @@ export function registerRuleLifecycleLane(tools) {
         const row = wireRows(list.data).find((item) => item.code === args.ruleCode);
         if (!row?.id)
             throw new WireError("business", `rule ${args.ruleCode} not found for disable`, 302024);
-        const performed = await wireCall(session, { path: ENDPOINTS.businessRuleUpdate, method: "POST", body: { ...row, enabled: false, status: "DISABLED" } });
+        // 2026-11-04（源码实证，GitLab #13）：8.6 与 8.1 都有 businessrule/disable
+        // 端点（body={schemaCode,ruleCode}），UI 开关同款——直打，不再用 update
+        // 拼载荷（残缺实体在 8.1 会回无明细 50000，正是 issue 的 disable 故障形态）。
+        const performed = await wireCall(session, { path: ENDPOINTS.businessRuleDisable, method: "POST", body: { schemaCode: args.schemaCode, ruleCode: args.ruleCode } });
         const readback = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
         const after = wireRows(readback.data).find((item) => item.code === args.ruleCode);
         return { performed: { errcode: performed.errcode }, readback: { enabled: after?.enabled === true } };

package/dist/lanes/runtime-data.js

@@ -12,6 +12,40 @@ import { CHILD_TABLE_PROPERTY_TYPE, diagnoseApprovalSubmitIdentity, runtimeWrite
 import { getReplayToken, searchWorkItems, wireString } from "../workflow-support.js";
 import { ENGINE_OWNED_KEYS, RUNTIME_DATA_LANE_CONTRACT, RUNTIME_DATA_WIRE, runtimeFormDataArg, } from "./runtime-data-contract.js";
 import { SYSTEM_FIELD_CODES } from "../field-families.js";
+// A2（GitLab #15，2026-11-04）：单选/字典字段（RADIO/CHECKBOX/DROPDOWN_BOX/
+// DROPDOWN_MULTI_BOX）在运行面查询按**字典 key**匹配，不按显示值——按「已审核」
+// 这类显示值过滤会静默 0 条；加 `_key` 后缀的字段名则不在发布元数据里，直接拒。
+// 两个方向都给写法提示，防"total:0 被读成查不到数据"（实测 313 条被误读）。
+const CHOICE_FILTER_PROPERTY_TYPES = new Set([12, 13, 14, 15]);
+function collectConditionLeafFields(condition) {
+    const codes = [];
+    const walk = (node) => {
+        if (Array.isArray(node)) {
+            node.forEach(walk);
+            return;
+        }
+        if (node === null || typeof node !== "object")
+            return;
+        const leaf = node;
+        if (typeof leaf.propertyCode === "string" && leaf.propertyCode)
+            codes.push(leaf.propertyCode);
+        Object.values(leaf).forEach(walk);
+    };
+    walk(condition);
+    return [...new Set(codes)];
+}
+function choiceKeySuffixHint(missing, typeByCode) {
+    const bases = missing
+        .filter((code) => code.endsWith("_key"))
+        .map((code) => code.slice(0, -"_key".length))
+        .filter((base) => CHOICE_FILTER_PROPERTY_TYPES.has(typeByCode.get(base) ?? -1));
+    if (bases.length === 0)
+        return "";
+    return `；${bases.join("、")} 是单选/多选（字典来源）字段：列表虽同时返回 code 与 code_key，但过滤要用原字段名 + 字典 key 值（不是 _key 后缀的字段名、也不是显示值）；key 可用 dictionary.names 查，或改 rawCondition 绕过字段元数据校验`;
+}
+function choiceFilterValueHint(fields) {
+    return `total:0 且过滤字段 ${fields.join("、")} 是单选/多选（字典来源）：平台查询按字典 key 匹配而非显示值——若 value 用的是显示值（如「已审核」），换字典 key（如 YSH，dictionary.names 可查）再试；确认确无数据再下「查不到」结论；也可用 rawCondition 或先无过滤查询复核 total`;
+}
 const RUNTIME_LANE = RUNTIME_DATA_LANE_CONTRACT.lane;
 const RUNTIME_TOOLS = RUNTIME_DATA_LANE_CONTRACT.tools;
 /**
@@ -789,6 +823,8 @@ export function registerRuntimeDataLane(tools) {
                 throw error;
             }
             return governedRead(ctx, self, args, async (session) => {
+                // A2：DSL 过滤命中的单选/字典字段（total:0 时给值写法提示）
+                let choiceFilterFields = [];
                 // Published field metadata is the sole source for filter propertyType
                 // injection AND for the projectionHint below. Fetch at most once per
                 // call: the DSL path needs it up front; the hint path asks only after
@@ -813,9 +849,13 @@ export function registerRuntimeDataLane(tools) {
                             status: "refused",
                             blocker: "unknown-filter-field",
                             missing: injected.missing,
-                            message: `filter fields not found in published field metadata: ${injected.missing.join(", ")}; the runtime query requires each leaf's propertyType from field metadata (no guessing); system/foreign fields may use rawCondition`,
+                            message: `filter fields not found in published field metadata: ${injected.missing.join(", ")}; the runtime query requires each leaf's propertyType from field metadata (no guessing); system/foreign fields may use rawCondition` + choiceKeySuffixHint(injected.missing, typeByCode),
                         };
                     condition = injected.condition;
+                    // A2（GitLab #15）：单选/字典字段按显示值过滤会静默 0 条（平台查询按
+                    // 字典 key 匹配）。带出这些字段，total:0 时给写法提示，防"查不到数据"
+                    // 误报（实测 313 条被 total:0 误读成"今天没有已审核单"）。
+                    choiceFilterFields = collectConditionLeafFields(condition).filter((code) => CHOICE_FILTER_PROPERTY_TYPES.has(typeByCode.get(code) ?? -1));
                 }
                 const requestedFields = args.displayFields ?? args.columns;
                 const fields = requestedFields && requestedFields.length > 0 ? requestedFields : undefined;
@@ -840,7 +880,7 @@ export function registerRuntimeDataLane(tools) {
                     const firstPage = extractBizObjectPage(first.data);
                     const total = Number(firstPage.total ?? 0);
                     if (total === 0 || firstPage.content.length === 0)
-                        return { schemaCode: args.schemaCode, total: 0, page: "all", size: 0, pagesFetched: 0, items: [] };
+                        return { schemaCode: args.schemaCode, total: 0, page: "all", size: 0, pagesFetched: 0, items: [], ...(choiceFilterFields.length > 0 ? { filterValueHint: choiceFilterValueHint(choiceFilterFields) } : {}) };
                     const rows = [...firstPage.content];
                     const target = Math.min(total, CAP);
                     let pageIndex = 1;
@@ -860,7 +900,22 @@ 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])) };
                     });
-                    return { schemaCode: args.schemaCode, total, page: "all", size: rows.length, pagesFetched: pageIndex, ...(capped ? { capped: true, capNotice: `结果超过安全上限 ${CAP}，已截断；请加 filters 分批` } : {}), items };
+                    // A6（GitLab #15）：all:true 路径此前完全没有 projectionHint——未配置列
+                    // 的 null/省略同样要点名，防「全量拉取却被投影坑」（实测 orderChange）。
+                    let allHint;
+                    if (items.length > 0) {
+                        try {
+                            const typeByCode = await publishedTypeByCode();
+                            const returnedKeys = new Set(Object.keys(items[0]?.fields ?? {}));
+                            const hintColumns = [...typeByCode.keys()].filter((field) => !SYSTEM_FIELD_CODES.has(field) && (!returnedKeys.has(field) || items.every((item) => item.fields[field] === null)));
+                            if (hintColumns.length > 0)
+                                allHint = `这些列在默认视图未配置（值可能存在但列表投影为 null 或整列省略）：${hintColumns.join("、")}；先用 listview.configure 配置列，或用 data.load 读单条权威值`;
+                        }
+                        catch {
+                            // 元数据读失败不阻断数据返回
+                        }
+                    }
+                    return { schemaCode: args.schemaCode, total, page: "all", size: rows.length, pagesFetched: pageIndex, ...(capped ? { capped: true, capNotice: `结果超过安全上限 ${CAP}，已截断；请加 filters 分批` } : {}), ...(allHint ? { projectionHint: allHint } : {}), items };
                 }
                 let result;
                 try {
@@ -868,7 +923,7 @@ export function registerRuntimeDataLane(tools) {
                 }
                 catch (error) {
                     if (error instanceof WireError && error.kind === "business" && error.errcode === RUNTIME_DATA_WIRE.emptyModelErrcode) {
-                        return { schemaCode: args.schemaCode, total: 0, totalPages: 0, page: args.page ?? 0, size: args.size ?? 10, items: [] };
+                        return { schemaCode: args.schemaCode, total: 0, totalPages: 0, page: args.page ?? 0, size: args.size ?? 10, items: [], ...(choiceFilterFields.length > 0 ? { filterValueHint: choiceFilterValueHint(choiceFilterFields) } : {}) };
                     }
                     // r30: a MISSING model answers this face with a generic 50000
                     // 服务异常 — indistinguishable from a real outage. One field-face
@@ -921,6 +976,7 @@ export function registerRuntimeDataLane(tools) {
                     // (live 2026-10-18: total:0 was read as "no residue" while 9 drafts
                     // existed).
                     filter: { excludedDraft: true, hint: "默认不含 DRAFT（total 亦仅计非草稿）；核对/清理残留请加 all:true" },
+                    ...(choiceFilterFields.length > 0 && Number(page.total ?? 0) === 0 ? { filterValueHint: choiceFilterValueHint(choiceFilterFields) } : {}),
                     totalPages: page.totalPages,
                     page: page.page ?? args.page ?? 0,
                     size: page.size ?? args.size ?? 20,
@@ -942,6 +998,26 @@ export function registerRuntimeDataLane(tools) {
                     const typeByCode = await publishedTypeByCode();
                     return candidates.filter((field) => typeByCode.has(field));
                 };
+                // A6（GitLab #15，2026-11-04）：未配置列有两种投影形态——值为 null，或
+                // **整键省略**（orderChange 实测：sequenceNo 在 data.list 里根本不出现，
+                // data.load 却有值，被误读成「单号为空」）。省略检测需要发布元数据
+                // （fieldList 有 60s wire 缓存，DSL 过滤路径本就已取）；两种形态合并进 hint。
+                const projectionHintFor = async () => {
+                    if (items.length === 0)
+                        return undefined;
+                    const typeByCode = await publishedTypeByCode();
+                    const returnedKeys = new Set(Object.keys(items[0]?.fields ?? {}));
+                    const nullColumns = fields && fields.length > 0
+                        ? fields.filter((field) => typeByCode.has(field) && items.every((item) => item.fields[field] === null))
+                        : [...returnedKeys].filter((field) => !SYSTEM_FIELD_CODES.has(field) && typeByCode.has(field) && items.every((item) => item.fields[field] === null));
+                    const omittedColumns = !fields
+                        ? [...typeByCode.keys()].filter((field) => !SYSTEM_FIELD_CODES.has(field) && !returnedKeys.has(field))
+                        : [];
+                    const hintColumns = [...new Set([...nullColumns, ...omittedColumns])];
+                    if (hintColumns.length === 0)
+                        return undefined;
+                    return `这些列在默认视图未配置（值可能存在但列表投影为 null 或整列省略）：${hintColumns.join("、")}；先用 listview.configure 配置列，或用 data.load 读单条权威值`;
+                };
                 if (fields &&
                     fields.length > 0 &&
                     items.length > 0 &&
@@ -955,9 +1031,9 @@ export function registerRuntimeDataLane(tools) {
                     // business fields absent from the list view render as null in every
                     // row with no explanation. Name the null'd business columns so the
                     // agent reads data.load instead of misdiagnosing "data lost".
-                    const nullColumns = await businessNullColumns();
-                    if (nullColumns.length > 0)
-                        readback.projectionHint = `这些列在默认视图未配置（值可能存在但列表投影为 null）：${nullColumns.join("、")}；先用 listview.configure 配置列，或用 data.load 读单条权威值`;
+                    const hint = await projectionHintFor();
+                    if (hint)
+                        readback.projectionHint = hint;
                 }
                 return readback;
             }, { full: args.full === true, target: `data.list:${JSON.stringify({ schemaCode: args.schemaCode, queryCode: args.queryCode ?? args.schemaCode, filter: args.filter, filters: args.filters, filterGroup: args.filterGroup, rawCondition: args.rawCondition, displayFields: args.displayFields, columns: args.columns, page: args.page ?? 0, size: args.size ?? 10 })}` });

package/dist/path-projection.js

@@ -144,7 +144,7 @@ function argvValues(args, name) {
     return values;
 }
 /** Shared wording for every projection miss, so all three faces teach the same syntax. */
-const PATH_MISS_HINT = "路径未命中（这一层没有该段）。可用写法：点式 a.b、下标 a[0]、切片 a[0:6]、数组映射 items[].fields.x、按键选择 rules[code=Create] 或 data.activities[code=A1]（数组与 index→条目对象都支持；键名可省 activityCode/nodeCode 等别名；返回第一个匹配项）。available 是该层真实存在的键。";
+const PATH_MISS_HINT = "路径未命中（这一层没有该段）。可用写法：点式 a.b、下标 a[0]、切片 a[0:6]、数组映射 items[].fields.x、按键选择 rules[code=Create] 或 data.activities[code=A1]（数组与 index→条目对象都支持；键名可省 activityCode/nodeCode 等别名；返回第一个匹配项）。available 是该层真实存在的键。注意：本参数是路径选择器、不是 jq 语言（不支持 | 管道与对象构造）；一次取多列用逗号分隔（--jq \"a.b,c.d\"）或重复传 --jq。";
 /**
  * `call --extract/--extract-keys`: resolve paths inside the result's own
  * artifact (or inside the result object when the tool returned no artifact).

package/dist/read.js

@@ -54,7 +54,7 @@ export async function governedRead(ctx, tool, args, execute, options = {}) {
         const targetFingerprint = sha256(result);
         const cached = ctx.readbackCache.get(target);
         if (ctx.readbackCacheBypass === 0 && cached && cached.environmentFingerprint === environmentFingerprint && cached.targetFingerprint === targetFingerprint && options.full !== true)
-            return { status: "ok", unchanged: true, detailFile: cached.detailFile, detailSha256: cached.detailSha256, environmentFingerprint };
+            return { status: "ok", unchanged: true, detailFile: cached.detailFile, detailSha256: cached.detailSha256, ...(cached.shapePlaceholders ?? {}), environmentFingerprint };
         const detail = { status: "ok", ...result, environmentFingerprint };
         // 2026-11-01 预算批 v2（r38 usage 实证）：1-4KB 中结果 59 次/135KB≈37% 全内联，
         // model.inspect 17 次全部卡在旧门下。降到 2048；compact 对配置清单保形为码表
@@ -62,19 +62,26 @@ export async function governedRead(ctx, tool, args, execute, options = {}) {
         const large = jsonBytes(result) > 2048;
         const fileName = `${tool.name.replace(/[^a-zA-Z0-9._-]/g, "_")}-${sha256(target).slice(0, 16)}.json`;
         const artifactRef = writeArtifact(ctx, fileName, detail);
-        ctx.readbackCache.set(target, { environmentFingerprint, targetFingerprint, detailFile: artifactRef.detailFile, detailSha256: artifactRef.detailSha256 });
+        const cacheEntry = { environmentFingerprint, targetFingerprint, detailFile: artifactRef.detailFile, detailSha256: artifactRef.detailSha256 };
         if (options.full === true) {
             const rawBytes = jsonBytes(result);
             // Small raw bodies keep the old inline behaviour; large ones are dieted
             // (see FULL_INLINE_CEILING_BYTES). The raw body stays fully reachable via
             // the artifact, so no capability is lost — only the inline copy is skipped.
-            if (rawBytes <= FULL_INLINE_CEILING_BYTES)
+            if (rawBytes <= FULL_INLINE_CEILING_BYTES) {
+                ctx.readbackCache.set(target, cacheEntry);
                 return { ...detail, detailFile: artifactRef.detailFile, detailSha256: artifactRef.detailSha256 };
+            }
             const compact = options.compact ? options.compact(result, session) : compactReadback(result);
+            // A1：外置与内联同形——被折叠的 payload 键补回空占位；缓存同样记占位，
+            // unchanged 二次读回时不丢形状（GitLab #15）。
+            const placeholders = externalizedShapePlaceholders(result, droppedShapeKeys(result, compact));
+            ctx.readbackCache.set(target, { ...cacheEntry, shapePlaceholders: placeholders });
             return {
                 status: "ok",
                 ...passthroughScalars(result),
                 ...compact,
+                ...placeholders,
                 full: true,
                 fullOmitted: true,
                 fullBytes: rawBytes,
@@ -84,10 +91,14 @@ export async function governedRead(ctx, tool, args, execute, options = {}) {
                 detailSha256: artifactRef.detailSha256,
             };
         }
-        if (!large)
+        if (!large) {
+            ctx.readbackCache.set(target, cacheEntry);
             return { status: "ok", ...result, environmentFingerprint };
+        }
         const compact = options.compact ? options.compact(result, session) : compactReadback(result);
-        return { status: "ok", ...passthroughScalars(result), ...compact, environmentFingerprint, detailFile: artifactRef.detailFile, detailSha256: artifactRef.detailSha256 };
+        const placeholders = externalizedShapePlaceholders(result, droppedShapeKeys(result, compact));
+        ctx.readbackCache.set(target, { ...cacheEntry, shapePlaceholders: placeholders });
+        return { status: "ok", ...passthroughScalars(result), ...compact, ...placeholders, environmentFingerprint, detailFile: artifactRef.detailFile, detailSha256: artifactRef.detailSha256 };
     }
     catch (error) {
         if (isUncertainWireError(error))
@@ -97,6 +108,22 @@ export async function governedRead(ctx, tool, args, execute, options = {}) {
         throw error;
     }
 }
+/**
+ * A1（GitLab #15，2026-11-04）：外置结果与内联同形。compact 把 BULKY_READ_KEYS
+ * （items/data/…）折叠成 `*Count` 后，按内联形状取数的脚本读 `result.items` /
+ * `result.data` 直接 TypeError——外置只是把数据搬进 artifact，不应改变返回形状。
+ * 被折叠的键补回为空占位（原值是数组→[]，否则 null）并标记 truncatedKeys；
+ * 真实数据在 detailFile 指向的 artifact 里，根键与内联一致（list=items、load=data）。
+ */
+function externalizedShapePlaceholders(result, dropped) {
+    const placeholders = { truncatedKeys: [...dropped], truncated: true };
+    for (const key of dropped)
+        placeholders[key] = Array.isArray(result[key]) ? [] : null;
+    return placeholders;
+}
+function droppedShapeKeys(result, payload) {
+    return Object.keys(result).filter((key) => BULKY_READ_KEYS.has(key) && !(key in payload));
+}
 function compactReadback(result) {
     const compact = {};
     for (const [key, value] of Object.entries(result)) {

package/dist/recipes/businessrule.js

@@ -167,6 +167,88 @@ const ruleTimingTask = Object.freeze({
     ],
     requiresEnvironmentDerivedIds: false,
 });
+const ruleTimingBizService = Object.freeze({
+    id: "rule-timing-bizservice",
+    title: "定时任务：定时调用业务方法（SCHEDULER-only 图 + BIZ_SERVICE，生产 106 条实证形状）",
+    aliases: ["定时调服务", "定时调接口", "定时调用方法", "BIZ_SERVICE", "定时调方法"],
+    status: "requires-prior-readback",
+    tool: "rule.save",
+    args: {
+        environment,
+        schemaCode: model,
+        ruleCode: "<customRuleCode e.g. nightly_ledger_rebuild>",
+        name: "每日台账重建",
+        nodeGraph: {
+            bizRuleType: 2,
+            // 与 rule-timing-task 的关键差异：**无动作节点**——方法挂在 schedulerSetting
+            // 上，不是 SCHEDULER 后面再接 UPDATE/BIZ_ACTION。生产 106 条「定时调服务」
+            // 全部是这个形状（Start → SCHEDULER → End）。
+            nodes: [
+                { nodeCode: "Start", nodeName: "开始", nodeType: "START" },
+                { nodeCode: "SCHEDULER", nodeName: "定时作业", nodeType: "SCHEDULER", isSystemNode: true, nodeCategory: "systemNode" },
+                { nodeCode: "End", nodeName: "结束", nodeType: "END" },
+            ],
+            routes: [
+                { preNode: "Start", postNode: "SCHEDULER", routeCondition: true },
+                { preNode: "SCHEDULER", postNode: "End", routeCondition: true },
+            ],
+            schedulerSetting: {
+                triggerTimeType: "SELECTED_TIME",
+                cycleType: "DAY",
+                executeType: "CYCLE",
+                execCycle: 1,
+                hour: 2,
+                minute: 0,
+                second: 0,
+                startTime: "<yyyy-MM-dd HH:mm:ss，未来时刻>",
+                endType: "NEVER",
+                // 定时调用业务集成方法：以方法为数据源，调度到点直接调用。
+                dataSourceType: "BIZ_SERVICE",
+                // methodCode 是**应用编码（appCode）**，不是方法 code——serviceCode+
+                // serviceMethodCode 定位方法，methodCode 定位应用。缺它：8.6 create 容忍、
+                // 8.1 update 回无明细 50000 且 enable 只翻 status 不翻 enabled
+                // （2026-11-03 issue A7/A8 实证；写前 gate 会直接拒绝缺失形态）。
+                methodMapping: {
+                    schemaCode: model,
+                    serviceCode: "<已注册服务 code>",
+                    serviceMethodCode: "<方法 code>",
+                    methodCode: "<应用编码 appCode>",
+                    inputMappings: [
+                        { serviceMethodParameterCode: "<参数 code，与方法声明逐字一致>", codeType: 0, bizCode: "<常量值>", required: false },
+                    ],
+                },
+                latestVersion: true,
+                consolidation: false,
+            },
+        },
+        publish: true,
+    },
+    preconditions: [
+        "目标业务集成服务与方法**已注册且已发布**（service.list / service.get 核对）",
+        "`methodCode`（应用编码）已知——不确定时先 `rule.get --keys schedulerSetting` 一条同族生产定时规则对照 methodMapping 形状",
+        "本环境需 `cloudpivot.task.enabled=true`（否则平台不建调度任务）",
+    ],
+    conditionalRequirements: [
+        "**不要**套用 `rule-timing-task`（GET_LIST + UPDATE 动作节点）的形状——那是「定时改数据」，本配方是「定时调方法」；两者 schedulerSetting.dataSourceType 与节点图都不同。",
+        "`methodMapping.inputMappings[]` 的 `serviceMethodParameterCode` 必须与方法声明的参数 code 逐字一致（method.get 读参数面核对，readbackCaveat 出现时以 inputParametersFromList 为准）；无参方法传 `[]`。",
+        "`latestVersion` 必须 true（false 走旧 builder → publish/update 50000，与 rule-timing-task 同坑）。",
+        "保存≠生效：`rule.save` 后必须 `rule.enable`；enable 回成功但 DB `enabled` 仍为 0 = 实体残缺（methodCode 缺失/options 空串），回 rule.save 修实体，不是重试 enable。",
+    ],
+    priorToolReferences: [
+        { tool: "service.list", args: { environment }, purpose: "确认服务已注册" },
+        { tool: "method.get", args: { environment, serviceCode: "<svc>", methodCode: "<method>" }, purpose: "读参数面拿 serviceMethodParameterCode（readbackCaveat.parametersUnreadable 出现时以 inputParametersFromList 为准）" },
+        { tool: "rule.get", args: { environment, schemaCode: model, ruleCode: "<同族生产规则>", keys: ["schedulerSetting"] }, purpose: "不确定 methodMapping 形状时对照生产实证形状" },
+    ],
+    dryRun: { supported: true, command: `omc call rule.save --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 跑图校验 + BIZ_SERVICE 写前 gate（methodMapping 三键非空），不写不发布" },
+    expectedReadback: { readback: { published: true, enabled: false, next: "rule.enable；到点后以平台日志/方法侧效果核验，不认返回值" } },
+    refusalRecovery: [
+        { code: "rule-scheduler-bizservice-mapping", action: "dataSourceType:BIZ_SERVICE 必须带 methodMapping{serviceCode,serviceMethodCode,methodCode}；methodCode 是应用编码（appCode）。对照 rule.get 的生产规则形状补齐" },
+        { code: "rule-name-invalid", action: "规则名仅支持中文/字母/数字、≤50 字符（平台设计器约束）" },
+        { code: "rule-graph-scheduler-setting-shape", action: "schedulerSetting 必须是 nodeGraph.schedulerSetting 上的对象，不是 SCHEDULER 节点字段" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: true,
+});
 const dataDuplicateFlag = Object.freeze({
     id: "data-duplicate-flag",
     title: "字段唯一性防重打标（8.6.26 实证唯一可靠路径）：预置 Create 规则挂 BIZ_ACTION 自调二开 markDuplicates（规则图内 QUERY→UPDATE 打标会静默空转）",
@@ -328,6 +410,6 @@ const ruleBizactionInvokeService = Object.freeze({
     requiresEnvironmentDerivedIds: true,
 });
 export const BUSINESSRULE_METADATA = Object.freeze({
-    "rule.save": Object.freeze({ recipes: [ruleGraph, ruleBranchGraph, ruleTimingTask, dataDuplicateFlag, ruleCrossModelCreate, ruleBizactionInvokeService], relatedTools: ["field.list", "rule.get", "rule.enable", "service.get"] }),
+    "rule.save": Object.freeze({ recipes: [ruleGraph, ruleBranchGraph, ruleTimingTask, ruleTimingBizService, dataDuplicateFlag, ruleCrossModelCreate, ruleBizactionInvokeService], relatedTools: ["field.list", "rule.get", "rule.enable", "service.get"] }),
 });
 //# sourceMappingURL=businessrule.js.map

package/dist/rule-support.js

@@ -838,6 +838,34 @@ export async function executeRuleSaveWrite(session, args) {
     // SCHEDULER rules keep the schedule on the rule row (schedulerSetting), not
     // on the node: normalize object → JSON string exactly like node/route.
     const schedulerInput = preparedGraph.schedulerSetting ?? preparedGraph.scheduler;
+    // A7 写前 gate（2026-11-03 issue，8.1.108 实测）：dataSourceType:"BIZ_SERVICE" 的
+    // 调度必须携带 methodMapping{serviceCode,serviceMethodCode,methodCode}。缺
+    // methodCode（应用编码）时平台 create 容忍、update 回**无明细 50000**，且 enable
+    // 只翻 status 不翻 enabled（实体残缺装不起调度链）。在本地拒绝，不发到 wire。
+    const schedulerForGate = typeof schedulerInput === "string" ? parseJsonColumn(schedulerInput) : schedulerInput;
+    if (schedulerForGate !== null && typeof schedulerForGate === "object" && !Array.isArray(schedulerForGate)
+        && String(schedulerForGate.dataSourceType ?? "") === "BIZ_SERVICE") {
+        const mapping = schedulerForGate.methodMapping;
+        const missing = [];
+        if (mapping === null || typeof mapping !== "object" || Array.isArray(mapping)) {
+            missing.push("methodMapping{serviceCode,serviceMethodCode,methodCode}");
+        }
+        else {
+            for (const key of ["serviceCode", "serviceMethodCode", "methodCode"]) {
+                const value = mapping[key];
+                if (typeof value !== "string" || !value.trim())
+                    missing.push(`methodMapping.${key}`);
+            }
+        }
+        if (missing.length > 0) {
+            throw new ToolRefusalError({
+                status: "refused",
+                blocker: "rule-scheduler-bizservice-mapping",
+                message: `schedulerSetting.dataSourceType=BIZ_SERVICE 但 ${missing.join("、")} 缺失（methodCode 是应用编码 appCode，不是方法 code——serviceCode+serviceMethodCode 定位方法，methodCode 定位应用）。缺 methodCode 的实体平台 create 容忍、update 回无明细 50000，且 enable 只翻 status 不翻 enabled。可先 rule.get 一条同族生产规则对照 methodMapping 形状。`,
+                missing,
+            });
+        }
+    }
     const schedulerSetting = schedulerInput === undefined || schedulerInput === null
         ? undefined
         : typeof schedulerInput === "string"
@@ -885,8 +913,40 @@ export async function executeRuleSaveWrite(session, args) {
     // Only CUSTOM rule codes take the caller's name. `existing` already carries
     // the platform name, so the spread preserves it.
     const isPresetRule = PLATFORM_TRIGGER_RULE_CODES.has(args.ruleCode);
+    // A5 写前 gate（2026-11-03 issue）：平台设计器只接受 中文/字母/数字、≤50 字符的
+    // 规则名。违规名 create 能落库（平台不拦），但设计器打开即报「规则名称仅支持
+    // 输入中文、字母和数字」且无法编辑——产出一个 UI 不可维护的 landmine。
+    // 只约束自定义规则（预置触发行的 name 属平台，见上方 isPresetRule 分支）。
+    if (!isPresetRule && typeof args.name === "string" && !/^[\u4e00-\u9fa5A-Za-z0-9]{1,50}$/.test(args.name)) {
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "rule-name-invalid",
+            message: `规则 name「${args.name.slice(0, 60)}」不符合平台约束：仅支持中文/字母/数字，长度 1-50（设计器校验；违规名虽能落库，但设计器无法再编辑该规则）。建议改为纯中文或字母数字命名。`,
+        });
+    }
+    // A8（2026-11-03 issue，8.1.108 实测）：`options` / `extensionSetting` 缺席或空串
+    // 时平台落 ""，8.1 族实体校验要求结构化的默认值——update 回无明细 50000。写前
+    // 归一：空串/缺席补平台默认结构（与设计器保存行为一致）。
+    const normalizeRuleJsonColumn = (value, fallback) => {
+        if (typeof value === "string" && value.trim())
+            return value;
+        if (value !== null && typeof value === "object")
+            return JSON.stringify(value);
+        return fallback;
+    };
     const performed = existing?.id
-        ? await wireCall(session, { path: ENDPOINTS.businessRuleUpdate, method: "POST", body: { ...existing, ...(isPresetRule ? {} : { name: args.name }), node: nodeJson, route: routeJson, bizRuleType, ...schedulerField, enabled: existing.enabled === true, status: existing.status ?? "DISABLED" } })
+        ? await wireCall(session, { path: ENDPOINTS.businessRuleUpdate, method: "POST", body: {
+                ...existing,
+                ...(isPresetRule ? {} : { name: args.name }),
+                options: normalizeRuleJsonColumn(existing.options, '{"ruleVariable":[]}'),
+                extensionSetting: normalizeRuleJsonColumn(existing.extensionSetting, "{}"),
+                node: nodeJson,
+                route: routeJson,
+                bizRuleType,
+                ...schedulerField,
+                enabled: existing.enabled === true,
+                status: existing.status ?? "DISABLED",
+            } })
         : await wireCall(session, { path: ENDPOINTS.businessRuleCreate, method: "POST", body: { code: args.ruleCode, name: args.name, schemaCode: args.schemaCode, bizRuleType, node: nodeJson, route: routeJson, schedulerSetting: schedulerSetting ?? null, ...RULE_CREATE_BODY } });
     // Ticket 62: a bare save only writes the DRAFT working row — the designer
     // and the runtime read the PUBLISHED version, so "saved" ≠ "visible". An

package/dist/wire.js

@@ -232,6 +232,32 @@ export async function wireCall(session, call) {
     return result;
 }
 /** List rows from the standard list envelope (array or {data:[]}). */
+/**
+ * 版本族端点备选链（2026-11-03 issue A1，8.1.108 实测）：部分端点只存在于
+ * 某个版本族——8.6 的 `runtime/business_rule/list_by_schemacode` 在 8.1 族不存在
+ * （404），8.1 用 `app/businessrule/list_by_schemacode`。按序尝试 candidates，
+ * **仅 HTTP 404（端点缺席）下探下一个**：401/500/transport/业务码拒绝原样抛出，
+ * 不吞真错误。全部 404 时重抛最后一个。
+ */
+export async function wireCallWith404Fallback(session, candidates, onFallback) {
+    let lastError;
+    for (let index = 0; index < candidates.length; index++) {
+        const call = candidates[index];
+        try {
+            return await wireCall(session, call);
+        }
+        catch (error) {
+            const endpointAbsent = error instanceof WireError && error.kind === "http-status" && error.diagnostic?.httpStatus === 404;
+            if (!endpointAbsent)
+                throw error;
+            lastError = error;
+            const next = candidates[index + 1];
+            if (next && onFallback)
+                onFallback(call, next);
+        }
+    }
+    throw lastError;
+}
 export function wireRows(value) {
     const rows = Array.isArray(value)
         ? value

package/package.json

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