@stalfh233/omc-cli 0.6.6 → 0.6.10

package/dist/lanes/rule-lifecycle.js

@@ -103,6 +103,9 @@ export async function executeRuleEnableWrite(session, args) {
     if (!full)
         throw new WireError("business", `rule ${args.ruleCode} 完整模型读回为空（businessrule/get id ${row.id}），拒绝用列表投影发布`, 302024);
     let published;
+    // 8.1 族走 `businessrule/update` 下探时，平台**没有** DRAFT/PUBLISH 两面
+    // （没有 publish 端点就没有双面模型），下面的 DRAFT 交叉校验对它不适用。
+    let publishEndpointAbsent = false;
     try {
         published = await wireCall(session, { path: ENDPOINTS.businessRulePublish, method: "POST", body: { ...full, enabled: true, status: "ENABLED" } });
     }
@@ -123,7 +126,7 @@ export async function executeRuleEnableWrite(session, args) {
         // `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;
+        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" } });
@@ -144,160 +147,311 @@ export async function executeRuleEnableWrite(session, args) {
     const after = wireRows(readback.data).find((item) => item.code === args.ruleCode);
     if (after?.enabled !== true)
         throw new ToolRefusalError({ status: "refused", blocker: "rule-enable-readback-failed", message: `rule ${args.ruleCode} 发布后未启用；enabled 必须为 true` });
-    return { performed: { errcode: published.errcode, enableErrcode, ...(alreadyEnabled ? { alreadyEnabled: true } : {}) }, readback: { enabled: true } };
+    // r28g F23/F27：list.enabled 是 PUBLISH 投影，运行时读 DRAFT。交叉读 get，
+    // 把 DRAFT 的 enabled 钉进 readback。硬门槛只认 draft.enabled===true（list
+    // 已闸过）；status 列可能滞后（平台 quirk / fake 复现），标 statusLag 而不
+    // 因此 fail closed——否则会把「enabled 已翻、status 还 DISABLED」的合法态拒掉。
+    const draft = publishEndpointAbsent
+        ? null
+        : (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id: String(row.id) } })).data;
+    const draftEnabled = draft === null ? null : draft.enabled === true;
+    const draftStatus = draft?.status == null ? null : String(draft.status);
+    // draftEnabled === null 表示"本版本族没有 DRAFT 面"（8.1 下探路径）——
+    // 此时以 list（唯一的面）为准，不做 DRAFT 闸。
+    if (draftEnabled === false) {
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "rule-enable-not-effective",
+            schemaCode: args.schemaCode,
+            ruleCode: args.ruleCode,
+            message: `rule.enable 后 list 报 enabled=true，但 DRAFT 行仍 enabled=false（status=${draftStatus ?? "null"}）。运行时 getExecutableBySchemaCodeAndCode 读的是 DRAFT；请重试 rule.enable，或 rule.get 核对后再 rule.run。`,
+            readback: { listEnabled: true, draftEnabled: false, draftStatus, executable: false },
+        });
+    }
+    const statusLag = draftStatus !== null && draftStatus !== "ENABLED";
+    return {
+        performed: { errcode: published.errcode, enableErrcode, ...(alreadyEnabled ? { alreadyEnabled: true } : {}) },
+        readback: {
+            enabled: true,
+            listEnabled: after?.enabled === true,
+            listStatus: after?.status ?? null,
+            draftEnabled,
+            draftStatus,
+            executable: true,
+            verified: true,
+            ...(statusLag ? { statusLag: true, statusNote: "DRAFT status 列仍非 ENABLED（平台滞后常见）；enabled=true 才是分发真相" } : {}),
+            source: "draft-get+list",
+            effectHint: "executable/verified 以 DRAFT get.enabled 为准；listEnabled 来自 PUBLISH 投影。rule.run 前若仍拒，再 rule.get 看 draftStatus",
+        },
+    };
 }
 export function registerRuleLifecycleLane(tools) {
-    writeTool(tools, "rule.enable", RULE_LIFECYCLE_LANE, RULE_LIFECYCLE_TOOLS["rule.enable"].scope, RULE_LIFECYCLE_TOOLS["rule.enable"].description, { schemaCode: z.string().min(1), ruleCode: z.string().min(1) }, async (session, args) => executeRuleEnableWrite(session, args), undefined, undefined, lifecycleRollbackSpec("rule.enable"));
-    writeTool(tools, "rule.disable", RULE_LIFECYCLE_LANE, RULE_LIFECYCLE_TOOLS["rule.disable"].scope, RULE_LIFECYCLE_TOOLS["rule.disable"].description, { schemaCode: z.string().min(1), ruleCode: z.string().min(1) }, async (session, args) => {
-        await assertRuleSchemaExists(session, args.schemaCode);
-        const list = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
-        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);
-        // 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 } };
-    }, undefined, undefined, lifecycleRollbackSpec("rule.disable"));
-    writeTool(tools, "rule.delete", RULE_LIFECYCLE_LANE, RULE_LIFECYCLE_TOOLS["rule.delete"].scope, RULE_LIFECYCLE_TOOLS["rule.delete"].description, { schemaCode: z.string().min(1), ruleCode: z.string().min(1) }, async (session, args) => {
-        // Ticket 96 finding: the preset rule codes are platform-managed —
-        // listViewsBySchemaCode re-fills any missing preset for the schema, so
-        // deleting one via the API is unreachable (it resurrects on the next
-        // list). Refuse up front instead of "succeeding" and multiplying rows.
-        if (PLATFORM_TRIGGER_RULE_CODES.has(args.ruleCode))
-            throw new ToolRefusalError({
-                status: "refused",
-                blocker: "rule-preset-delete-unreachable",
-                message: `ruleCode "${args.ruleCode}" 是平台预置触发规则——list_by_schemacode 会自动重灌缺失预置（BusinessRuleFacadeImpl.listViewsBySchemaCode:179-185），API 删除不可达且会增殖版本行；预置规则请用 rule.save 覆盖图或 rule.disable 停用`,
+    writeTool({
+        tools,
+        name: "rule.enable",
+        lane: RULE_LIFECYCLE_LANE,
+        scope: RULE_LIFECYCLE_TOOLS["rule.enable"].scope,
+        description: RULE_LIFECYCLE_TOOLS["rule.enable"].description,
+        inputSchema: { schemaCode: z.string().min(1), ruleCode: z.string().min(1) },
+        execute: async (session, args) => executeRuleEnableWrite(session, args),
+        rollback: lifecycleRollbackSpec("rule.enable"),
+    });
+    writeTool({
+        tools,
+        name: "rule.disable",
+        lane: RULE_LIFECYCLE_LANE,
+        scope: RULE_LIFECYCLE_TOOLS["rule.disable"].scope,
+        description: RULE_LIFECYCLE_TOOLS["rule.disable"].description,
+        inputSchema: { schemaCode: z.string().min(1), ruleCode: z.string().min(1) },
+        execute: async (session, args) => {
+            await assertRuleSchemaExists(session, args.schemaCode);
+            const list = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
+            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);
+            // r28g F22/F24 真机（1.1.25，2026-11-05）：`businessrule/disable` 只把 DRAFT
+            // 行的 status 置 DISABLED，**不翻 enabled**——随后 list 仍报 enabled:true/
+            // ENABLED，get 报 enabled:true+ruleStatus:DISABLED+statusLag，enable 误报
+            // alreadyEnabled，run 仍放行。`rule.disableMany` 走 update 写
+            // `{enabled:false,status:DISABLED}` 才是真停用（stillEnabled:[] + get.enabled=false）。
+            // 契约本来就钉 `businessrule/update`；这里与 disableMany 对齐。残缺 list
+            // 投影在 8.1 会 50000 时，改读完整 get 模型再 update（同 enable 路径）。
+            const alreadyDisabled = row.enabled !== true;
+            if (alreadyDisabled) {
+                return {
+                    performed: { errcode: 0, alreadyDisabled: true, noop: true },
+                    readback: { enabled: false, status: row.status ?? null, source: "list", note: "list 行已 enabled=false，未发 wire" },
+                };
+            }
+            // 与 disableMany 同路径：list 投影 + update{enabled:false,status:DISABLED}。
+            // 真机上这条路径会同时翻 PUBLISH/DRAFT；假平台也认 list 投影。
+            // 读回以 list.enabled 为门（disableMany.stillEnabled 同口径）；get 作补充，
+            // 若 get 仍滞后只标 statusLag，不因 get 单独 fail closed。
+            const performed = await wireCall(session, {
+                path: ENDPOINTS.businessRuleUpdate,
+                method: "POST",
+                body: { ...row, enabled: false, status: "DISABLED" },
             });
-        await assertRuleSchemaExists(session, args.schemaCode);
-        const list = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
-        const row = wireRows(list.data).find((item) => item.code === args.ruleCode);
-        if (!row?.id)
-            throw new WireError("business", `rule ${args.ruleCode} not found for delete`, 302024);
-        const performed = await wireCall(session, { path: ENDPOINTS.businessRuleDelete, method: "POST", query: { id: String(row.id) } });
-        const readback = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
-        return { performed: { errcode: performed.errcode }, readback: { absent: !wireRows(readback.data).some((item) => item.code === args.ruleCode) } };
-    }, undefined, undefined, lifecycleRollbackSpec("rule.delete"));
+            const afterList = wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } })).data).find((item) => item.code === args.ruleCode);
+            const listEnabled = afterList?.enabled === true;
+            if (listEnabled) {
+                throw new ToolRefusalError({
+                    status: "refused",
+                    blocker: "rule-disable-not-effective",
+                    schemaCode: args.schemaCode,
+                    ruleCode: args.ruleCode,
+                    message: `rule.disable 已发 businessrule/update(enabled:false)，但 list 仍 enabled=true；不要信任 summary。可改试 rule.disableMany {schemaCode, ruleCodes:[${JSON.stringify(args.ruleCode)}]}`,
+                    readback: { enabled: true, listEnabled: true, listStatus: afterList?.status ?? null },
+                });
+            }
+            let draftEnabled = null;
+            let draftStatus = null;
+            try {
+                const afterGet = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id: String(row.id) } })).data;
+                if (afterGet) {
+                    draftEnabled = afterGet.enabled === true;
+                    draftStatus = afterGet.status == null ? null : String(afterGet.status);
+                }
+            }
+            catch {
+                // list 已证明停用；get 失败不挡
+            }
+            return {
+                performed: { errcode: performed.errcode },
+                readback: {
+                    enabled: false,
+                    listEnabled: false,
+                    listStatus: afterList?.status ?? null,
+                    ...(draftEnabled !== null ? { draftEnabled, draftStatus } : {}),
+                    ...(draftEnabled === true ? { statusLag: true, statusNote: "list.enabled=false 已生效；DRAFT get.enabled 仍 true（面滞后）——以 list / 本 readback.enabled 为准" } : {}),
+                    source: "list",
+                    effectHint: "停用读回以本 readback.enabled（list 面，与 disableMany 同口径）为准；rule.get 可作交叉核对",
+                },
+            };
+        },
+        rollback: lifecycleRollbackSpec("rule.disable"),
+    });
+    writeTool({
+        tools,
+        name: "rule.delete",
+        lane: RULE_LIFECYCLE_LANE,
+        scope: RULE_LIFECYCLE_TOOLS["rule.delete"].scope,
+        description: RULE_LIFECYCLE_TOOLS["rule.delete"].description,
+        inputSchema: { schemaCode: z.string().min(1), ruleCode: z.string().min(1) },
+        execute: async (session, args) => {
+            // Ticket 96 finding: the preset rule codes are platform-managed —
+            // listViewsBySchemaCode re-fills any missing preset for the schema, so
+            // deleting one via the API is unreachable (it resurrects on the next
+            // list). Refuse up front instead of "succeeding" and multiplying rows.
+            if (PLATFORM_TRIGGER_RULE_CODES.has(args.ruleCode))
+                throw new ToolRefusalError({
+                    status: "refused",
+                    blocker: "rule-preset-delete-unreachable",
+                    message: `ruleCode "${args.ruleCode}" 是平台预置触发规则——list_by_schemacode 会自动重灌缺失预置（BusinessRuleFacadeImpl.listViewsBySchemaCode:179-185），API 删除不可达且会增殖版本行；预置规则请用 rule.save 覆盖图或 rule.disable 停用`,
+                });
+            await assertRuleSchemaExists(session, args.schemaCode);
+            const list = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
+            const row = wireRows(list.data).find((item) => item.code === args.ruleCode);
+            if (!row?.id)
+                throw new WireError("business", `rule ${args.ruleCode} not found for delete`, 302024);
+            const performed = await wireCall(session, { path: ENDPOINTS.businessRuleDelete, method: "POST", query: { id: String(row.id) } });
+            const readback = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
+            return { performed: { errcode: performed.errcode }, readback: { absent: !wireRows(readback.data).some((item) => item.code === args.ruleCode) } };
+        },
+        rollback: lifecycleRollbackSpec("rule.delete"),
+    });
     // Round 10 issue 05 — lifecycle batch. Disabling a model's rules one by one was
     // N calls; this flips `enabled:false` on every matching rule in one tool. Only
     // CUSTOM rules by default (platform preset trigger rows must not be disabled —
     // they are platform-managed); `includePresets:true` opts in explicitly.
-    writeTool(tools, "rule.run", RULE_LIFECYCLE_LANE, RULE_LIFECYCLE_TOOLS["rule.run"].scope, RULE_LIFECYCLE_TOOLS["rule.run"].description, {
-        schemaCode: z.string().min(1),
-        ruleCode: z.string().min(1),
-        ids: z.array(z.string().min(1)).min(1).describe("要执行的业务数据 id（data.load/data.list 的 bizObjectId / row.bizObjectId）——就是平台按钮点击时提交的 ids"),
-        consolidation: z.boolean().optional().describe("平台 body 字段，默认 false（按钮点击抓包值）；合并执行场景才传 true"),
-    }, async (session, args) => {
-        await assertRuleSchemaExists(session, args.schemaCode);
-        const ids = [...new Set(args.ids.map(String))];
-        if (ids.length !== args.ids.length)
-            throw new ToolRefusalError({ status: "refused", blocker: "rule-run-ids-duplicated", message: "ids 有重复项——按去重后的列表执行，别让同一行在一条规则里被执行两次" });
-        const list = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
-        const row = wireRows(list.data).find((item) => String(item.code) === args.ruleCode);
-        if (!row)
-            throw new ToolRefusalError({ status: "refused", blocker: "rule-run-rule-absent", schemaCode: args.schemaCode, ruleCode: args.ruleCode, message: `模型 ${args.schemaCode} 没有规则 ${args.ruleCode}——先 rule.list 核对 code` });
-        if (row.defaultRule === true || PLATFORM_TRIGGER_RULE_CODES.has(args.ruleCode))
-            throw new ToolRefusalError({
-                status: "refused",
-                blocker: "rule-run-preset-rule",
-                ruleCode: args.ruleCode,
-                message: `${args.ruleCode} 是平台预置触发规则（defaultRule:true）——它由数据事件（新增/更新/删除/流程生效…）自动分发，设计器的按钮规则选择器不提供预置行。要手动跑请新建自定义规则（CUSTOM_NODE 触发）再用 button/rule.run`,
-            });
-        if (row.enabled !== true)
-            throw new ToolRefusalError({
-                status: "refused",
-                blocker: "rule-run-disabled",
-                ruleCode: args.ruleCode,
-                message: `规则 ${args.ruleCode} 当前未启用（enabled=${String(row.enabled)}）——先 rule.enable（publish+enable 两步），否则设计器显示「失效·未启用」且按钮不会执行它`,
-            });
-        let performed;
-        try {
-            performed = await wireCall(session, {
-                path: ruleRuntimeExecutePath(args.schemaCode, args.ruleCode),
-                method: "POST",
-                body: { schemaCode: args.schemaCode, ids, ruleCode: args.ruleCode, consolidation: args.consolidation === true },
-            });
-        }
-        catch (error) {
-            // 550001 业务规则不存在 on the launcher runtime path means the rule was
-            // not REGISTERED as a custom trigger (r15: a data-event graph saved with
-            // customTrigger:true still 550001s). Name the semantic instead of
-            // forwarding a bare platform code.
-            if (error instanceof WireError && error.kind === "business" && error.errcode === 550001)
+    writeTool({
+        tools,
+        name: "rule.run",
+        lane: RULE_LIFECYCLE_LANE,
+        scope: RULE_LIFECYCLE_TOOLS["rule.run"].scope,
+        description: RULE_LIFECYCLE_TOOLS["rule.run"].description,
+        inputSchema: {
+            schemaCode: z.string().min(1),
+            ruleCode: z.string().min(1),
+            ids: z.array(z.string().min(1)).min(1).describe("要执行的业务数据 id（data.load/data.list 的 bizObjectId / row.bizObjectId）——就是平台按钮点击时提交的 ids"),
+            consolidation: z.boolean().optional().describe("平台 body 字段，默认 false（按钮点击抓包值）；合并执行场景才传 true"),
+        },
+        execute: async (session, args) => {
+            await assertRuleSchemaExists(session, args.schemaCode);
+            const ids = [...new Set(args.ids.map(String))];
+            if (ids.length !== args.ids.length)
+                throw new ToolRefusalError({ status: "refused", blocker: "rule-run-ids-duplicated", message: "ids 有重复项——按去重后的列表执行，别让同一行在一条规则里被执行两次" });
+            const list = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
+            const row = wireRows(list.data).find((item) => String(item.code) === args.ruleCode);
+            if (!row)
+                throw new ToolRefusalError({ status: "refused", blocker: "rule-run-rule-absent", schemaCode: args.schemaCode, ruleCode: args.ruleCode, message: `模型 ${args.schemaCode} 没有规则 ${args.ruleCode}——先 rule.list 核对 code` });
+            if (row.defaultRule === true || PLATFORM_TRIGGER_RULE_CODES.has(args.ruleCode))
                 throw new ToolRefusalError({
                     status: "refused",
-                    blocker: "rule-not-executable",
-                    schemaCode: args.schemaCode,
+                    blocker: "rule-run-preset-rule",
                     ruleCode: args.ruleCode,
-                    nextCommand: `omc call rule.enable --args '${JSON.stringify({ schemaCode: args.schemaCode, ruleCode: args.ruleCode })}'`,
-                    message: `550001「业务规则不存在」在这里的真实含义是「该规则当前不可执行」，不是规则不存在，也不是「只认 CUSTOM_NODE」。` +
-                        `反编译 8.6.26 的 BusinessRuleTableImpl#getExecutableBySchemaCodeAndCode 是唯一判定：` +
-                        `① **DRAFT 行**必须存在；② DRAFT 行 enabled=true **且** status != DISABLED；③ 至少一条 PUBLISH 版本。` +
-                        `rule.save --publish 只写 PUBLISH 行，**DRAFT 行的 status 仍是 DISABLED**——所以发布完直接 rule.run 必然 550001。` +
-                        `修法：rule.enable（它先 publish 再调平台 /enable，把 DRAFT 行 status 置 ENABLED）。` +
-                        `注意 rule.list 显示的是 PUBLISH 行的 enabled/status，看起来"已启用"但运行期读的是 DRAFT 行——不要用 list 判定可执行性。`,
+                    message: `${args.ruleCode} 是平台预置触发规则（defaultRule:true）——它由数据事件（新增/更新/删除/流程生效…）自动分发，设计器的按钮规则选择器不提供预置行。要手动跑请新建自定义规则（CUSTOM_NODE 触发）再用 button/rule.run`,
                 });
-            throw error;
-        }
-        const payload = (performed.data ?? null);
-        const objects = Array.isArray(payload) ? payload : [];
-        return {
-            performed: { errcode: performed.errcode, ruleCode: args.ruleCode, ids },
-            readback: {
-                schemaCode: args.schemaCode,
-                ruleCode: args.ruleCode,
-                executedIds: ids,
-                returnedObjects: objects.length,
-                // 302045 = 数据被占用（前端把同样的码映射成"有人正在编辑"）。
-                ...(performed.errcode === 302045
-                    ? { dataInUse: true, hint: "302045：数据被占用（有人正在编辑该行 / 行锁未释放），稍后重试" }
-                    : {}),
-                effectHint: "平台只回执行结果信封；返回的 data 是执行前快照（reacquireDataFromDb:false）。规则副作用必须另行读回：data.load {schemaCode, bizObjectId} 或 data.list（data.list 默认不含 DRAFT，草稿行请用 data.load）",
-                // NOT latestPublished: the platform's list projection reports
-                // latestPublished:false even for rows it executes fine (live
-                // 2026-10-23, documented in rule-support.ts) — a warning here would be
-                // noise. Liveness is `enabled`, which is gated above.
-            },
-        };
-    }, undefined, undefined, undefined);
-    writeTool(tools, "rule.disableMany", RULE_LIFECYCLE_LANE, RULE_LIFECYCLE_TOOLS["rule.disableMany"].scope, RULE_LIFECYCLE_TOOLS["rule.disableMany"].description, {
-        schemaCode: z.string().min(1),
-        ruleCodes: z.array(z.string().min(1)).optional().describe("只停用这些 code；省略=该模型全部规则"),
-        customOnly: z.boolean().optional().describe("默认 false：停用全部匹配规则（含平台预置触发码 Create/Update/…，因为用户逻辑常写在其中）；true 只停用自定义规则、跳过预置。"),
-    }, async (session, args) => {
-        await assertRuleSchemaExists(session, args.schemaCode);
-        const list = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
-        const wanted = args.ruleCodes ? new Set(args.ruleCodes) : undefined;
-        const targets = wireRows(list.data).filter((row) => {
-            const code = String(row.code ?? "");
-            if (wanted && !wanted.has(code))
-                return false;
-            // NOTE: presets are INCLUDED by default — user logic is frequently
-            // authored INTO preset trigger rows (Create/Update/…), so skipping them
-            // would silently leave the user's rules enabled. customOnly:true opts out.
-            if (args.customOnly === true && PLATFORM_TRIGGER_RULE_CODES.has(code))
-                return false;
-            return true;
-        });
-        const disabled = [];
-        const skipped = [];
-        for (const row of targets) {
-            const code = String(row.code ?? "");
+            // r28g F27：list.enabled 是 PUBLISH 投影；运行时门禁读 DRAFT.enabled。
+            // status 列可滞后（enable 后仍 DISABLED），不单独据此拒绝——与 rule.get
+            // 的 statusLag 注释一致。只看 list 会在 disable 半生效时假通过。
+            let draftEnabled = row.enabled === true;
+            let draftStatus = row.status == null ? null : String(row.status);
+            if (row.id) {
+                try {
+                    const draft = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id: String(row.id) } })).data;
+                    if (draft) {
+                        draftEnabled = draft.enabled === true;
+                        draftStatus = draft.status == null ? null : String(draft.status);
+                    }
+                }
+                catch {
+                    // fall back to list projection
+                }
+            }
+            if (!draftEnabled)
+                throw new ToolRefusalError({
+                    status: "refused",
+                    blocker: "rule-run-disabled",
+                    ruleCode: args.ruleCode,
+                    listEnabled: row.enabled === true,
+                    draftEnabled,
+                    draftStatus,
+                    message: `规则 ${args.ruleCode} 当前未启用（DRAFT enabled=false, status=${draftStatus ?? "null"}；list.enabled=${String(row.enabled)}）——先 rule.enable（publish+enable 两步），否则设计器显示「失效·未启用」且按钮不会执行它`,
+                });
+            let performed;
             try {
-                await wireCall(session, { path: ENDPOINTS.businessRuleUpdate, method: "POST", body: { ...row, enabled: false, status: "DISABLED" } });
-                disabled.push(code);
+                performed = await wireCall(session, {
+                    path: ruleRuntimeExecutePath(args.schemaCode, args.ruleCode),
+                    method: "POST",
+                    body: { schemaCode: args.schemaCode, ids, ruleCode: args.ruleCode, consolidation: args.consolidation === true },
+                });
             }
             catch (error) {
-                skipped.push({ ruleCode: code, reason: error instanceof Error ? error.message : String(error) });
+                // 550001 业务规则不存在 on the launcher runtime path means the rule was
+                // not REGISTERED as a custom trigger (r15: a data-event graph saved with
+                // customTrigger:true still 550001s). Name the semantic instead of
+                // forwarding a bare platform code.
+                if (error instanceof WireError && error.kind === "business" && error.errcode === 550001)
+                    throw new ToolRefusalError({
+                        status: "refused",
+                        blocker: "rule-not-executable",
+                        schemaCode: args.schemaCode,
+                        ruleCode: args.ruleCode,
+                        nextCommand: `omc call rule.enable --args '${JSON.stringify({ schemaCode: args.schemaCode, ruleCode: args.ruleCode })}'`,
+                        message: `550001「业务规则不存在」在这里的真实含义是「该规则当前不可执行」，不是规则不存在，也不是「只认 CUSTOM_NODE」。` +
+                            `反编译 8.6.26 的 BusinessRuleTableImpl#getExecutableBySchemaCodeAndCode 是唯一判定：` +
+                            `① **DRAFT 行**必须存在；② DRAFT 行 enabled=true **且** status != DISABLED；③ 至少一条 PUBLISH 版本。` +
+                            `rule.save --publish 只写 PUBLISH 行，**DRAFT 行的 status 仍是 DISABLED**——所以发布完直接 rule.run 必然 550001。` +
+                            `修法：rule.enable（它先 publish 再调平台 /enable，把 DRAFT 行 status 置 ENABLED）。` +
+                            `注意 rule.list 显示的是 PUBLISH 行的 enabled/status，看起来"已启用"但运行期读的是 DRAFT 行——不要用 list 判定可执行性。`,
+                    });
+                throw error;
             }
-        }
-        const after = wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } })).data);
-        const stillEnabled = after.filter((row) => row.enabled === true && disabled.includes(String(row.code ?? ""))).map((row) => String(row.code));
-        return { performed: { disabled }, readback: { disabledCount: disabled.length, disabled, skipped, stillEnabled } };
+            const payload = (performed.data ?? null);
+            const objects = Array.isArray(payload) ? payload : [];
+            return {
+                performed: { errcode: performed.errcode, ruleCode: args.ruleCode, ids },
+                readback: {
+                    schemaCode: args.schemaCode,
+                    ruleCode: args.ruleCode,
+                    executedIds: ids,
+                    returnedObjects: objects.length,
+                    // 302045 = 数据被占用（前端把同样的码映射成"有人正在编辑"）。
+                    ...(performed.errcode === 302045
+                        ? { dataInUse: true, hint: "302045：数据被占用（有人正在编辑该行 / 行锁未释放），稍后重试" }
+                        : {}),
+                    effectHint: "平台只回执行结果信封；返回的 data 是执行前快照（reacquireDataFromDb:false）。规则副作用必须另行读回：data.load {schemaCode, bizObjectId} 或 data.list（data.list 默认不含 DRAFT，草稿行请用 data.load）",
+                    // NOT latestPublished: the platform's list projection reports
+                    // latestPublished:false even for rows it executes fine (live
+                    // 2026-10-23, documented in rule-support.ts) — a warning here would be
+                    // noise. Liveness is `enabled`, which is gated above.
+                },
+            };
+        },
+    });
+    writeTool({
+        tools,
+        name: "rule.disableMany",
+        lane: RULE_LIFECYCLE_LANE,
+        scope: RULE_LIFECYCLE_TOOLS["rule.disableMany"].scope,
+        description: RULE_LIFECYCLE_TOOLS["rule.disableMany"].description,
+        inputSchema: {
+            schemaCode: z.string().min(1),
+            ruleCodes: z.array(z.string().min(1)).optional().describe("只停用这些 code；省略=该模型全部规则"),
+            customOnly: z.boolean().optional().describe("默认 false：停用全部匹配规则（含平台预置触发码 Create/Update/…，因为用户逻辑常写在其中）；true 只停用自定义规则、跳过预置。"),
+        },
+        execute: async (session, args) => {
+            await assertRuleSchemaExists(session, args.schemaCode);
+            const list = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
+            const wanted = args.ruleCodes ? new Set(args.ruleCodes) : undefined;
+            const targets = wireRows(list.data).filter((row) => {
+                const code = String(row.code ?? "");
+                if (wanted && !wanted.has(code))
+                    return false;
+                // NOTE: presets are INCLUDED by default — user logic is frequently
+                // authored INTO preset trigger rows (Create/Update/…), so skipping them
+                // would silently leave the user's rules enabled. customOnly:true opts out.
+                if (args.customOnly === true && PLATFORM_TRIGGER_RULE_CODES.has(code))
+                    return false;
+                return true;
+            });
+            const disabled = [];
+            const skipped = [];
+            for (const row of targets) {
+                const code = String(row.code ?? "");
+                try {
+                    await wireCall(session, { path: ENDPOINTS.businessRuleUpdate, method: "POST", body: { ...row, enabled: false, status: "DISABLED" } });
+                    disabled.push(code);
+                }
+                catch (error) {
+                    skipped.push({ ruleCode: code, reason: error instanceof Error ? error.message : String(error) });
+                }
+            }
+            const after = wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } })).data);
+            const stillEnabled = after.filter((row) => row.enabled === true && disabled.includes(String(row.code ?? ""))).map((row) => String(row.code));
+            return { performed: { disabled }, readback: { disabledCount: disabled.length, disabled, skipped, stillEnabled } };
+        },
     });
     registerPackageTool(tools, {
         name: "configure_rule",

package/dist/lanes/runtime-data-contract.js

@@ -5,7 +5,7 @@ export { RUNTIME_DATA_WIRE, RUNTIME_QUERY_OPERATORS, ENGINE_OWNED_KEYS, SUBMIT_S
 import { RUNTIME_DATA_WIRE } from "omc-core/wire-facts";
 export function dataListDescription() {
     const wire = RUNTIME_DATA_WIRE;
-    return `按简化过滤 DSL 查询业务对象（runtime/query/list）；DSL 在 CLI 内翻译为平台 queryCondition（${wire.dslShape}），并按发布字段元数据为每个条件注入 propertyType（未知过滤字段将被拒绝，可用 rawCondition 逃生）；响应仅返回选定 fields 与分页元数据；空模型返回空列表；未配列的自定义字段投影为 null——这是显示面缺列配置、不是数据缺失（data.load 有值），显式选列在结果中全为 null 而发布字段元数据显示其存在时，readback 追加 projectionHint（先用 listview.configure 配置该模型的默认视图列，或用 data.load 读单条权威值）。`;
+    return `按简化过滤 DSL 查询业务对象（runtime/query/list）；DSL 在 CLI 内翻译为平台 queryCondition（${wire.dslShape}），并按发布字段元数据为每个条件注入 propertyType（未知过滤字段将被拒绝，可用 rawCondition 逃生）；响应行在 items[]，业务字段在 items[].fields.<code>（不是 rows[]，也不是 item 顶层——--jq 常用 items[].fields.sku）；空模型返回空列表；未配列的自定义字段投影为 null——这是显示面缺列配置、不是数据缺失（data.load 有值），显式选列在结果中全为 null 而发布字段元数据显示其存在时，readback 追加 projectionHint（先用 listview.configure 配置该模型的默认视图列，或用 data.load 读单条权威值）。`;
 }
 export function dataUpdateDescription() {
     const wire = RUNTIME_DATA_WIRE;
@@ -21,7 +21,7 @@ export function dataUpdateDescription() {
 }
 export function dataSaveDescription() {
     const wire = RUNTIME_DATA_WIRE;
-    return describeTool("M2 runtime data write (runtime/form/save) — returns bizObjectId for authoritative readback via data.load.", [
+    return describeTool("默认存草稿（DRAFT，不触发规则）；要提交态用顶层 submit:true 或随后 data.submit；formData.name 会被平台改写为「用户名+模型名+时间」，要控标题请传业务字段。M2 runtime/form/save — returns bizObjectId for authoritative readback via data.load.", [
         `带可选 workflowCode 时按门户暂存形状创建流程草稿：${wire.workflowDraftSave}。`,
         "formData 禁止携带 id（带 id 的就地发起在 8.6.26 无 REST 面，会被拒绝；既有无实例草稿请改用两段式或 data.submit 的 workItemId 审批链）。",
         "关联值形状（live 2026-09-24）：**单选关联（propertyType 9）传 id 字符串或 { id }；传数组会 50000**；多选关联（11）才用数组。**人员/组织（50/51/60/61）传选择对象数组 `[{\"id\":\"<id>\",\"type\":3,\"name\":\"<名>\"}]`——`type` 必填**（BizField.parseFromClient 把 `type` 强转 Integer 并 intValue()，缺 `type` 稳定 50000）；`type` 取 UnitType 索引：用户=3、部门=1。字段 `mappings` 由表单运行时在用户选择时套用，**服务端 data.save 不会自动回填映射目标字段**——API 侧调用需自行写入被映射字段，否则读回为空（不要误判为映射配置失败）。",
@@ -138,8 +138,8 @@ function desc(lead) {
 }
 export function assertRuntimeDataContract() {
     assertLaneContract(RUNTIME_DATA_LANE_CONTRACT);
-    assertDescriptionCarries(RUNTIME_DATA_LANE_CONTRACT, "data.list", ["queryCondition", "propertyType", "rawCondition", "projectionHint", "listview.configure", "data.load"]);
-    assertDescriptionCarries(RUNTIME_DATA_LANE_CONTRACT, "data.save", ["bizObjectId", "sheetCode", "bizsheet/get", "workflowCode", "sequenceStatus", "workItem", "propertyType 9", "50000", "mappings", "rowStatus"]);
+    assertDescriptionCarries(RUNTIME_DATA_LANE_CONTRACT, "data.list", ["queryCondition", "propertyType", "rawCondition", "projectionHint", "listview.configure", "data.load", "items[].fields"]);
+    assertDescriptionCarries(RUNTIME_DATA_LANE_CONTRACT, "data.save", ["bizObjectId", "sheetCode", "bizsheet/get", "workflowCode", "sequenceStatus", "workItem", "propertyType 9", "50000", "mappings", "rowStatus", "DRAFT", "submit:true"]);
     assertDescriptionCarries(RUNTIME_DATA_LANE_CONTRACT, "data.update", ["runtime/form/save", "bizObjectId", "COMPLETED", "304001", "form/load", "rowStatus"]);
     assertDescriptionCarries(RUNTIME_DATA_LANE_CONTRACT, "data.delete", ["absence", "sheetCode"]);
     assertDescriptionCarries(RUNTIME_DATA_LANE_CONTRACT, "data.submit", ["getReplayToken", "replayToken", "bizObjectId", "objectId", "DRAFT", "COMPLETED", "10009", "100005", "NPE", "两段式", "finishStart=FALSE"]);