@stalfh233/omc-cli 0.6.2 → 0.6.4

package/dist/governed-execution.js

@@ -14,7 +14,11 @@ export async function admitGovernedWrite(ctx, request) {
         return settled(refusalFromCoverage(error));
     }
     const resolved = ctx.sessions.config().resolveEnvironment(request.environment);
-    if (!environmentWritable(resolved.profile))
+    const writable = environmentWritable(resolved.profile);
+    // P2-5：只读环境默认拒绝；仅当调用方**显式**请求、且会话内证明这次用法只读，
+    // 才开一条窄缝。未请求/证明失败都回原来的 environment-write-disabled。
+    const escapeRequested = !writable && request.readOnlyEscape !== undefined && request.readOnlyEscape.requested(request.args ?? {});
+    if (!writable && !escapeRequested)
         return settled({
             status: "refused",
             blocker: "environment-write-disabled",
@@ -42,6 +46,26 @@ export async function admitGovernedWrite(ctx, request) {
             blocker: "version-family-evidence-missing",
             message: "writes fail closed when the CloudPivot version family cannot be established",
         });
+    // P2-5：只读放行的证明**放在版本门之后**——任何额外读回都要先过 fail-closed 的
+    // 版本证据门，保持「没有版本证据就不加新 wire 行为」的既有顺序。
+    let readOnlyEscape;
+    if (escapeRequested && request.readOnlyEscape !== undefined) {
+        let verdict;
+        try {
+            verdict = await request.readOnlyEscape.verify(session, request.args ?? {});
+        }
+        catch (error) {
+            return settled({
+                status: "refused",
+                blocker: "read-only-escape-unverified",
+                environment: resolved.name,
+                message: `只读放行的证明读回失败（${error instanceof Error ? error.message : String(error)}）；未执行任何试跑/查询。`,
+            });
+        }
+        if (!verdict.ok)
+            return settled({ ...verdict.refusal, environment: resolved.name });
+        readOnlyEscape = verdict.note;
+    }
     // Version family is advisory now: OMC is built on 8.6, but a deployment on a
     // different version (or product line, e.g. AI-Platform) is accepted in
     // compatibility mode. Missing evidence still fails closed above.
@@ -81,6 +105,7 @@ export async function admitGovernedWrite(ctx, request) {
             profile: resolved.profile,
             plan,
             ...(productionConfirmed ? { productionConfirmed: true } : {}),
+            ...(readOnlyEscape !== undefined ? { readOnlyEscape } : {}),
         },
     };
 }

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

@@ -181,7 +181,7 @@ export const B2_LANE_CONTRACT = Object.freeze({
         }),
         "service.table_sql": Object.freeze({
             scope: "readback",
-            description: "表 SQL 模板发现：`/bizservice/method/get_table_column?serviceCode=&tableName=`。端点名虽为 column，实际返回**生成的 SQL 模板**（DataTableSqlModel{sql,sqlType ∈ SELECT/INSERT/UPDATE/DELETE/UPSERT}，BizServiceFacadeImpl.getDataTableSql:889-910），不是列元数据；同样仅 DATA_TABLE 服务（501010）。纯只读。",
+            description: "表 SQL 模板发现：`/bizservice/method/get_table_column?serviceCode=&tableName=`。端点名虽为 column，实际返回**生成的 SQL 模板**（DataTableSqlModel{sql,sqlType ∈ SELECT/INSERT/UPDATE/DELETE/UPSERT}，BizServiceFacadeImpl.getDataTableSql:889-910），不是列元数据；同样仅 DATA_TABLE 服务（501010）。纯只读。**只回模板、不执行**——平台没有自由 SQL 查询通道（要跑已注册的只读方法用 method.test，要查业务数据用 data.list 分片），别把本工具当查询入口（GitLab #18 P2-6）。",
         }),
         "service.delete": Object.freeze({
             scope: B2_SCOPE,

package/dist/lanes/b2-registration.js

@@ -19,6 +19,82 @@ const B2_TOOLS = B2_LANE_CONTRACT.tools;
 function decodeJsonColumn(value) {
     return decodeSharedJsonColumn(value, JSON_COLUMN_NULL_COALESCE);
 }
+/**
+ * 只读 SQL 判定用的结构视图：剥掉字符串字面量与注释，只留可执行的 SQL 骨架。
+ *
+ * 为什么需要：`SELECT note FROM ledger WHERE note = 'for update'` 是正常查询，
+ * 但直接对全文跑「FOR UPDATE」正则会误杀；反过来，若不剥字面量就放宽规则，
+ * `SELECT 1 INTO OUTFILE ...` 这类真副作用又会漏过。
+ *
+ * 保守约定：引号/注释**不配对**时返回 null（调用方据此拒绝）——不猜残缺 SQL 的
+ * 语义。支持 SQL 的两种转义（`''` 与 `\'`）。
+ */
+function stripSqlLiteralsAndComments(sql) {
+    let out = "";
+    let index = 0;
+    while (index < sql.length) {
+        const char = sql[index];
+        const next = sql[index + 1];
+        if (char === "'" || char === '"' || char === "`") {
+            const quote = char;
+            index += 1;
+            let closed = false;
+            while (index < sql.length) {
+                const current = sql[index];
+                if (current === "\\") {
+                    index += 2;
+                    continue;
+                }
+                if (current === quote) {
+                    if (quote !== "`" && sql[index + 1] === quote) {
+                        index += 2;
+                        continue;
+                    } // '' 转义
+                    index += 1;
+                    closed = true;
+                    break;
+                }
+                index += 1;
+            }
+            if (!closed)
+                return null;
+            out += " '' ";
+            continue;
+        }
+        if (char === "-" && next === "-" && (index + 2 >= sql.length || /\s/.test(sql[index + 2]))) {
+            // SQL/MySQL 的 `--` 注释要求后面跟空白；不跟空白时是算术（`1--2`），
+            // 若当注释剥掉会把其后的 `INTO OUTFILE` 一起吞成注释 → 绕过。
+            const end = sql.indexOf("\n", index);
+            if (end < 0)
+                return out;
+            index = end;
+            continue;
+        }
+        if (char === "#") {
+            // MySQL 的 `#` 注释（无需空白）。
+            const end = sql.indexOf("\n", index);
+            if (end < 0)
+                return out;
+            index = end;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            // MySQL 可执行注释 `/*!50000 ... */` 里的语句**会执行**——不能当注释剥掉，
+            // 直接判定为无法静态证明只读。
+            if (sql[index + 2] === "!")
+                return null;
+            const end = sql.indexOf("*/", index + 2);
+            if (end < 0)
+                return null; // 未闭合注释：拒绝
+            index = end + 2;
+            out += " ";
+            continue;
+        }
+        out += char;
+        index += 1;
+    }
+    return out;
+}
 function adapterCodeOf(serviceRow) {
     return typeof serviceRow?.adapterCode === "string" ? serviceRow.adapterCode : "";
 }
@@ -365,11 +441,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 };
         }),
@@ -1268,10 +1370,109 @@ export function registerB2Lane(tools) {
     const TEST_EVIDENCED_ADAPTERS = new Set(["RESTFUL", "DATA_SQL", "DATA_TABLE", "SOAP", "INTERNAL"]);
     /** Adapters whose method configJson must be non-null to be executable (SOAP methods are WSDL-discovered and carry none). */
     const TEST_CONFIG_REQUIRED_ADAPTERS = new Set(["RESTFUL", "DATA_SQL", "DATA_TABLE", "SAP", "KAFKA", "INTERNAL"]);
+    /** 只读环境放行判定：只认「显式传参 + DATA_SQL + 严格 SELECT-only」。 */
+    const methodTestReadOnlyEscape = {
+        requested: (args) => args.readOnlyOnReadOnlyEnv === true,
+        verify: async (session, args) => {
+            const serviceCode = String(args.serviceCode ?? "");
+            const methodCode = String(args.methodCode ?? "");
+            const refusal = (blocker, message, extra = {}) => ({
+                ok: false,
+                refusal: { status: "refused", blocker, serviceCode, methodCode, message, ...extra },
+            });
+            let serviceRow;
+            try {
+                serviceRow = (await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode } })).data;
+            }
+            catch (error) {
+                return refusal("read-only-escape-unverified", `只读放行需要先证明方法确实是只读 SELECT，但服务配置读回失败（${error instanceof Error ? error.message : String(error)}）——零试跑调用。`);
+            }
+            if (serviceRow === null)
+                return refusal("wire-business", `业务服务不存在：${serviceCode}`);
+            const adapterCode = adapterCodeOf(serviceRow);
+            if (adapterCode !== "DATA_SQL")
+                return refusal("read-only-escape-adapter-refused", `readOnlyOnReadOnlyEnv 只对 DATA_SQL 适配器生效（本次 ${adapterCode || "(空)"}）：RESTFUL/SOAP/INTERNAL 等会真实打外部系统（可能 INSERT/UPDATE），无法静态证明只读，只读环境一律拒绝。`, { adapterCode });
+            let rows;
+            try {
+                rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode, filterFlag: "false" } })).data);
+            }
+            catch (error) {
+                return refusal("read-only-escape-unverified", `方法面读回失败（${error instanceof Error ? error.message : String(error)}）——零试跑调用。`);
+            }
+            const method = rows.find((row) => row.code === methodCode);
+            if (!method)
+                return refusal("wire-business", `业务方法不存在：${serviceCode}/${methodCode}`);
+            // 平台把方法 configJson 以**明文 JSON**落库（controller 解密后存明文；
+            // 回读面同样是明文）。个别部署/中间层可能回密文，所以两种都认：先当明文
+            // JSON 解析，失败再按 AES 解密——两条都失败就拒绝（不能证明只读）。
+            const rawConfig = typeof method.configJson === "string" ? method.configJson : "";
+            if (!rawConfig)
+                return refusal("bizservice-test-shell", `方法 ${methodCode} 是注册壳（无 configJson）——不可执行，只读放行不适用。`);
+            let parsedConfig;
+            try {
+                parsedConfig = JSON.parse(rawConfig);
+            }
+            catch {
+                try {
+                    parsedConfig = JSON.parse((await omcCore()).decryptBizServiceMethodConfigJson(rawConfig));
+                }
+                catch (error) {
+                    return refusal("read-only-escape-unverified", `configJson 既不是明文 JSON 也无法解密（${error instanceof Error ? error.message : String(error)}）——不能证明只读，零试跑调用。`);
+                }
+            }
+            const sql = typeof parsedConfig.sql === "string" ? parsedConfig.sql : "";
+            const trimmed = sql.trim().replace(/^\(+/, "").trim();
+            // 严格 SELECT-only：`;` 多语句、WITH 后接 DML 一律不放行（宁可误杀）。
+            // 审查补强（2026-11-04）：`/^select/` 远不等于只读——下面这些都是真实
+            // 副作用写，却被首词 select 掩护：
+            //   SELECT … INTO OUTFILE/DUMPFILE '/tmp/x'   → 落盘写文件
+            //   SELECT … INTO @v                          → 会话变量（配合后续可用）
+            //   SELECT … FOR UPDATE / FOR SHARE / LOCK IN SHARE MODE → 行锁
+            //   SELECT 1\nDELETE FROM t                   → 换行分隔的第二条语句（无分号）
+            // 只读环境上放行这些等于给写副作用开口子，所以一律拒绝。
+            // 先剥掉字符串字面量与注释再判（否则 `WHERE note = 'for update'` 被误杀）；
+            // 引号/注释不配对就直接拒绝——那段 SQL 本身就有问题，不猜。
+            const structural = stripSqlLiteralsAndComments(sql);
+            if (structural === null)
+                return refusal("read-only-escape-not-select", `readOnlyOnReadOnlyEnv 需要能静态判定的 SQL：方法 ${methodCode} 的 SQL 字符串/注释引号不配对，无法证明只读（零试跑调用）。`, { sqlPreview: sql.slice(0, 120) });
+            const dangerousClauses = [
+                { pattern: /\binto\s+(outfile|dumpfile)\b/i, label: "INTO OUTFILE/DUMPFILE（写文件）" },
+                { pattern: /\binto\s+@\w+/i, label: "INTO @变量（会话变量）" },
+                { pattern: /\bfor\s+(update|share)\b/i, label: "FOR UPDATE/SHARE（行锁）" },
+                { pattern: /\block\s+in\s+share\s+mode\b/i, label: "LOCK IN SHARE MODE（行锁）" },
+                // 不再只盯「换行后的第二条语句」：剥离注释后 `SELECT 1 /*x*/ DELETE …`
+                // 会变成同一行，只查换行前缀就漏。改成全文任何位置出现写关键字即拒绝
+                // （fail-closed；正常 SELECT 不会出现这些词，列名如 update_log 有下划线
+                // 不算词边界，不会被误杀）。
+                { pattern: /\b(insert|update|delete|drop|alter|truncate|create|replace|call|exec|execute|merge|grant|revoke)\b/i, label: "写/DDL 关键字（非纯 SELECT）" },
+            ];
+            const dangerous = dangerousClauses.find((entry) => entry.pattern.test(structural));
+            const looksSelectOnly = /^select\b/i.test(trimmed) && !/[;]/.test(structural) && !/^with\b/i.test(trimmed) && dangerous === undefined;
+            if (!looksSelectOnly)
+                return refusal("read-only-escape-not-select", dangerous !== undefined
+                    ? `readOnlyOnReadOnlyEnv 只放行**纯读取**的 SELECT（方法 ${methodCode} 的 SQL 含 ${dangerous.label}）——这在只读环境上仍然有副作用，请在可写环境执行。`
+                    : `readOnlyOnReadOnlyEnv 只放行单条 SELECT（方法 ${methodCode} 的 SQL 不是严格 SELECT-only：禁止 ';' 多语句、WITH…DML、非 SELECT 语句）。要跑写库/DDL 方法请在可写环境执行。`, { sqlPreview: sql.slice(0, 120), ...(dangerous !== undefined ? { rejectedClause: dangerous.label } : {}) });
+            return {
+                ok: true,
+                note: {
+                    reason: "read-only-select-on-read-only-environment",
+                    adapterCode,
+                    methodCode,
+                    sqlPreview: sql.slice(0, 120),
+                    note: "只读环境 + 显式 readOnlyOnReadOnlyEnv + DATA_SQL 严格 SELECT-only：本次试跑已放行；它仍会真调数据库（SELECT）并记集成日志，不写配置行。",
+                },
+            };
+        },
+    };
     writeTool(tools, "method.test", B2_LANE, B2_TOOLS["method.test"].scope, B2_TOOLS["method.test"].description, {
         serviceCode: z.string().min(1),
         methodCode: z.string().min(1),
         testInputParametersMap: z.record(z.string(), z.unknown()).describe("试跑入参：参数 code → JSON 值（BizServiceMethodVO Map<String,Object>；按方法声明参数面校验）"),
+        // P2-5（GitLab #18）：method.test 是治理写（会真调外部系统），只读环境下默认
+        // 拒绝——但一条纯 SELECT 的 DATA_SQL 方法没有任何副作用，此前却必须先把
+        // 生产环境改成 writable 才能读数据（安全语义倒置）。显式传本参数 + 工具
+        // 用真实配置证明「DATA_SQL 且严格 SELECT-only」才放行，其余一律原写门。
+        readOnlyOnReadOnlyEnv: z.boolean().optional().describe("只读环境（writable=false）里显式放行本次试跑：仅当服务是 DATA_SQL 且方法 SQL 是单条 SELECT 时生效；不传=按写门拒绝（默认）。仍会真执行 SELECT 并记集成日志，不写配置行"),
     }, async (session, args) => {
         // Ticket 107 — a REAL one-shot execution of the configured method
         // (BizServiceMethodController.java:398-412 → BizServiceFacadeImpl:426-464
@@ -1372,6 +1573,6 @@ export function registerB2Lane(tools) {
                 ...(externalSuccess ? {} : { externalFailure }),
             },
         };
-    });
+    }, undefined, undefined, undefined, methodTestReadOnlyEscape);
 }
 //# sourceMappingURL=b2-registration.js.map

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/form.js

@@ -144,21 +144,41 @@ export function registerFormLane(tools) {
                 ...(wanted ? { draftControls: pick(sheet.draftAttributesJson), publishedControls: pick(sheet.publishedAttributesJson) } : {}),
             };
         }, {
+            // T1（GitLab #17，2026-11-04）：`full` 此前没传，于是 form.get --full 永远
+            // 整包内联（实测 94.9KB 只为 grep 一个串）——与 data/workflow 的 8KB 读门
+            // 不一致，且外置态的根键随来源漂移。传入后大包走 fullOmitted + artifact，
+            // 小包行为不变（≤8KB 仍原样内联）。
+            full: args.full === true,
             // 2026-11-01 读门 2048：controls=true 是**显式**取控件定义的请求——compact
             // 保留定义映射与按钮/options（--full 的语义面），其余大数组归码表/计数。
+            // T1：六份布局 JSON 是大**字符串**（不是数组/对象），旧 compact 的 else 分支
+            // 原样保留 → 外置了也没省体积。超过 4KB 的单串改为 `*Omitted` + 字节数，
+            // 正文用 `artifact get <detailArtifactId> --jq draftViewJson` 定向取回。
             compact: (result) => {
                 const KEEP = new Set(["draftControls", "publishedControls", "customButtonJson", "options", "formButtons", "formButtonCodes"]);
                 const out = {};
+                const omitted = [];
                 for (const [key, value] of Object.entries(result)) {
                     if (KEEP.has(key))
                         out[key] = value;
+                    else if (typeof value === "string" && Buffer.byteLength(value, "utf8") > 4096) {
+                        out[`${key}Omitted`] = true;
+                        out[`${key}Bytes`] = Buffer.byteLength(value, "utf8");
+                        omitted.push(key);
+                    }
                     else if (Array.isArray(value))
                         out[`${key}Codes`] = value.map((entry) => (entry && typeof entry === "object" ? String(entry.code ?? entry.propertyCode ?? "") : String(entry))).filter((entry) => entry.length > 0), out[`${key}Count`] = value.length;
+                    // 大**对象**也要降载：审查 2026-11-04 指出旧 else 分支把
+                    // htmlRenderCompat 这类非 KEEP 对象整包内联，抵消了 T1 的省体积目标。
                     else if (value !== null && typeof value === "object")
                         out[`${key}Count`] = Object.keys(value).length;
                     else
                         out[key] = value;
                 }
+                // 有任一布局被外置时给一行可执行取回路径，避免把 Omitted 面误读成
+                // 「这个表单没有布局」。
+                if (omitted.length > 0)
+                    out.layoutHint = `这些布局正文已外置（${omitted.join("、")}）：用 \`omc artifact get <detailArtifactId> --jq <key>\` 取原文，例如 --jq draftViewJson。**不要**把 Omitted 面当空布局回写 form.draft（fromReadback 需要 artifact 里的原文）。`;
                 return out;
             },
         }),

package/dist/lanes/model.js

@@ -9,7 +9,7 @@ import { writeSummary } from "../human-summary.js";
 import { capabilityArg, environmentArg } from "../args.js";
 import { governedRead, withoutReadbackCache } from "../read.js";
 import { parseToolInput } from "../tool-types.js";
-import { applicationResolutionOf, applicationScopeHint, flattenTreeRows, resolveApplicationCode, resolveApplicationScope } from "../support.js";
+import { applicationResolutionOf, applicationScopeHint, applicationScopeNotice, flattenTreeRows, resolveApplicationCode, resolveApplicationScope } from "../support.js";
 import { writeTool } from "../write.js";
 import { registerPackageTool } from "../package-tool.js";
 import { defineTool, ToolInputError, ToolRefusalError } from "../tool-types.js";
@@ -221,6 +221,7 @@ export function registerModelLane(tools) {
                 totalBeforeFilter: all.length,
                 filterApplied: needle !== undefined && needle !== "",
                 ...(needle ? { filter: needle } : {}),
+                scopeHint: applicationScopeNotice(scope),
                 models,
                 ...(models.length === 0 ? { hint: applicationScopeHint(scope, "模型") } : {}),
             };
@@ -275,14 +276,28 @@ export function registerModelLane(tools) {
                 // parallel (bounded) instead of paying six sequential round-trips. Only
                 // workflow.get_published stays chained (it needs workflowCode from the
                 // draft face). Output ordering is unchanged (results land by index).
-                const [fieldFace, formFace, listviewFace, ruleFace, dataruleFace, draftFace] = await mapBounded([
+                // T4（GitLab #17，2026-11-04）：业务方永远按中文菜单名提问，而本面此前不
+                // 回显示名——只能靠 listview.list 反推（未配视图的模型无路可查）。应用树
+                // 节点本来就带 name，与六面同一批并发读，零额外顺序往返。
+                const treeFace = async () => {
+                    try {
+                        return { node: (await resolveModelTreeNode(session, schemaCode)).node };
+                    }
+                    catch {
+                        return undefined;
+                    }
+                };
+                const [fieldFace, formFace, listviewFace, ruleFace, dataruleFace, draftFace, treeRead] = await mapBounded([
                     () => face("field.list", { schemaCode, published: true, ...(all ? { all: true } : {}) }, faceErrcodes),
                     () => face("form.get", { schemaCode }),
                     () => face("listview.get", { schemaCode }),
                     () => face("rule.list", { schemaCode }),
                     () => face("datarule.list", { schemaCode }),
                     () => face("workflow.get_draft", { schemaCode }),
-                ], 6, (task) => task());
+                    () => treeFace(),
+                ], 7, (task) => task());
+                const treeNode = treeRead?.node;
+                const modelName = typeof treeNode?.name === "string" && treeNode.name ? treeNode.name : typeof treeNode?.text === "string" && treeNode.text ? treeNode.text : undefined;
                 const fieldRows = Array.isArray(fieldFace?.fields) ? fieldFace.fields : [];
                 const fields = fieldRows
                     .filter((field) => all || !SYSTEM_FIELD_CODES.has(String(field.code)))
@@ -353,6 +368,7 @@ export function registerModelLane(tools) {
                 const modelPresent = absent ? false : fieldFace !== undefined && !fieldRefused ? true : undefined;
                 return {
                     schemaCode,
+                    ...(modelName !== undefined ? { name: modelName } : {}),
                     ...(modelPresent !== undefined ? { modelPresent } : {}),
                     ...(modelPresent === false
                         ? {
@@ -367,7 +383,7 @@ export function registerModelLane(tools) {
                     rulesCustom: rules.filter((rule) => rule.defaultRule !== true).map((rule) => rule.code),
                     datarules,
                     workflow,
-                    hint: "model.inspect 聚合设计时六面（fields/form/listview/rules/datarules/workflow，摘要）。modelPresent 是存在性判据（field 面 300004=false）；字段 options 细节用 field.list --code；规则图用 rule.get schemaCode+ruleCode；运行数据用 data.list（不在此面）。",
+                    hint: "model.inspect 聚合设计时六面（fields/form/listview/rules/datarules/workflow，摘要）；name 是模型显示名（业务方的中文菜单名），与 schemaCode 一一对应，不必再用 listview.list 反推。modelPresent 是存在性判据（field 面 300004=false）；字段 options 细节用 field.list --code；规则图用 rule.get schemaCode+ruleCode；运行数据用 data.list（不在此面）。",
                 };
             };
             const one = await inspectOne(codes[0]);

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 } };