@stalfh233/omc-cli 0.0.0-stage → 0.4.0

package/dist/lanes/b2-registration.js

@@ -0,0 +1,1187 @@
+import { z } from "zod";
+import { basename } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { ENDPOINTS } from "../endpoints.js";
+import { capabilityArg, environmentArg } from "../args.js";
+import { governedRead } from "../read.js";
+import { writeTool } from "../write.js";
+import { decodeJsonColumn as decodeSharedJsonColumn, JSON_COLUMN_NULL_COALESCE } from "../json-column.js";
+import { defineTool, ToolRefusalError } from "../tool-types.js";
+import { wireCall, wireRows, wireDownloadBuffer, wireUploadFile, WireError } from "../wire.js";
+import { ZipFormatError, readZipEntries, zipEntryByBasename } from "../zip.js";
+import { B2_LANE_CONTRACT } from "./b2-registration-contract.js";
+import { BIZSERVICE_WRITE_ADAPTERS, assertBizServiceAdapterWhitelisted, assertStructuredConfig, compileMethodConfigPlain, compileParameterFace, compileServiceConfig, maskServiceConfigSecrets, normalizeMethodConfigReadback, normalizeParameterFaceReadback, parseIeManifest, iePackageSummary, } from "../bizservice-config.js";
+import { encryptBizServiceMethodConfigJson, encryptBizDbPoolPassword } from "omc-core";
+const B2_LANE = B2_LANE_CONTRACT.lane;
+const B2_TOOLS = B2_LANE_CONTRACT.tools;
+/** Decode a JSON-string column (configJson/inputParametersJson/…); policy: non-strings null-coalesce, unparseable passes through. */
+function decodeJsonColumn(value) {
+    return decodeSharedJsonColumn(value, JSON_COLUMN_NULL_COALESCE);
+}
+function adapterCodeOf(serviceRow) {
+    return typeof serviceRow?.adapterCode === "string" ? serviceRow.adapterCode : "";
+}
+/**
+ * Ticket 103 — fail-closed dangling-category preflight. The platform writes
+ * serviceCategoryId verbatim with NO existence validation
+ * (BizServiceServiceImpl.update:251; create likewise), so an orphan id would
+ * silently strand the service outside every real directory. The tool refuses
+ * before any write unless the id resolves to a non-virtual category row
+ * (the「全部」row carries an empty id and can never be one).
+ */
+const ALL_ZERO_ID_RE = /^0{16,}$/;
+async function assertCategoryResolves(session, serviceCategoryId) {
+    const rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceCategoryList })).data);
+    const resolved = rows.find((row) => row.id === serviceCategoryId && typeof row.id === "string" && row.id !== "");
+    if (!resolved)
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "bizservice-category-dangling",
+            message: `serviceCategoryId ${serviceCategoryId} 不存在于 /bizservice/category/list（虚拟「全部」id 为空，同样不可用）——先用 service.category.list 解析（取 usable[].id 真实值）或 service.category.create 新建；平台写面不校验该 id，悬空即拒绝，零写入`,
+            hint: ALL_ZERO_ID_RE.test(serviceCategoryId) ? "该 id 是全 0 掩码/占位值（r5-crm 实证：agent 一直用全 0 占位当真实 categoryId，四连拒后误判为环境限制）。真实 id 只能取 service.category.list 返回的 usable[].id——回显/兜底拼接出的全 0 串不是任何分类的 id。" : undefined,
+            serviceCategoryId,
+        });
+}
+/** A JSON-string parameter face parses to an array when valid; otherwise undefined so the compile layer reports it. */
+function safeParseArray(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Ticket 107 — the DECLARED input parameter face of a method row, as
+ * (all codes, required codes). An unparsable/absent face decodes to no
+ * constraints (the platform itself quotes `args` by parameter code only).
+ */
+function parseDeclaredParameterCodes(inputParametersJson) {
+    const parsed = typeof inputParametersJson === "string" ? safeParseArray(inputParametersJson) : Array.isArray(inputParametersJson) ? inputParametersJson : undefined;
+    if (!parsed)
+        return { all: [], required: [] };
+    const all = [];
+    const required = [];
+    for (const entry of parsed) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const code = entry.code;
+        if (typeof code !== "string" || !code.trim())
+            continue;
+        all.push(code);
+        if (entry.required === true)
+            required.push(code);
+    }
+    return { all, required };
+}
+/**
+ * Ticket 104 — readback face for a connection-pool row: an explicit field
+ * whitelist WITHOUT `password`. The platform's raw list does not mask the
+ * credential column, so the strip lives in the tool boundary.
+ */
+function poolReadbackFace(pool) {
+    return {
+        id: pool.id,
+        code: pool.code,
+        name: pool.name,
+        ...(pool.description !== undefined && pool.description !== null ? { description: pool.description } : {}),
+        databaseType: pool.databaseType,
+        datasourceType: pool.datasourceType,
+        jdbcUrl: pool.jdbcUrl,
+        ...(pool.username !== undefined && pool.username !== null ? { username: pool.username } : {}),
+        ...(pool.externInfo !== undefined && pool.externInfo !== null ? { externInfo: pool.externInfo } : {}),
+    };
+}
+/**
+ * Ticket 104 — fail-closed DATA_SQL/DATA_TABLE binding preflight. The
+ * platform stores commonlist.databaseConnectionPoolCode with no existence
+ * validation; a dangling code strands the service against a pool that cannot
+ * resolve. Refused before any write (read-only list resolution precedes).
+ */
+async function assertDbConnPoolResolves(session, poolCode) {
+    const rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizDbConnPoolList })).data);
+    const resolved = rows.find((row) => row.code === poolCode);
+    if (!resolved)
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "bizservice-dbconnpool-dangling",
+            message: `databaseConnectionPoolCode ${poolCode} 不存在于 /bizservice/dbconnpool/list——先用 service.dbconnpool.list 解析或 service.dbconnpool.create 新建；平台写面不校验该 code，悬空即拒绝，零写入`,
+            databaseConnectionPoolCode: poolCode,
+        });
+}
+/** Ticket 104 — extract a DATA_SQL/DATA_TABLE service config's pool code (undefined when absent). */
+function dbConnPoolCodeOf(serviceConfig) {
+    const commonlist = serviceConfig.commonlist;
+    if (!Array.isArray(commonlist))
+        return undefined;
+    for (const entry of commonlist) {
+        if (entry && typeof entry === "object" && entry.code === "databaseConnectionPoolCode") {
+            const value = entry.value;
+            if (typeof value === "string" && value)
+                return value;
+        }
+    }
+    return undefined;
+}
+/** get_by_code answers 500001 业务服务不存在 when the service is gone (BizServiceController). */
+function isServiceAbsent(error) {
+    return error instanceof WireError && error.kind === "business" && error.errcode === 500001;
+}
+export function registerB2Lane(tools) {
+    tools.push(defineTool({
+        name: "service.get",
+        layer: "low",
+        kind: "read",
+        lane: B2_LANE,
+        scope: B2_TOOLS["service.get"].scope,
+        description: B2_TOOLS["service.get"].description,
+        inputSchema: { environment: environmentArg, serviceCode: z.string(), capability: capabilityArg },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            let service;
+            try {
+                service = await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: args.serviceCode } });
+            }
+            catch (error) {
+                // A deleted service answers the wire-business error 500001; reading a
+                // just-cleaned-up service back to VERIFY the cleanup is a normal
+                // success, not a `refused` envelope (dogfood R3). Absence is a fact.
+                if (isServiceAbsent(error))
+                    return { serviceCode: args.serviceCode, present: false, absent: true, service: null, adapterCode: null, methods: [], methodsError: null };
+                throw error;
+            }
+            const serviceRow = service.data;
+            let methods = null;
+            let methodsError = null;
+            try {
+                methods = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data).map((row) => ({
+                    code: row.code,
+                    name: row.name,
+                    serviceCode: row.serviceCode ?? args.serviceCode,
+                    configJson: maskServiceConfigSecrets(normalizeMethodConfigReadback(adapterCodeOf(serviceRow), decodeJsonColumn(row.configJson))),
+                    inputParameters: normalizeParameterFaceReadback(adapterCodeOf(serviceRow), decodeJsonColumn(row.inputParametersJson)),
+                    outputParameters: normalizeParameterFaceReadback(adapterCodeOf(serviceRow), decodeJsonColumn(row.outputParametersJson)),
+                    referenced: row.referenced === true,
+                }));
+            }
+            catch (error) {
+                methodsError = error instanceof Error ? error.message : String(error);
+            }
+            return {
+                serviceCode: args.serviceCode,
+                present: serviceRow !== null,
+                // Ticket 115: the READ face masks auth parameterlist VALUES (handoff
+                // §5 — credentials never echo); structure stays readable.
+                service: serviceRow === null ? null : { ...serviceRow, ...(serviceRow.configJson !== undefined ? { configJson: maskServiceConfigSecrets(decodeJsonColumn(serviceRow.configJson)) } : {}) },
+                adapterCode: serviceRow?.adapterCode ?? null,
+                methods,
+                methodsError,
+            };
+        }),
+    }));
+    tools.push(defineTool({
+        name: "method.get",
+        layer: "low",
+        kind: "read",
+        lane: B2_LANE,
+        scope: B2_TOOLS["method.get"].scope,
+        description: B2_TOOLS["method.get"].description,
+        inputSchema: { environment: environmentArg, serviceCode: z.string().min(1), methodCode: z.string().min(1), capability: capabilityArg },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            let service = null;
+            try {
+                service = await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: args.serviceCode } });
+            }
+            catch (error) {
+                // Same absence semantics as service.get: a deleted service (and
+                // therefore its method) is `absent:true`, not a refused envelope.
+                if (isServiceAbsent(error))
+                    return { serviceCode: args.serviceCode, methodCode: args.methodCode, present: false, absent: true, method: null };
+                throw error;
+            }
+            const serviceRow = service.data;
+            const rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data);
+            const listed = rows.find((candidate) => candidate.code === args.methodCode);
+            if (!listed || typeof listed.id !== "string" || !listed.id)
+                return { serviceCode: args.serviceCode, methodCode: args.methodCode, present: false, absent: true, method: null };
+            const fetched = await wireCall(session, { path: ENDPOINTS.bizServiceMethodGet, query: { id: listed.id } });
+            const row = fetched.data;
+            if (!row)
+                return { serviceCode: args.serviceCode, methodCode: args.methodCode, present: false, absent: true, method: null };
+            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)),
+            };
+            return { serviceCode: args.serviceCode, methodCode: args.methodCode, present: true, method };
+        }),
+    }));
+    writeTool(tools, "method.update", B2_LANE, B2_TOOLS["method.update"].scope, B2_TOOLS["method.update"].description, {
+        serviceCode: z.string().min(1),
+        methodCode: z.string().min(1),
+        name: z.string().optional(),
+        methodConfig: z.record(z.string(), z.unknown()).optional(),
+        methodInputParameters: z.union([z.array(z.record(z.string(), z.unknown())), z.string()]).optional(),
+        methodOutputParameters: z.union([z.array(z.record(z.string(), z.unknown())), z.string()]).optional(),
+    }, async (session, args) => {
+        const service = await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: args.serviceCode } });
+        const serviceRow = service.data;
+        const adapterCode = assertBizServiceAdapterWhitelisted(adapterCodeOf(serviceRow));
+        const rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data);
+        const current = rows.find((row) => row.code === args.methodCode);
+        if (!current)
+            throw new ToolRefusalError({ status: "refused", blocker: "wire-business", message: `业务方法不存在：${args.serviceCode}/${args.methodCode}`, errcode: 500001 });
+        const currentRecord = current;
+        const inputJson = args.methodInputParameters === undefined ? currentRecord.inputParametersJson : compileParameterFace(adapterCode, typeof args.methodInputParameters === "string" ? safeParseArray(args.methodInputParameters) : args.methodInputParameters, "methodInputParameters");
+        const outputJson = args.methodOutputParameters === undefined ? currentRecord.outputParametersJson : compileParameterFace(adapterCode, typeof args.methodOutputParameters === "string" ? safeParseArray(args.methodOutputParameters) : args.methodOutputParameters, "methodOutputParameters");
+        const methodConfigPlain = args.methodConfig === undefined ? undefined : compileMethodConfigPlain(adapterCode, args.methodConfig);
+        const currentConfig = decodeJsonColumn(currentRecord.configJson);
+        const currentConfigPlain = currentConfig === undefined || currentConfig === null ? undefined : compileMethodConfigPlain(adapterCode, currentConfig);
+        const performed = await wireCall(session, {
+            path: ENDPOINTS.bizServiceMethodUpdate,
+            method: "POST",
+            // Live 2026-09-15 + source evidence (BizServiceMethodModel.java:88-146):
+            // a body carrying the transient `inputParameterModels`/`inputParameters`
+            // keys makes the model setter RE-SERIALIZE and filter out parameters
+            // lacking bizPropertyType/externParameterType, overwriting
+            // inputParametersJson with "[]". The update body must therefore carry
+            // ONLY the persisted columns — never the read-model's transient keys.
+            body: {
+                id: currentRecord.id,
+                serviceCode: args.serviceCode,
+                code: args.methodCode,
+                name: args.name ?? (typeof currentRecord.name === "string" ? currentRecord.name : args.methodCode),
+                ...(methodConfigPlain !== undefined ? { configJson: encryptBizServiceMethodConfigJson(methodConfigPlain) } : currentConfigPlain !== undefined ? { configJson: encryptBizServiceMethodConfigJson(currentConfigPlain) } : {}),
+                ...(inputJson !== undefined && inputJson !== null ? { inputParametersJson: inputJson } : {}),
+                ...(outputJson !== undefined && outputJson !== null ? { outputParametersJson: outputJson } : {}),
+            },
+        });
+        const afterRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data);
+        const after = afterRows.find((row) => row.code === args.methodCode);
+        return { performed: { errcode: performed.errcode }, readback: { methodPresent: after != null, nameMatches: args.name === undefined || after?.name === args.name, configMatches: methodConfigPlain === undefined || after?.configJson === methodConfigPlain, inputParameters: decodeJsonColumn(after?.inputParametersJson), outputParameters: decodeJsonColumn(after?.outputParametersJson) } };
+    }, (args) => {
+        assertStructuredConfig(args.methodConfig, "methodConfig");
+    });
+    writeTool(tools, "method.create", B2_LANE, B2_TOOLS["method.create"].scope, B2_TOOLS["method.create"].description, {
+        serviceCode: z.string().min(1).describe("已存在的业务服务编码（在其下新增方法）"),
+        methodCode: z.string().min(1),
+        name: z.string().min(1).describe("方法名称（设计器必填，中文≤50）"),
+        methodConfig: z.record(z.string(), z.unknown()).optional(),
+        methodInputParameters: z.union([z.array(z.record(z.string(), z.unknown())), z.string()]).optional(),
+        methodOutputParameters: z.union([z.array(z.record(z.string(), z.unknown())), z.string()]).optional(),
+    }, async (session, args) => {
+        // Ticket 116: a new extension endpoint does NOT always mean a new
+        // service — the common case is ADDING a method to an existing service.
+        // service.register refuses a duplicate serviceCode (duplicate-service)
+        // and method.update refuses an absent method, so without this tool the
+        // only path was delete-and-recreate (which drops the service and its
+        // other methods/rule bindings). Platform face: POST
+        // /bizservice/method/create with BizServiceMethodModel{serviceCode,code,
+        // name,configJson,inputParametersJson,outputParametersJson}
+        // (BizServiceMethodController.java:133-170); name/code/serviceCode are
+        // validated non-blank, name ≤50 Chinese chars.
+        const service = await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: args.serviceCode } });
+        const serviceRow = service.data;
+        if (!serviceRow)
+            throw new ToolRefusalError({ status: "refused", blocker: "wire-business", message: `业务服务不存在：${args.serviceCode}；在已有服务下加方法前先确认服务存在（新增服务用 service.register）`, errcode: 500001 });
+        const adapterCode = assertBizServiceAdapterWhitelisted(adapterCodeOf(serviceRow));
+        const rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data);
+        if (rows.some((row) => row.code === args.methodCode))
+            throw new ToolRefusalError({ status: "refused", blocker: "duplicate-method", serviceCode: args.serviceCode, methodCode: args.methodCode, message: `业务方法 ${args.serviceCode}/${args.methodCode} 已存在；改方法用 method.update` });
+        const inputJson = args.methodInputParameters === undefined ? undefined : compileParameterFace(adapterCode, typeof args.methodInputParameters === "string" ? safeParseArray(args.methodInputParameters) : args.methodInputParameters, "methodInputParameters");
+        const outputJson = args.methodOutputParameters === undefined ? undefined : compileParameterFace(adapterCode, typeof args.methodOutputParameters === "string" ? safeParseArray(args.methodOutputParameters) : args.methodOutputParameters, "methodOutputParameters");
+        const methodConfigPlain = args.methodConfig === undefined ? undefined : compileMethodConfigPlain(adapterCode, args.methodConfig);
+        const performed = await wireCall(session, {
+            path: ENDPOINTS.bizServiceMethodCreate,
+            method: "POST",
+            body: {
+                serviceCode: args.serviceCode,
+                code: args.methodCode,
+                name: args.name,
+                ...(methodConfigPlain !== undefined ? { configJson: encryptBizServiceMethodConfigJson(methodConfigPlain) } : {}),
+                ...(inputJson !== undefined && inputJson !== null ? { inputParametersJson: inputJson } : {}),
+                ...(outputJson !== undefined && outputJson !== null ? { outputParametersJson: outputJson } : {}),
+            },
+        });
+        const afterRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data);
+        const after = afterRows.find((row) => row.code === args.methodCode);
+        return { performed: { errcode: performed.errcode }, readback: { methodPresent: after != null, nameMatches: after?.name === args.name, configMatches: methodConfigPlain === undefined || after?.configJson === methodConfigPlain, inputParameters: decodeJsonColumn(after?.inputParametersJson), outputParameters: decodeJsonColumn(after?.outputParametersJson) } };
+    }, (args) => {
+        assertStructuredConfig(args.methodConfig, "methodConfig");
+    });
+    writeTool(tools, "method.delete", B2_LANE, B2_TOOLS["method.delete"].scope, B2_TOOLS["method.delete"].description, { serviceCode: z.string().min(1), methodCode: z.string().min(1) }, async (session, args) => {
+        // Id resolution mirrors service.delete: the delete endpoint keys on the
+        // row id (query, comma-separated on the platform face — this tool stays
+        // single-target), resolved via list_by_service_code + method code.
+        const rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data);
+        const current = rows.find((row) => row.code === args.methodCode);
+        const id = current?.id;
+        if (typeof id !== "string" || !id)
+            return { performed: { errcode: 0 }, readback: { absent: true, note: "method already absent" } };
+        // A referenced method answers 500108 业务方法已绑定默认方法，不可删除
+        // (BizServiceMethodController.java:246-272) — governedWrite surfaces the
+        // platform refusal verbatim with errcode + message; the rule and its
+        // binding stay untouched.
+        const performed = await wireCall(session, { path: ENDPOINTS.bizServiceMethodDelete, method: "POST", query: { id } });
+        const afterRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data);
+        const after = afterRows.find((row) => row.code === args.methodCode);
+        return { performed: { errcode: performed.errcode }, readback: { absent: after == null, ...(after ? { method: after } : {}) } };
+    });
+    tools.push(defineTool({
+        name: "service.category.list",
+        layer: "low",
+        kind: "read",
+        lane: B2_LANE,
+        scope: B2_TOOLS["service.category.list"].scope,
+        description: B2_TOOLS["service.category.list"].description,
+        inputSchema: { environment: environmentArg, capability: capabilityArg },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            // Standard face: /bizservice/category/list returns [{id,name}]; the
+            // virtual「全部」row carries an empty id and is flagged — it is NOT a
+            // valid 所属目录 for register/update.
+            const rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceCategoryList })).data);
+            const categories = rows.map((row) => ({ id: typeof row.id === "string" ? row.id : "", name: row.name }));
+            return {
+                categories,
+                usable: categories.filter((row) => row.id !== ""),
+                virtual: categories.filter((row) => row.id === "").map((row) => row.name),
+            };
+        }),
+    }));
+    writeTool(tools, "service.category.create", B2_LANE, B2_TOOLS["service.category.create"].scope, B2_TOOLS["service.category.create"].description, {
+        name: z.string().min(1).describe("分类名称（非空）"),
+    }, async (session, args) => {
+        const beforeRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceCategoryList })).data);
+        if (beforeRows.some((row) => row.name === args.name))
+            throw new ToolRefusalError({ status: "refused", blocker: "bizservice-category-duplicate", message: `业务服务分类 ${args.name} 已存在；拒绝重复 POST` });
+        // Standard face: category/create {name} (BizServiceCategoryController
+        // .java:43-176); the readback re-lists and resolves the new row by name.
+        const performed = await wireCall(session, { path: ENDPOINTS.bizServiceCategoryCreate, method: "POST", body: { name: args.name } });
+        const afterRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceCategoryList })).data);
+        const created = afterRows.find((row) => row.name === args.name);
+        return {
+            performed: { errcode: performed.errcode },
+            readback: { categoryPresent: created != null, ...(created ? { id: created.id, name: created.name } : {}) },
+        };
+    }, (args) => {
+        if (typeof args.name !== "string" || !args.name.trim())
+            throw new ToolRefusalError({ status: "refused", blocker: "bizservice-required-field-missing", message: "分类名称 name 是必填项；缺失即拒绝，零 wire", field: "name" });
+    });
+    writeTool(tools, "service.category.update", B2_LANE, B2_TOOLS["service.category.update"].scope, B2_TOOLS["service.category.update"].description, {
+        id: z.string().min(1).describe("分类 id（service.category.list 解析）"),
+        name: z.string().min(1).describe("新分类名称（非空，中文≤50）"),
+    }, async (session, args) => {
+        const beforeRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceCategoryList })).data);
+        const current = beforeRows.find((row) => row.id === args.id);
+        if (!current)
+            throw new ToolRefusalError({ status: "refused", blocker: "bizservice-category-absent", errcode: 501052, message: `业务服务分类 ${args.id} 不存在；拒绝 category/update POST` });
+        if (beforeRows.some((row) => row.id !== args.id && row.name === args.name))
+            throw new ToolRefusalError({ status: "refused", blocker: "bizservice-category-duplicate", errcode: 501004, message: `业务服务分类 ${args.name} 已存在；拒绝 category/update POST` });
+        // Standard face: category/update {id,name} (BizServiceCategoryController
+        // .java:109-140). A missing id answers the 501052 envelope; a duplicate
+        // name answers 501004 (BizServiceCategoryServiceImpl.save:54-63) — both
+        // surface verbatim. Readback re-lists and pins the row by id.
+        const performed = await wireCall(session, { path: ENDPOINTS.bizServiceCategoryUpdate, method: "POST", body: { id: args.id, name: args.name } });
+        const afterRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceCategoryList })).data);
+        const after = afterRows.find((row) => row.id === args.id);
+        return {
+            performed: { errcode: performed.errcode },
+            readback: { categoryPresent: after != null, ...(after ? { id: after.id, name: after.name } : {}) },
+        };
+    }, (args) => {
+        for (const [key, label] of [["id", "分类 id"], ["name", "分类名称 name"]])
+            if (typeof args[key] !== "string" || !args[key].trim())
+                throw new ToolRefusalError({ status: "refused", blocker: "bizservice-required-field-missing", message: `${label} 是必填项；缺失即拒绝，零 wire`, field: key });
+        if (args.name.length > 50)
+            throw new ToolRefusalError({ status: "refused", blocker: "bizservice-name-too-long", message: "分类名称中文长度不能超过 50（服务端同样强制）" });
+    });
+    writeTool(tools, "service.category.delete", B2_LANE, B2_TOOLS["service.category.delete"].scope, B2_TOOLS["service.category.delete"].description, {
+        id: z.string().min(1).describe("分类 id（service.category.list 解析；虚拟「全部」id 为空不可删）"),
+    }, async (session, args) => {
+        const beforeRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceCategoryList })).data);
+        if (!beforeRows.some((row) => row.id === args.id))
+            return { performed: { skipped: "already-absent" }, readback: { absent: true } };
+        // Standard face: category/delete?id= (BizServiceCategoryController
+        // .java:142-165). A category still holding services answers 501003
+        // 业务服务目录下存在集成服务，不可删除 (BizServiceFacadeImpl:196-207) —
+        // deletion is BLOCKED, no cascade; the refusal surfaces verbatim.
+        const performed = await wireCall(session, { path: ENDPOINTS.bizServiceCategoryDelete, method: "POST", query: { id: args.id } });
+        const afterRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceCategoryList })).data);
+        const after = afterRows.find((row) => row.id === args.id);
+        return {
+            performed: { errcode: performed.errcode },
+            readback: { absent: after == null, ...(after ? { category: after } : {}) },
+        };
+    });
+    tools.push(defineTool({
+        name: "service.dbconnpool.list",
+        layer: "low",
+        kind: "read",
+        lane: B2_LANE,
+        scope: B2_TOOLS["service.dbconnpool.list"].scope,
+        description: B2_TOOLS["service.dbconnpool.list"].description,
+        inputSchema: { environment: environmentArg, capability: capabilityArg },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            // Standard face: /bizservice/dbconnpool/list. The platform returns
+            // the password column unmasked — the TOOL strips it (credentials
+            // never echo); only the structural face is read back.
+            const rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizDbConnPoolList })).data);
+            return { pools: rows.map((row) => poolReadbackFace(row)), codes: rows.map((row) => row.code) };
+        }),
+    }));
+    writeTool(tools, "service.dbconnpool.create", B2_LANE, B2_TOOLS["service.dbconnpool.create"].scope, B2_TOOLS["service.dbconnpool.create"].description, {
+        code: z.string().min(1).describe("连接池编码（唯一；无效 → 502003，重复 → 502002）"),
+        name: z.string().min(1).describe("连接池名称（非空，中文≤50；空 → 502004）"),
+        databaseType: z.string().min(1).describe("数据库类型（如 MySQL/Oracle/SQLServer；设计器必选）"),
+        jdbcUrl: z.string().min(1).describe("JDBC 连接串（服务端白名单校验；Kafka 类型由 externInfo url:port 合成）"),
+        username: z.string().optional(),
+        password: z.string().optional().describe("连接口令（只上送，读回永不回显）"),
+        description: z.string().optional(),
+        datasourceType: z.string().optional().describe("DATABASE（缺省）/Kafka"),
+        externInfo: z.string().optional().describe("扩展信息 JSON（Kafka 需 {url,port}）"),
+    }, async (session, args) => {
+        // Standard face: /bizservice/dbconnpool/create (BizDatabaseConnection
+        // PoolModel body; controller validates the jdbcUrl whitelist, service
+        // validates name/code/uniqueness and initializes the datasource).
+        // Password RSA boundary (live 504011): the entity decrypts the stored
+        // column with its hardcoded keypair — plaintext fails to decrypt and
+        // the pool connects with NO password, so the tool always sends the
+        // encrypted form (encryptBizDbPoolPassword).
+        const performed = await wireCall(session, {
+            path: ENDPOINTS.bizDbConnPoolCreate,
+            method: "POST",
+            body: {
+                code: args.code,
+                name: args.name,
+                databaseType: args.databaseType,
+                jdbcUrl: args.jdbcUrl,
+                ...(args.username !== undefined ? { username: args.username } : {}),
+                ...(args.password !== undefined ? { password: encryptBizDbPoolPassword(args.password) } : {}),
+                ...(args.description !== undefined ? { description: args.description } : {}),
+                ...(args.datasourceType !== undefined ? { datasourceType: args.datasourceType } : {}),
+                ...(args.externInfo !== undefined ? { externInfo: args.externInfo } : {}),
+            },
+        });
+        const rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizDbConnPoolList })).data);
+        const created = rows.find((row) => row.code === args.code);
+        return {
+            performed: { errcode: performed.errcode },
+            readback: { poolPresent: created != null, ...(created ? poolReadbackFace(created) : {}) },
+        };
+    }, (args) => {
+        for (const [key, label] of [["code", "连接池编码 code"], ["name", "连接池名称 name"], ["databaseType", "数据库类型 databaseType"], ["jdbcUrl", "JDBC 连接串 jdbcUrl"]])
+            if (typeof args[key] !== "string" || !args[key].trim())
+                throw new ToolRefusalError({ status: "refused", blocker: "bizservice-required-field-missing", message: `${label} 是必填项；缺失即拒绝，零 wire`, field: key });
+        if (args.datasourceType !== undefined && !["DATABASE", "Kafka"].includes(String(args.datasourceType)))
+            throw new ToolRefusalError({ status: "refused", blocker: "bizservice-dbconnpool-invalid", message: "datasourceType 只接受 DATABASE（缺省）或 Kafka（8.6.26 服务端分支）" });
+    });
+    writeTool(tools, "service.dbconnpool.update", B2_LANE, B2_TOOLS["service.dbconnpool.update"].scope, B2_TOOLS["service.dbconnpool.update"].description, {
+        code: z.string().min(1).describe("连接池编码（解析行 id 与当前列）"),
+        name: z.string().optional(),
+        databaseType: z.string().optional(),
+        jdbcUrl: z.string().optional(),
+        username: z.string().optional(),
+        password: z.string().optional().describe("新口令（只上送；缺省回显存量密文保持覆写不抹列）"),
+        description: z.string().optional(),
+        datasourceType: z.string().optional(),
+        externInfo: z.string().optional(),
+    }, async (session, args) => {
+        // The platform update is a FULL-ROW overwrite
+        // (BizDatabaseConnectionPoolServiceImpl.update:135-168 — only
+        // createdTime is carried), so the tool echoes every untouched column
+        // (including the stored password ciphertext, like the designer) and a
+        // name-only update cannot wipe jdbcUrl/username/credentials.
+        const rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizDbConnPoolList })).data);
+        const current = rows.find((row) => row.code === args.code);
+        if (!current)
+            throw new ToolRefusalError({ status: "refused", blocker: "wire-business", message: `数据库连接池不存在：${args.code}`, errcode: 502001 });
+        const currentRecord = current;
+        const performed = await wireCall(session, {
+            path: ENDPOINTS.bizDbConnPoolUpdate,
+            method: "POST",
+            body: {
+                id: currentRecord.id,
+                code: args.code,
+                name: args.name ?? currentRecord.name,
+                databaseType: args.databaseType ?? currentRecord.databaseType,
+                jdbcUrl: args.jdbcUrl ?? currentRecord.jdbcUrl,
+                username: args.username !== undefined ? args.username : currentRecord.username ?? "",
+                // New passwords ride the RSA boundary; the echoed stored value is
+                // already ciphertext (designer parity — the overwrite keeps the
+                // credential column intact when the caller does not rotate it).
+                password: args.password !== undefined ? encryptBizDbPoolPassword(args.password) : currentRecord.password ?? "",
+                description: args.description !== undefined ? args.description : currentRecord.description ?? "",
+                datasourceType: args.datasourceType ?? currentRecord.datasourceType ?? "DATABASE",
+                externInfo: args.externInfo !== undefined ? args.externInfo : currentRecord.externInfo ?? "",
+            },
+        });
+        const afterRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizDbConnPoolList })).data);
+        const after = afterRows.find((row) => row.code === args.code);
+        return {
+            performed: { errcode: performed.errcode },
+            readback: { poolPresent: after != null, ...(after ? poolReadbackFace(after) : {}) },
+        };
+    });
+    writeTool(tools, "service.dbconnpool.delete", B2_LANE, B2_TOOLS["service.dbconnpool.delete"].scope, B2_TOOLS["service.dbconnpool.delete"].description, { code: z.string().min(1).describe("连接池编码") }, async (session, args) => {
+        // Standard face: /bizservice/dbconnpool/delete?id=. A pool referenced
+        // by any service config's dbConnPoolCode answers 502006
+        // 数据库连接池已经被业务服务引用 (BizServiceFacadeImpl delete:173-189)
+        // — blocked, no cascade; the refusal surfaces verbatim.
+        const rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizDbConnPoolList })).data);
+        const current = rows.find((row) => row.code === args.code);
+        if (!current)
+            return { performed: { errcode: 0 }, readback: { absent: true, note: "pool already absent" } };
+        const performed = await wireCall(session, { path: ENDPOINTS.bizDbConnPoolDelete, method: "POST", query: { id: String(current.id) } });
+        const afterRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizDbConnPoolList })).data);
+        const after = afterRows.find((row) => row.code === args.code);
+        return { performed: { errcode: performed.errcode }, readback: { absent: after == null } };
+    });
+    tools.push(defineTool({
+        name: "service.adapter_config",
+        layer: "low",
+        kind: "read",
+        lane: B2_LANE,
+        scope: B2_TOOLS["service.adapter_config"].scope,
+        description: B2_TOOLS["service.adapter_config"].description,
+        inputSchema: { environment: environmentArg, capability: capabilityArg },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            // Standard face: /bizservice/service/adapter_config answers a JSON
+            // STRING of the registered protocol adapters (BizServiceFacadeImpl
+            // .java:322-328 JSON.toJSONString(list); each entry
+            // {code,name,config:{authList,commonList,serviceActionList,
+            // methodActionList}} per AdapterConfigParam.java:16-181). Decoded to
+            // the same faces service.register's adapter preflight enforces —
+            // one source, no drift. Note: with sqlConfigEnabled the platform
+            // REMOVES DATA_SQL/DATA_TABLE from the list (readback verbatim).
+            const result = await wireCall(session, { path: ENDPOINTS.bizServiceAdapterConfig });
+            let adapters = null;
+            if (typeof result.data === "string" && result.data.trim()) {
+                try {
+                    adapters = JSON.parse(result.data);
+                }
+                catch {
+                    adapters = null;
+                }
+            }
+            return { adapters, rawPresent: typeof result.data === "string" };
+        }),
+    }));
+    tools.push(defineTool({
+        name: "service.table_list",
+        layer: "low",
+        kind: "read",
+        lane: B2_LANE,
+        scope: B2_TOOLS["service.table_list"].scope,
+        description: B2_TOOLS["service.table_list"].description,
+        inputSchema: {
+            environment: environmentArg,
+            serviceCode: z.string().min(1).describe("DATA_TABLE 业务服务编码"),
+            page: z.number().int().min(1).optional(),
+            size: z.number().int().min(1).optional(),
+            keyword: z.string().optional(),
+            capability: capabilityArg,
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            // Standard face: /bizservice/method/get_tablename_list (defaults
+            // page=1 / size=MAX when omitted, BizServiceMethodController
+            // .java:503-537). DATA_TABLE only — a DATA_SQL service answers 501010
+            // 业务服务不为DataTable类型 (evidence correction: the research doc's
+            // "DATA_SQL table discovery" reading was wrong).
+            const result = await wireCall(session, {
+                path: ENDPOINTS.bizServiceTableList,
+                query: { serviceCode: args.serviceCode, ...(args.page !== undefined ? { page: String(args.page) } : {}), ...(args.size !== undefined ? { size: String(args.size) } : {}), ...(args.keyword !== undefined ? { keyword: args.keyword } : {}) },
+            });
+            return { serviceCode: args.serviceCode, tables: result.data };
+        }),
+    }));
+    tools.push(defineTool({
+        name: "service.table_sql",
+        layer: "low",
+        kind: "read",
+        lane: B2_LANE,
+        scope: B2_TOOLS["service.table_sql"].scope,
+        description: B2_TOOLS["service.table_sql"].description,
+        inputSchema: { environment: environmentArg, serviceCode: z.string().min(1), tableName: z.string().min(1), capability: capabilityArg },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            // Standard face: /bizservice/method/get_table_column
+            // (BizServiceMethodController.java:538-560). Despite the name it
+            // answers GENERATED SQL TEMPLATES (DataTableSqlModel{sql,sqlType}),
+            // not column metadata (BizServiceFacadeImpl.getDataTableSql:889-910).
+            const result = await wireCall(session, { path: ENDPOINTS.bizServiceTableSql, query: { serviceCode: args.serviceCode, tableName: args.tableName } });
+            return { serviceCode: args.serviceCode, tableName: args.tableName, rows: result.data };
+        }),
+    }));
+    writeTool(tools, "service.register", B2_LANE, B2_TOOLS["service.register"].scope, B2_TOOLS["service.register"].description, {
+        serviceCode: z.string().min(1),
+        name: z.string().min(1).describe("服务名称（设计器必填；非空，中文≤50，服务端同样强制）"),
+        adapterCode: z.string().min(1).describe("适配器编码（设计器必填）：RESTFUL/DATA_SQL/DATA_TABLE/SAP/KAFKA/SOAP。自定义 Java 方法体（扩展接口）的常规做法是用 RESTFUL 指向扩展端点，不要用 INTERNAL/custom_protocol"),
+        serviceCategoryId: z.string().min(1).describe("所属目录 id（设计器必填；用 service.category.list 解析，「全部」是空 id 虚拟项不可用，必要时 service.category.create 新建）"),
+        serviceConfig: z.record(z.string(), z.unknown()).optional().describe("结构化服务 configJson（明文落库；原生适配器按 adapterCode 校验）。RESTFUL/SOAP 鉴权 auth.code 仅接受 customer（parameterlist=[]）、basic（username/password）、oauth_password（client_id/client_secret/username/password/oauth_path）、oauth_client（client_id/client_secret/oauth_path）；每项为 code/name?/value 字符串，值只透传不记录；DATA_SQL/DATA_TABLE/SAP/KAFKA 不使用服务级鉴权，auth 只能为空对象或省略"),
+        methodName: z.string().optional(),
+        methodConfig: z.record(z.string(), z.unknown()).optional().describe("结构化方法 configJson（工具 AES-128-ECB+Base64 加密后上送；明文会被平台静默存 NULL）。RESTFUL 必填 httpType/requestBodyType/url/frontEndExtensionEnable，枚举可用名字（httpType: Post/Get/Put/Patch/Delete；requestBodyType: Form-urlencoded/JSON/Text），工具会编码成平台整数索引。DATA_SQL/DATA_TABLE 需要 sql/returnType（returnType: Void/SingleObject/List）。RESTFUL/DATA_SQL/DATA_TABLE/SAP/KAFKA 带 methodName 时必填；SOAP 方法由 WSDL 动态发现、无固定方法 configJson"),
+        methodInputParameters: z.union([z.array(z.record(z.string(), z.unknown())), z.string()]).optional().describe("方法输入参数声明（[{code,name,…}] 数组或 JSON 字符串）→ inputParametersJson；绑定校验按 code 对账；RESTFUL 每参数需 configJson.position"),
+        methodOutputParameters: z.union([z.array(z.record(z.string(), z.unknown())), z.string()]).optional().describe("方法输出参数声明 → outputParametersJson"),
+        description: z.string().optional(),
+    }, async (session, args) => {
+        // Live evidence (ticket 35): service/create with an empty adapterCode is
+        // refused 500005 业务服务关联适配器编码为空; INTERNAL(6) is the local
+        // extension adapter a 二开 registration shell binds to. A structured
+        // write (serviceConfig/methodConfig) targets the designer write face and
+        // requires a whitelisted adapterCode (ticket 92). Designer-parity
+        // requireds (user directive 2026-09-14): name/adapterCode/
+        // serviceCategoryId are enforced by the schema AND the preflight, and a
+        // whitelisted adapter must carry serviceConfig (+ methodConfig with a
+        // methodName).
+        const adapterCode = args.adapterCode;
+        let existing = null;
+        try {
+            existing = (await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: args.serviceCode } })).data;
+        }
+        catch (error) {
+            if (!(error instanceof WireError && error.kind === "business"))
+                throw error;
+        }
+        if (existing)
+            throw new ToolRefusalError({ status: "refused", blocker: "duplicate-service", serviceCode: args.serviceCode, message: `业务服务 ${args.serviceCode} 已存在；拒绝重复 service/create POST` });
+        if (adapterCode === "SOAP" && (args.methodName !== undefined || args.methodConfig !== undefined))
+            throw new ToolRefusalError({ status: "refused", blocker: "bizservice-method-config-invalid", message: "SOAP 方法由 WSDL 动态发现，没有固定 methodConfig；请使用平台原生 SOAP refresh/方法发现接口，不伪造方法体" });
+        // Ticket 103: the platform never validates serviceCategoryId — refuse a
+        // dangling id before any write (read-only resolution precedes this).
+        await assertCategoryResolves(session, args.serviceCategoryId);
+        const serviceConfigJson = args.serviceConfig !== undefined ? compileServiceConfig(adapterCode, args.serviceConfig) : undefined;
+        // Ticket 104: a DATA_SQL/DATA_TABLE binding must reference an existing
+        // connection pool before any write (the platform stores it unvalidated).
+        if (serviceConfigJson !== undefined && (adapterCode === "DATA_SQL" || adapterCode === "DATA_TABLE")) {
+            const poolCode = dbConnPoolCodeOf(args.serviceConfig);
+            if (poolCode !== undefined)
+                await assertDbConnPoolResolves(session, poolCode);
+        }
+        const methodConfigPlain = args.methodConfig !== undefined ? compileMethodConfigPlain(adapterCode, args.methodConfig) : undefined;
+        const performed = await wireCall(session, {
+            path: ENDPOINTS.bizServiceCreate,
+            method: "POST",
+            body: {
+                code: args.serviceCode,
+                name: args.name,
+                adapterCode,
+                description: args.description ?? "",
+                serviceCategoryId: args.serviceCategoryId,
+                ...(serviceConfigJson !== undefined ? { configJson: serviceConfigJson } : {}),
+            },
+        });
+        if (args.methodName) {
+            // The parameter face is adapter-checked only when this is a structured
+            // write; a plain registration shell keeps the ticket-35 face (INTERNAL).
+            const faceAdapter = serviceConfigJson !== undefined || methodConfigPlain !== undefined ? assertBizServiceAdapterWhitelisted(adapterCode) : "INTERNAL";
+            const serializeFace = (value, label) => value === undefined ? undefined : compileParameterFace(faceAdapter, typeof value === "string" ? (safeParseArray(value) ?? value) : value, label);
+            const inputJson = serializeFace(args.methodInputParameters, "methodInputParameters");
+            const outputJson = serializeFace(args.methodOutputParameters, "methodOutputParameters");
+            await wireCall(session, {
+                path: ENDPOINTS.bizServiceMethodCreate,
+                method: "POST",
+                body: {
+                    serviceCode: args.serviceCode, code: args.methodName, name: args.methodName,
+                    ...(methodConfigPlain !== undefined ? { configJson: encryptBizServiceMethodConfigJson(methodConfigPlain) } : {}),
+                    ...(inputJson !== undefined ? { inputParametersJson: inputJson } : {}),
+                    ...(outputJson !== undefined ? { outputParametersJson: outputJson } : {}),
+                },
+            });
+        }
+        const readback = await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: args.serviceCode } });
+        const methodRows = readback.data != null
+            ? wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data)
+            : [];
+        const registered = args.methodName ? methodRows.some((row) => row.code === args.methodName) : undefined;
+        return {
+            performed: { errcode: performed.errcode },
+            readback: { servicePresent: readback.data != null, ...(registered !== undefined ? { methodPresent: registered, methodCount: methodRows.length } : {}) },
+        };
+    }, (args) => {
+        // Dry-lint (zero wire). `omc call` bypasses zod, so every schema-level
+        // required is re-enforced here BEFORE the write permission gate.
+        for (const [key, label] of [["name", "服务名称 name"], ["adapterCode", "适配器编码 adapterCode"], ["serviceCategoryId", "所属目录 serviceCategoryId"]])
+            if (typeof args[key] !== "string" || !args[key].trim())
+                throw new ToolRefusalError({ status: "refused", blocker: "bizservice-required-field-missing", message: `${label} 是设计器必填项（designer parity）；缺失即拒绝，零 wire。所属目录用 service.category.list 解析、service.category.create 新建`, field: key });
+        if (args.name.length > 50)
+            throw new ToolRefusalError({ status: "refused", blocker: "bizservice-name-too-long", message: "服务名称中文长度不能超过 50（BizServiceController.java:84-112 服务端同样强制）" });
+        assertStructuredConfig(args.serviceConfig, "serviceConfig");
+        assertStructuredConfig(args.methodConfig, "methodConfig");
+        const adapterCode = String(args.adapterCode);
+        if (BIZSERVICE_WRITE_ADAPTERS.includes(adapterCode)) {
+            // A source-evidenced native adapter is a DESIGNER configuration: the
+            // service config is required for every adapter. SOAP deliberately has
+            // no methodName/methodConfig here because the platform discovers SOAP
+            // methods from WSDL via its native refresh path.
+            if (args.serviceConfig === undefined)
+                throw new ToolRefusalError({ status: "refused", blocker: "bizservice-service-config-invalid", message: `${adapterCode} 服务必须携带结构化 serviceConfig（设计器同款必填）` });
+            compileServiceConfig(adapterCode, args.serviceConfig);
+            if (args.methodName !== undefined && adapterCode === "SOAP")
+                throw new ToolRefusalError({ status: "refused", blocker: "bizservice-method-config-invalid", message: "SOAP 方法由 WSDL 动态发现，没有固定 methodConfig；请使用平台原生 SOAP refresh/方法发现接口，不伪造方法体" });
+            if (args.methodName !== undefined && args.methodConfig === undefined)
+                throw new ToolRefusalError({ status: "refused", blocker: "bizservice-method-config-invalid", message: `${adapterCode} 方法必须携带结构化 methodConfig——只有名字/参数面的注册壳不是设计器配置的方法` });
+            if (args.methodConfig !== undefined)
+                compileMethodConfigPlain(adapterCode, args.methodConfig);
+            for (const [key, label] of [["methodInputParameters", "methodInputParameters"], ["methodOutputParameters", "methodOutputParameters"]])
+                if (args[key] !== undefined)
+                    compileParameterFace(adapterCode, typeof args[key] === "string" ? safeParseArray(args[key]) : args[key], label);
+        }
+        else if (args.serviceConfig !== undefined || args.methodConfig !== undefined) {
+            // Structured configs on a non-whitelisted adapter (e.g. INTERNAL) are
+            // refused with the support face named (ADR 0001).
+            assertBizServiceAdapterWhitelisted(adapterCode);
+        }
+    });
+    writeTool(tools, "service.update", B2_LANE, B2_TOOLS["service.update"].scope, B2_TOOLS["service.update"].description, {
+        serviceCode: z.string().min(1),
+        name: z.string().optional(),
+        serviceConfig: z.record(z.string(), z.unknown()).optional().describe("结构化服务 configJson（明文上送；按服务 adapterCode 做必需键预检，同 service.register）"),
+        description: z.string().optional(),
+        serviceCategoryId: z.string().optional().describe("服务分类 id（通用透传，不静默丢弃）"),
+        shared: z.boolean().optional().describe("共享服务（通用透传）"),
+        userIdList: z.array(z.string()).optional().describe("可见用户列表（通用透传）"),
+        modifierList: z.array(z.string()).optional().describe("修改者列表（通用透传）"),
+    }, async (session, args) => {
+        // Ticket 93 — patch an existing service without delete/recreate. The id
+        // is resolved via get_by_code first (BizServiceController update path
+        // requires it); metadata keys pass through verbatim.
+        const found = await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: args.serviceCode } });
+        const row = found.data;
+        const id = row?.id;
+        if (typeof id !== "string" || !id)
+            return { performed: { errcode: 500001 }, readback: { absent: true }, summary: `业务服务不存在：${args.serviceCode}` };
+        const adapterCode = typeof row.adapterCode === "string" ? row.adapterCode : "";
+        // Ticket 103: a NEW serviceCategoryId must resolve before the update
+        // write (the platform writes it verbatim without validation).
+        if (args.serviceCategoryId !== undefined)
+            await assertCategoryResolves(session, args.serviceCategoryId);
+        // A structured serviceConfig targets the designer write face: the same
+        // adapter whitelist + required-key preflight as register (ticket 92).
+        // Refusal here precedes the update WRITE (only the read-only id
+        // resolution may have preceded it).
+        const serviceConfigJson = args.serviceConfig !== undefined ? compileServiceConfig(assertBizServiceAdapterWhitelisted(adapterCode), args.serviceConfig) : undefined;
+        // Ticket 104: a DATA_SQL/DATA_TABLE binding must reference an existing
+        // connection pool before the update write.
+        if (serviceConfigJson !== undefined && (adapterCode === "DATA_SQL" || adapterCode === "DATA_TABLE")) {
+            const poolCode = dbConnPoolCodeOf(args.serviceConfig);
+            if (poolCode !== undefined)
+                await assertDbConnPoolResolves(session, poolCode);
+        }
+        // Live incident 2026-09-14 (user-visible): the platform update path is a
+        // FULL-ROW overwrite (ModelUtility.toEntity → save/update) — a body that
+        // omits configJson/serviceCategoryId wipes them to NULL on the platform
+        // even though the caller never asked to change them. Patch semantics are
+        // therefore implemented by ECHOING the row's current values for every
+        // nullable managed column the caller did not override.
+        const echo = (override, current) => (override !== undefined ? override : current ?? null);
+        const performed = await wireCall(session, {
+            path: ENDPOINTS.bizServiceUpdate,
+            method: "POST",
+            body: {
+                id,
+                code: args.serviceCode,
+                name: args.name ?? row.name ?? args.serviceCode,
+                adapterCode,
+                description: args.description ?? (typeof row.description === "string" ? row.description : ""),
+                configJson: echo(serviceConfigJson, typeof row.configJson === "string" ? row.configJson : null),
+                serviceCategoryId: echo(args.serviceCategoryId, typeof row.serviceCategoryId === "string" ? row.serviceCategoryId : null),
+                shared: echo(args.shared, row.shared === true),
+                userIdList: echo(args.userIdList, Array.isArray(row.userIdList) ? row.userIdList : []),
+                modifierList: echo(args.modifierList, Array.isArray(row.modifierList) ? row.modifierList : []),
+            },
+        });
+        const readback = await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: args.serviceCode } });
+        const after = readback.data;
+        const nameMatches = args.name === undefined || after?.name === args.name;
+        const configMatches = serviceConfigJson === undefined || (typeof after?.configJson === "string" && after.configJson === serviceConfigJson);
+        // Regression guard against the full-row-overwrite wipe: when the caller
+        // did NOT touch the config, an existing config must survive verbatim.
+        const configPreserved = serviceConfigJson === undefined && typeof row.configJson === "string" ? after?.configJson === row.configJson : undefined;
+        return {
+            performed: { errcode: performed.errcode },
+            readback: { servicePresent: after != null, nameMatches, configMatches, ...(configPreserved !== undefined ? { configPreserved } : {}), ...(adapterCode ? { adapterCode } : {}) },
+        };
+    }, (args) => {
+        // Zero-wire refusal: the raw-string configJson face. `omc call` bypasses
+        // zod, so the string form must be refused here too. The adapter
+        // whitelist/required-key preflight needs the service row's adapterCode
+        // and therefore runs after the read-only id resolution — still before
+        // any update write (see the execute body).
+        assertStructuredConfig(args.serviceConfig, "serviceConfig");
+    });
+    writeTool(tools, "service.delete", B2_LANE, B2_TOOLS["service.delete"].scope, B2_TOOLS["service.delete"].description, { serviceCode: z.string().min(1) }, async (session, args) => {
+        const found = await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: args.serviceCode } });
+        const id = found.data?.id;
+        if (typeof id !== "string" || !id)
+            return { performed: { errcode: 0 }, readback: { absent: true, note: "service already absent" } };
+        const performed = await wireCall(session, { path: ENDPOINTS.bizServiceDelete, method: "POST", query: { id } });
+        let absent = false;
+        try {
+            const readback = await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: args.serviceCode } });
+            absent = readback.data == null;
+        }
+        catch {
+            // get_by_code answers 500001 业务服务不存在 when the service is gone.
+            absent = true;
+        }
+        // Ticket 97 audit fix: the service-row absence alone does not prove the
+        // METHOD rows are gone (DB-level cascade was never evidenced) — read the
+        // method list by serviceCode and require it empty before absent:true.
+        let methodsAbsent = false;
+        try {
+            const methods = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data);
+            methodsAbsent = methods.length === 0;
+        }
+        catch {
+            // The list face refuses once the owning service row is gone — the
+            // methods are unreachable, which is the observable absence.
+            methodsAbsent = true;
+        }
+        return { performed: { errcode: performed.errcode }, readback: { absent: absent && methodsAbsent, serviceRowAbsent: absent, methodsAbsent } };
+    });
+    // -------------------------------------------------------------------------
+    // Ticket 106 — the IE (import/export) face
+    // -------------------------------------------------------------------------
+    /**
+     * Read + validate a local IE package BEFORE any wire call: a missing file
+     * (bizservice-ie-zip-missing) or an off-shape zip/manifest
+     * (bizservice-ie-zip-invalid) refuses with zero uploads. The manifest is
+     * parsed once here and reused by check (reporting) and import (readback
+     * targets).
+     */
+    function readIeZipFile(zipPath) {
+        if (!existsSync(zipPath))
+            throw new ToolRefusalError({ status: "refused", blocker: "bizservice-ie-zip-missing", message: `集成服务包不存在：${zipPath}（先用 service.export 导出，或确认路径）`, zipPath });
+        let bytes;
+        try {
+            bytes = readFileSync(zipPath);
+        }
+        catch (error) {
+            throw new ToolRefusalError({ status: "refused", blocker: "bizservice-ie-zip-missing", message: `集成服务包不可读：${zipPath}（${error.message}）`, zipPath });
+        }
+        const fail = (reason) => new ToolRefusalError({ status: "refused", blocker: "bizservice-ie-zip-invalid", message: `集成服务包无效：${reason}（需要平台 export 形状的 zip：manifest.json + version.md）`, zipPath });
+        let manifestRaw;
+        try {
+            const entries = readZipEntries(bytes);
+            const manifestEntry = zipEntryByBasename(entries, "manifest.json");
+            if (manifestEntry === undefined)
+                throw new Error("缺少 manifest.json");
+            manifestRaw = JSON.parse(manifestEntry.toString("utf8"));
+        }
+        catch (error) {
+            throw fail(error instanceof ZipFormatError || error instanceof SyntaxError ? error.message : error.message);
+        }
+        let manifest;
+        try {
+            manifest = parseIeManifest(manifestRaw);
+        }
+        catch (error) {
+            throw fail(error.message);
+        }
+        return { bytes, sha256: createHash("sha256").update(bytes).digest("hex"), manifest };
+    }
+    /** Upload a fresh copy of the package; every refId is one-shot (platform design). */
+    async function uploadIeZip(session, zip, zipPath) {
+        return wireUploadFile(session, ENDPOINTS.runtimeQueryUploadFile, basename(zipPath) || "bizservice-package.zip", zip.bytes);
+    }
+    async function ieImportScope(session, manifest, args) {
+        const rename = new Map((args.modifyServiceCodes ?? []).map((entry) => [entry.oldServiceCode, entry.newServiceCode]));
+        const scope = {
+            services: manifest.services.map((service) => rename.get(service.code) ?? service.code),
+            methods: manifest.services.map((service) => ({
+                serviceCode: rename.get(service.code) ?? service.code,
+                methodCodes: (manifest.methodsByService[service.code] ?? []).map((method) => method.code),
+            })),
+        };
+        if (args.overWrite)
+            return scope;
+        const conflicts = { services: [], methods: [] };
+        for (const service of scope.services) {
+            let row;
+            try {
+                row = (await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: service } })).data;
+            }
+            catch (error) {
+                if (error instanceof WireError && error.kind === "business" && error.errcode === 500001)
+                    row = null;
+                else
+                    throw error;
+            }
+            if (!row)
+                continue;
+            conflicts.services.push(service);
+            const methods = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: service, filterFlag: "false" } })).data);
+            const packaged = scope.methods.find((entry) => entry.serviceCode === service)?.methodCodes ?? [];
+            const methodCodes = methods.map((method) => method.code).filter((code) => typeof code === "string" && packaged.includes(code));
+            if (methodCodes.length > 0)
+                conflicts.methods.push({ serviceCode: service, methodCodes });
+        }
+        if (conflicts.services.length > 0 || conflicts.methods.length > 0)
+            throw new ToolRefusalError({ status: "refused", blocker: "bizservice-import-conflict", message: `导入包与现有业务服务/方法编码冲突；overWrite=false 时拒绝上传与 import`, conflicts });
+        return scope;
+    }
+    tools.push(defineTool({
+        name: "service.export",
+        layer: "low",
+        kind: "read",
+        lane: B2_LANE,
+        scope: B2_TOOLS["service.export"].scope,
+        description: B2_TOOLS["service.export"].description,
+        inputSchema: {
+            environment: environmentArg,
+            serviceCodes: z.array(z.string().min(1)).min(1).describe("要导出的业务集成服务编码列表"),
+            capability: capabilityArg,
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            // Fail-closed existence preflight: the platform export SILENTLY SKIPS
+            // unknown codes (BizServiceIEFacadeImpl.java:135-148 getByCode null →
+            // not added), so an unresolved code would hand back a short package.
+            const missing = [];
+            for (const code of args.serviceCodes) {
+                try {
+                    const found = await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: code } });
+                    if (found.data == null)
+                        missing.push(code);
+                }
+                catch {
+                    missing.push(code);
+                }
+            }
+            if (missing.length > 0)
+                throw new ToolRefusalError({ status: "refused", blocker: "bizservice-export-code-unresolved", message: `集成服务编码不存在：${missing.join("、")}——平台导出会静默跳过未知编码，缺码即拒绝（零导出调用）`, serviceCodes: missing });
+            const zip = await wireDownloadBuffer(session, { path: ENDPOINTS.bizServiceExport, body: { serviceCodes: args.serviceCodes } });
+            mkdirSync(ctx.artifactsDir, { recursive: true });
+            const filePath = `${ctx.artifactsDir.replaceAll(/\\/g, "/")}/bizservice-export-${randomUUID().slice(0, 8)}.zip`;
+            writeFileSync(filePath, zip);
+            // Secret-free package summary. The zip itself keeps the platform
+            // shape (service configJson incl. auth values, method configJson in
+            // the stored plaintext form) — the import round-trip requires it; the
+            // RESPONSE never inlines package contents.
+            let packageSummary = null;
+            let packageParseError = null;
+            try {
+                const manifestEntry = zipEntryByBasename(readZipEntries(zip), "manifest.json");
+                if (manifestEntry === undefined)
+                    throw new Error("manifest.json 缺失");
+                packageSummary = iePackageSummary(parseIeManifest(JSON.parse(manifestEntry.toString("utf8"))));
+            }
+            catch (error) {
+                packageParseError = error.message;
+            }
+            return {
+                serviceCodes: args.serviceCodes,
+                artifact: { path: filePath, bytes: zip.length, sha256: createHash("sha256").update(zip).digest("hex") },
+                package: packageSummary,
+                ...(packageParseError !== null ? { packageParseError } : {}),
+            };
+        }),
+    }));
+    tools.push(defineTool({
+        name: "service.check",
+        layer: "low",
+        kind: "read",
+        lane: B2_LANE,
+        scope: B2_TOOLS["service.check"].scope,
+        description: B2_TOOLS["service.check"].description,
+        inputSchema: {
+            environment: environmentArg,
+            zipPath: z.string().min(1).describe("本地集成服务包路径（service.export 的 artifact.path）"),
+            overWrite: z.boolean().describe("是否覆盖已存在的同码服务"),
+            modifyServiceCodes: z.array(z.object({ oldServiceCode: z.string().min(1), newServiceCode: z.string().min(1) })).optional().describe("重码改名映射（overWrite=false 时解冲突；newCode 需匹配 [a-zA-Z][a-zA-Z0-9_]{0,27}）"),
+            capability: capabilityArg,
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            const zip = readIeZipFile(args.zipPath);
+            const refId = await uploadIeZip(session, zip, args.zipPath);
+            // Validation-only: check reads the uploaded package and reports
+            // repeated codes / renames; it writes nothing (the refId it consumed
+            // is its own fresh upload).
+            const result = await wireCall(session, {
+                path: ENDPOINTS.bizServiceCheck,
+                method: "POST",
+                body: {
+                    fileName: refId,
+                    overWrite: args.overWrite,
+                    ...(args.modifyServiceCodes !== undefined ? { modifyServiceCodes: args.modifyServiceCodes } : {}),
+                },
+            });
+            return {
+                zip: { path: args.zipPath, bytes: zip.bytes.length, sha256: zip.sha256 },
+                overWrite: args.overWrite,
+                report: result.data,
+                package: iePackageSummary(zip.manifest),
+            };
+        }),
+    }));
+    writeTool(tools, "service.import", B2_LANE, B2_TOOLS["service.import"].scope, B2_TOOLS["service.import"].description, {
+        zipPath: z.string().min(1).describe("本地集成服务包路径（service.export 的 artifact.path）"),
+        overWrite: z.boolean().describe("覆盖已存在的同码服务（true 时忽略重码改名）"),
+        modifyServiceCodes: z.array(z.object({ oldServiceCode: z.string().min(1), newServiceCode: z.string().min(1) })).optional().describe("重码改名映射（overWrite=false 时解冲突）"),
+        groupId: z.string().optional().describe("导入目标分类 id（service.category.list 解析；缺省沿用包内分类）"),
+    }, async (session, args) => {
+        const zip = readIeZipFile(args.zipPath);
+        const overwriteScope = await ieImportScope(session, zip.manifest, args);
+        const refId = await uploadIeZip(session, zip, args.zipPath);
+        const performed = await wireCall(session, {
+            path: ENDPOINTS.bizServiceImport,
+            method: "POST",
+            body: {
+                fileName: refId,
+                overWrite: args.overWrite,
+                ...(args.modifyServiceCodes !== undefined ? { modifyServiceCodes: args.modifyServiceCodes } : {}),
+                ...(args.groupId !== undefined ? { groupId: args.groupId } : {}),
+            },
+        });
+        // Authoritative readback: every manifest service under its FINAL code
+        // (rename applied), with its method face enumerated.
+        const rename = new Map((args.modifyServiceCodes ?? []).map((entry) => [entry.oldServiceCode, entry.newServiceCode]));
+        const services = [];
+        for (const service of zip.manifest.services) {
+            const finalCode = rename.get(service.code) ?? service.code;
+            const entry = { code: finalCode, packagedCode: service.code };
+            try {
+                const found = await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: finalCode } });
+                const row = found.data;
+                entry.present = row != null;
+                if (row) {
+                    entry.name = row.name;
+                    entry.adapterCode = row.adapterCode;
+                }
+                const methods = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: finalCode, filterFlag: "false" } })).data);
+                const packagedMethods = zip.manifest.methodsByService[service.code] ?? [];
+                entry.methods = methods.map((method) => ({ code: method.code, name: method.name }));
+                entry.parameterFaces = packagedMethods.map((packaged) => {
+                    const actual = methods.find((method) => method.code === packaged.code);
+                    return {
+                        methodCode: packaged.code,
+                        inputParametersMatch: actual !== undefined && String(actual.inputParametersJson ?? "") === String(packaged.raw.inputParametersJson ?? ""),
+                        outputParametersMatch: actual !== undefined && String(actual.outputParametersJson ?? "") === String(packaged.raw.outputParametersJson ?? ""),
+                    };
+                });
+            }
+            catch (error) {
+                throw new ToolRefusalError({
+                    status: "refused",
+                    blocker: "bizservice-import-readback-failed",
+                    message: `导入后读回 ${finalCode} 失败，已完成部分已保留在报告中：${error instanceof Error ? error.message : String(error)}`,
+                    completedServices: services,
+                    failedService: finalCode,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+            services.push(entry);
+        }
+        return {
+            performed: { errcode: performed.errcode, overWrite: args.overWrite, ...(args.overWrite ? { overwriteScope } : {}), ...(args.modifyServiceCodes !== undefined ? { modifyServiceCodes: args.modifyServiceCodes } : {}), ...(args.groupId !== undefined ? { groupId: args.groupId } : {}) },
+            readback: { services },
+        };
+    }, (args) => {
+        // Zero-wire rename lint: the platform checks newCode against
+        // [a-zA-Z][a-zA-Z0-9_]{0,27} (BizServiceIEFacadeImpl.checkSingleCodeLegal,
+        // INVALID_NAME 580001) only AFTER the upload; refuse earlier here.
+        for (const entry of args.modifyServiceCodes ?? [])
+            if (!/^[a-zA-Z][a-zA-Z0-9_]{0,27}$/.test(entry.newServiceCode))
+                throw new ToolRefusalError({ status: "refused", blocker: "bizservice-ie-rename-invalid", message: `newServiceCode "${entry.newServiceCode}" 不匹配平台合法编码 [a-zA-Z][a-zA-Z0-9_]{0,27}（BizServiceIEFacadeImpl.checkSingleCodeLegal，580001）`, newServiceCode: entry.newServiceCode });
+    });
+    // -------------------------------------------------------------------------
+    // Ticket 107 — the designer TEST face
+    // -------------------------------------------------------------------------
+    /** Adapters whose service_test runtimes are source-evidenced (8.6.26). */
+    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"]);
+    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>；按方法声明参数面校验）"),
+    }, async (session, args) => {
+        // Ticket 107 — a REAL one-shot execution of the configured method
+        // (BizServiceMethodController.java:398-412 → BizServiceFacadeImpl:426-464
+        // → the service's ProtocolAdapterRuntimeService). The chain writes NO
+        // config rows (only async integration logs); the readback below proves
+        // the stored method row survived the test untouched.
+        const service = await wireCall(session, { path: ENDPOINTS.bizServiceGetByCode, query: { serviceCode: args.serviceCode } });
+        const serviceRow = service.data;
+        if (serviceRow === null)
+            throw new ToolRefusalError({ status: "refused", blocker: "wire-business", message: `业务服务不存在：${args.serviceCode}`, errcode: 500001 });
+        const adapterCode = adapterCodeOf(serviceRow);
+        if (!TEST_EVIDENCED_ADAPTERS.has(adapterCode))
+            throw new ToolRefusalError({
+                status: "refused",
+                blocker: "bizservice-test-adapter-not-evidenced",
+                message: `适配器 ${adapterCode || "(空)"} 在设计器测试面（service_test）无运行时证据（8.6.26 已取证：RESTFUL/DATA_SQL/DATA_TABLE/SOAP/INTERNAL）——不猜不伪造，拒绝试跑，零 service_test 调用`,
+                adapterCode,
+            });
+        const rows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data);
+        const method = rows.find((row) => row.code === args.methodCode);
+        if (!method)
+            throw new ToolRefusalError({ status: "refused", blocker: "wire-business", message: `业务方法不存在：${args.serviceCode}/${args.methodCode}`, errcode: 500001 });
+        // Registration-shell boundary: a method with no stored config on a
+        // config-carrying adapter has nothing executable to test.
+        if (TEST_CONFIG_REQUIRED_ADAPTERS.has(adapterCode) && (method.configJson === null || method.configJson === undefined || method.configJson === ""))
+            throw new ToolRefusalError({ status: "refused", blocker: "bizservice-test-shell", message: `方法 ${args.methodCode} 是注册壳（无 configJson）——不是可执行 BizMethod，试跑拒绝，零 service_test 调用`, methodCode: args.methodCode });
+        // Parameter-face gate (fail closed, zero service_test wire on violation):
+        // every declared required input must be supplied; unknown keys are
+        // refused instead of guessed onto the wire.
+        const face = parseDeclaredParameterCodes(method.inputParametersJson);
+        const supplied = Object.keys(args.testInputParametersMap);
+        const missing = face.required.filter((code) => !(code in args.testInputParametersMap));
+        if (missing.length > 0)
+            throw new ToolRefusalError({ status: "refused", blocker: "bizservice-test-param-missing", message: `试跑缺必填入参：${missing.join("、")}（按方法声明参数面 fail-closed，零试跑调用）`, missing });
+        const unknown = supplied.filter((code) => !face.all.includes(code));
+        if (unknown.length > 0)
+            throw new ToolRefusalError({ status: "refused", blocker: "bizservice-test-param-unknown", message: `试跑携带未声明参数：${unknown.join("、")}（方法参数面只有 ${face.all.join("、") || "(空)"}；不猜不透传，零试跑调用）`, unknown });
+        const performed = await wireCall(session, {
+            path: ENDPOINTS.bizServiceMethodTest,
+            method: "POST",
+            body: { serviceCode: args.serviceCode, code: args.methodCode, testInputParametersMap: args.testInputParametersMap },
+        });
+        // Zero-config-write proof: re-read the method row and compare the
+        // stored configJson verbatim.
+        const afterRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data);
+        const after = afterRows.find((row) => row.code === args.methodCode);
+        const configUnchanged = after !== undefined && String(after.configJson ?? "") === String(method.configJson ?? "");
+        // The platform test answer nests its own success flag
+        // (`{result:{success:false,msg:"..."}}`) while the outer envelope is
+        // errcode 0 — so a business-level test FAILURE would otherwise read as
+        // `ok:true`. Surface it as a first-class `externalSuccess` field (dogfood
+        // R3) so "the call completed" is never confused with "the endpoint
+        // answered successfully". The outer status stays `ok` because the test
+        // itself did run; the field carries the external verdict.
+        const external = (performed.data ?? {});
+        // The platform answers `{success,msg,data}` where `data` is the adapter's
+        // own result. For a same-instance RESTFUL call the HTTP layer can be a
+        // 200 while the target answered a CloudPivot error envelope
+        // (`{errcode:50000,errmsg:"..."}`) — e.g. `corpId can not be blank`. The
+        // platform still sets `success:true` (the call was made), so a business
+        // failure would otherwise read as externalSuccess:true. Surface the
+        // nested business errcode and fold it into the verdict (dogfood round20).
+        const body = external.data;
+        const isEnvelope = body !== null && typeof body === "object" && !Array.isArray(body) && typeof body.errcode === "number";
+        const resultBodyErrcode = isEnvelope ? body.errcode : undefined;
+        const businessOk = resultBodyErrcode === undefined || resultBodyErrcode === 0;
+        const externalSuccess = external.success === true && businessOk;
+        const externalFailure = externalSuccess
+            ? {}
+            : {
+                ...(typeof external.msg === "string" && external.msg ? { msg: external.msg } : {}),
+                ...(resultBodyErrcode === undefined ? {} : { resultBodyErrcode }),
+                ...(isEnvelope && typeof body.errmsg === "string" ? { resultBodyMsg: body.errmsg } : {}),
+                note: businessOk
+                    ? "外层 status:ok 只表示试跑调用完成；被测接口本身失败（externalSuccess:false）——按 message/result 诊断外部资源，不要当作方法可用"
+                    : `外层 status:ok 只表示试跑调用完成；被测接口本身回了业务错误 errcode=${resultBodyErrcode}（如同实例自调缺 X-LowCode-Corpid 头会回 50000 corpId can not be blank）——按 errmsg/result 诊断，不要当作方法可用`,
+            };
+        return {
+            performed: { errcode: performed.errcode, adapterCode, ...(adapterCode === "RESTFUL" || adapterCode === "DATA_SQL" || adapterCode === "DATA_TABLE" ? { externalSideEffect: "real" } : {}) },
+            readback: {
+                result: performed.data,
+                configUnchanged,
+                externalSuccess,
+                ...(resultBodyErrcode === undefined ? {} : { resultBodyErrcode }),
+                ...(externalSuccess ? {} : { externalFailure }),
+            },
+        };
+    });
+}
+//# sourceMappingURL=b2-registration.js.map