@stalfh233/omc-cli 0.4.69 → 0.4.71

package/dist/cli.js

@@ -968,12 +968,33 @@ async function main() {
     command.command("setup").option("--list").option("--edit <environment>").option("--remove <environment>").action(async (options) => {
         commandExitCode = await cmdSetup(new ConfigStore(defaultPaths()), [...(options.list ? ["--list"] : []), ...(options.edit ? ["--edit", options.edit] : []), ...(options.remove ? ["--remove", options.remove] : [])]);
     });
-    command.command("env [action]").option("--json").action(async (action, options) => {
+    command.command("env [action] [name]").option("--json").action(async (action, name, options) => {
         // Read-only inventory of configured environment names. r18: the sandbox
         // guessed names instead of listing them; doctor's wording now points here.
         const store = new ConfigStore(defaultPaths());
+        if (action === "allow") {
+            // The only sanctioned way to widen a project's environment scope. The
+            // list stays project-scoped until the operator names the environment —
+            // an agent cannot discover another project's environments from here.
+            const target = name;
+            if (!target) {
+                console.error("用法：omc env allow <环境名>（把该项目需要的另一环境写入 .omc-envs；执行前须向用户报告并取得同意）");
+                commandExitCode = CLI_EXIT_CODES.invalidInput;
+                return;
+            }
+            try {
+                store.allowProjectEnvironment(target);
+                console.error(`已允许本项目使用环境 ${target}（写入 .omc-envs）`);
+                commandExitCode = CLI_EXIT_CODES.ok;
+            }
+            catch (error) {
+                console.error(error.message);
+                commandExitCode = CLI_EXIT_CODES.invalidInput;
+            }
+            return;
+        }
         if (action !== undefined && action !== "list") {
-            console.error("用法：omc env list [--json]");
+            console.error("用法：omc env list [--json] | omc env allow <环境名>");
             commandExitCode = CLI_EXIT_CODES.invalidInput;
             return;
         }

package/dist/config-store.js

@@ -23,6 +23,7 @@ export function defaultPaths(projectDir = process.cwd()) {
         configPath: join(configRoot, "omc.config.json"),
         credentialsPath: join(configRoot, "credentials"),
         projectEnvPath: join(resolve(projectDir), ".omc-env"),
+        projectEnvsPath: join(resolve(projectDir), ".omc-envs"),
     };
 }
 export class ConfigStore {
@@ -124,8 +125,55 @@ export class ConfigStore {
         this.writeConfig({ environments });
         return config;
     }
-    listEnvironments() {
-        return Object.entries(this.readConfig().environments).map(([name, profile]) => ({ name, profile }));
+    /**
+     * Environments visible to THIS project. Project isolation is the default:
+     * the caller only ever sees the project's own environments, never the rest of
+     * the machine's config (a co-located project's baseUrl/credentials are its
+     * own business). `all:true` is for the operator-facing setup command, which
+     * must explicitly ask before revealing another project's environment.
+     */
+    listEnvironments(options = {}) {
+        const all = Object.entries(this.readConfig().environments).map(([name, profile]) => ({ name, profile }));
+        if (options.all === true)
+            return all;
+        const own = new Set(this.ownEnvironmentNames());
+        return all.filter((entry) => own.has(entry.name));
+    }
+    /** Names declared by this project: `.omc-envs` lines + the `.omc-env` binding. */
+    ownEnvironmentNames() {
+        const names = new Set(this.readProjectEnvsFile());
+        const bound = this.readProjectEnvBinding();
+        if (bound)
+            names.add(bound);
+        if (names.size === 0) {
+            const configured = this.listEnvironments({ all: true });
+            const fallback = configured.find((entry) => entry.profile.isDefault) ?? (configured.length === 1 ? configured[0] : undefined);
+            if (fallback)
+                names.add(fallback.name);
+        }
+        return [...names];
+    }
+    readProjectEnvBinding() {
+        if (!existsSync(this.paths.projectEnvPath))
+            return undefined;
+        const name = readFileSync(this.paths.projectEnvPath, "utf8").trim();
+        return name || undefined;
+    }
+    readProjectEnvsFile() {
+        if (!existsSync(this.paths.projectEnvsPath))
+            return [];
+        return readFileSync(this.paths.projectEnvsPath, "utf8")
+            .split(/\r?\n/u)
+            .map((line) => line.replace(/#.*$/u, "").trim())
+            .filter((line) => line !== "");
+    }
+    /** Declare another environment as usable by this project (cross-env approval). */
+    allowProjectEnvironment(name) {
+        if (!this.readConfig().environments[name]) {
+            throw new ConfigurationError(`unknown environment "${name}"; available: ${this.availableEnvironmentNames()}`);
+        }
+        const names = [...new Set([...this.readProjectEnvsFile(), name])].sort();
+        this.atomicWrite(this.paths.projectEnvsPath, names.join("\n") + "\n", 0o644);
     }
     readCredential(name) {
         const inline = process.env.OMC_CLOUDPIVOT_CREDENTIAL;
@@ -161,20 +209,25 @@ export class ConfigStore {
     }
     /** Available environment names, for error messages — stops agents guessing or spelunking ~/.config. */
     availableEnvironmentNames() {
-        return Object.keys(this.readConfig().environments).join("、") || "(none configured; run omc setup)";
+        return this.ownEnvironmentNames().join("、") || "(none configured for this project; run omc setup)";
     }
     /** Resolve the active environment for a call. */
     resolveEnvironment(explicit) {
+        const resolved = this.resolveCandidate(explicit);
+        this.assertProjectScope(resolved.name, resolved.source);
+        return resolved;
+    }
+    resolveCandidate(explicit) {
         if (explicit && explicit.trim()) {
             const profile = this.readConfig().environments[explicit];
             if (!profile)
-                throw new ConfigurationError(`unknown environment "${explicit}"; available: ${this.availableEnvironmentNames()} (doctor prints the bound 环境=; do not guess or read ~/.config/omc manually)`);
+                throw new ConfigurationError(`unknown environment "${explicit}"; available: ${this.availableEnvironmentNames()}（仅本项目；doctor prints the bound 环境=; do not guess or read ~/.config/omc manually)`);
             return { name: explicit, profile, source: "explicit" };
         }
         if (process.env.OMC_ENV) {
             const profile = this.readConfig().environments[process.env.OMC_ENV];
             if (!profile)
-                throw new ConfigurationError(`OMC_ENV=${process.env.OMC_ENV} is not configured; available: ${this.availableEnvironmentNames()}`);
+                throw new ConfigurationError(`OMC_ENV=${process.env.OMC_ENV} is not configured; available: ${this.availableEnvironmentNames()}（仅本项目）`);
             return { name: process.env.OMC_ENV, profile, source: "OMC_ENV" };
         }
         if (existsSync(this.paths.projectEnvPath)) {
@@ -182,15 +235,36 @@ export class ConfigStore {
             if (name) {
                 const profile = this.readConfig().environments[name];
                 if (!profile)
-                    throw new ConfigurationError(`project .omc-env binds "${name}" which is not configured in omc.config.json; available: ${this.availableEnvironmentNames()} (run omc setup)`);
+                    throw new ConfigurationError(`project .omc-env binds "${name}" which is not configured in omc.config.json; available: ${this.availableEnvironmentNames()}（仅本项目；run omc setup）`);
                 return { name, profile, source: ".omc-env" };
             }
         }
-        const entry = this.listEnvironments().find((item) => item.profile.isDefault);
+        const configured = this.listEnvironments({ all: true });
+        const entry = configured.find((item) => item.profile.isDefault) ?? (configured.length === 1 ? configured[0] : undefined);
         if (!entry)
             throw new ConfigurationError("no default environment; run omc setup or pass environment explicitly");
         return { name: entry.name, profile: entry.profile, source: "default" };
     }
+    /**
+     * Project isolation gate. A directory may hold several environments, but only
+     * those it declares (`.omc-envs` + `.omc-env`). Touching any other environment
+     * is a cross-project read: refuse BEFORE credentials/token/network, and tell
+     * the caller to obtain the user's approval. `OMC_ALLOW_CROSS_ENV=1` is the
+     * human-approved one-off escape hatch and announces itself on stderr.
+     */
+    assertProjectScope(name, source) {
+        const own = this.ownEnvironmentNames();
+        if (own.includes(name))
+            return;
+        if (process.env.OMC_ALLOW_CROSS_ENV === "1") {
+            console.error(`cross-env: 环境 "${name}" 不在本项目允许列表（${own.join("、") || "空"}）；已按 OMC_ALLOW_CROSS_ENV=1 放行本次访问。请确认这是用户批准的临时跨环境操作。`);
+            return;
+        }
+        throw new ConfigurationError(`跨环境访问被拒绝：环境 "${name}" 不属于本项目（本项目允许：${own.join("、") || "(none)"}）。` +
+            `每个项目目录只能使用自己声明的环境，不允许读取其他环境的信息。` +
+            `如确需跨环境，先向用户报告并取得同意，再由用户执行 \`omc env allow ${name}\`（写入项目 .omc-envs），` +
+            `或临时设置 OMC_ALLOW_CROSS_ENV=1 单次放行。`);
+    }
     bindProjectEnvironment(name) {
         const config = this.readConfig();
         if (!config.environments[name])

package/dist/endpoints.js

@@ -55,6 +55,7 @@ export const ENDPOINTS = {
     businessRuleCreate: "/api/api/app/businessrule/create",
     businessRuleUpdate: "/api/api/app/businessrule/update",
     businessRulePublish: "/api/api/app/businessrule/publish",
+    businessRuleNodeRunMap: "/api/api/app/businessrule/node_run_map",
     businessRuleEnable: "/api/api/app/businessrule/enable",
     businessRuleDelete: "/api/api/app/businessrule/delete",
     dataRuleCreate: "/api/api/app/bizdatarule/create",

package/dist/form-support.js

@@ -343,6 +343,100 @@ function childTableColumns(parentCode, children) {
  * layered back from the previous draft. Child-table (201) controls are skipped:
  * their columns are regenerated from the model's subSchema.
  */
+/**
+ * Options that carry an expression the DESIGNER computed (formula, condition,
+ * default formula). A rebuild re-scaffolds controls from field metadata, which
+ * cannot reproduce them: the scaffold only knows the field family. Losing one
+ * is silent — the control still renders, the page still publishes, and the only
+ * signal is an empty string where an expression used to be. Live 2026-10-21
+ * (customer 8.2.96, 季度考评): `field.update cascadeRepublish:true` rebuilt the
+ * form and `totalScore`/`score`/`totalEvaluationScore` came back with
+ * `shortTextStitch: ""` while the pre-rebuild backup still had
+ * `SUM({evaluation_form.realScore})`.
+ */
+const FORMULA_BEARING_CONTROL_KEYS = [
+    "shortTextStitch",
+    "formulaConfig",
+    "displayFormula",
+    "requiredFormula",
+    "readonlyFormula",
+    "readonlyCondition",
+    "verifyFormula",
+    "computeFormula",
+];
+function nonEmptyExpression(value) {
+    if (typeof value === "string")
+        return value.trim() !== "" && value.trim() !== "{}" && value.trim() !== "[]";
+    if (value && typeof value === "object" && !Array.isArray(value))
+        return Object.keys(value).length > 0;
+    return false;
+}
+/**
+ * Layer two attributes faces (base = published, over = draft). Controls keep
+ * their own `options` merged per key, so a control edited on only one face
+ * still contributes its untouched options to the rebuild baseline. The draft
+ * wins wherever both define a key.
+ */
+function mergeAttributeFaces(base, over) {
+    if (base === undefined)
+        return over;
+    if (over === undefined)
+        return base;
+    const merged = { ...base };
+    for (const [code, control] of Object.entries(over)) {
+        const prior = base[code];
+        const options = control?.options;
+        if (prior && typeof prior === "object" && options && typeof options === "object" && !Array.isArray(options)
+            && prior.options && typeof prior.options === "object" && !Array.isArray(prior.options)) {
+            merged[code] = { ...control, options: { ...prior.options, ...options } };
+            continue;
+        }
+        merged[code] = control;
+    }
+    return merged;
+}
+/** controlCode → option keys that carried a real expression on that face. */
+export function formulaBearingControlOptions(face) {
+    const carry = new Map();
+    for (const [code, control] of Object.entries(face)) {
+        const options = control?.options;
+        if (!options || typeof options !== "object" || Array.isArray(options))
+            continue;
+        const keys = FORMULA_BEARING_CONTROL_KEYS.filter((key) => nonEmptyExpression(options[key]));
+        if (keys.length > 0)
+            carry.set(code, keys);
+    }
+    return carry;
+}
+/**
+ * Fail-closed guard for the rebuild path: every expression present on the
+ * baseline face must still be present afterwards. Refusing beats shipping a
+ * form whose formula silently became "". The caller can restore from a backup
+ * artifact or pass the layout explicitly.
+ */
+export function assertFormulasSurvivedRebuild(next, baseline, where) {
+    const lost = [];
+    for (const [code, optionKeys] of formulaBearingControlOptions(baseline)) {
+        const options = next[code]?.options;
+        const current = options && typeof options === "object" && !Array.isArray(options) ? options : {};
+        for (const key of optionKeys)
+            if (!nonEmptyExpression(current[key]))
+                lost.push({ control: code, option: key });
+    }
+    if (lost.length === 0)
+        return;
+    throw new ToolRefusalError({
+        status: "refused",
+        blocker: "form-rebuild-formula-would-be-lost",
+        schemaCode: where.schemaCode,
+        sheetCode: where.sheetCode,
+        losing: lost,
+        message: `重建表单会清空 ${lost.length} 处设计器公式（${lost.map((item) => `${item.control}.${item.option}`).join("、")}）——` +
+            `脚手架只能按字段元数据重建控件，公式/条件不在字段上。写前零 wire 拒绝，避免「回读 published:true 但公式已空」。` +
+            `先取备份（form.get --full 或表单版本历史 /api/api/app/bizsheet/history/list），或显式传 draftAttributesJson 原布局；` +
+            `只改字段时不要用 cascadeRepublish。`,
+    });
+}
 export function preserveDesignerControlOptions(next, previous) {
     const STRUCTURAL = new Set(["name", "name_i18n", "schemaCode", "displayField", "queryCode", "relativePropertyMatchCode"]);
     const preserved = [];
@@ -692,9 +786,21 @@ export async function executeFormDraftWrite(session, args) {
     // control visibility/width, label tweaks) are not derivable from field
     // metadata. A rebuild re-scaffolds, so capture the previous draft first and
     // layer those edits back on (see preserveDesignerControlOptions).
-    const previousAttributes = !args.rebuild || typeof pre?.draftAttributesJson !== "string"
+    // Baseline for the preserve/guard step. The DRAFT is the normal source, but a
+    // published form whose draft face is empty/stale is not a safe baseline: the
+    // designer's formulas then live only on publishedAttributesJson, and reading
+    // the draft alone makes a rebuild look like "nothing to preserve" while it
+    // drops every expression (live 2026-10-21). Merge draft-over-published so a
+    // control the designer edited only on one face still carries its options.
+    const draftAttributes = !args.rebuild || typeof pre?.draftAttributesJson !== "string"
         ? undefined
         : decodeJsonObjectColumn(pre.draftAttributesJson, { invalid: "undefined", array: "reject", object: "accept" });
+    const publishedAttributes = !args.rebuild || typeof pre?.publishedAttributesJson !== "string"
+        ? undefined
+        : decodeJsonObjectColumn(pre.publishedAttributesJson, { invalid: "undefined", array: "reject", object: "accept" });
+    const previousAttributes = draftAttributes === undefined && publishedAttributes === undefined
+        ? undefined
+        : mergeAttributeFaces(publishedAttributes, draftAttributes);
     // `rebuild: true` discards the existing draft layout and re-scaffolds from
     // the published fields, so fields added after the form was first built (a
     // child table, a new relation) land in the layout. The platform designer's
@@ -741,6 +847,15 @@ export async function executeFormDraftWrite(session, args) {
         // controls verbatim, so a later field.update never propagated (bench20).
         attributes = syncFieldDerivedControlOptions(attributes, publishedFields);
     }
+    // Fail-closed: a rebuild that would drop a designer formula must never reach
+    // the wire. The merge above normally carries them, but it cannot when the
+    // control was not re-scaffolded (field family without a control shape) or the
+    // baseline face was unreadable — those are exactly the silent-loss cases.
+    if (args.rebuild === true && previousAttributes !== undefined && typeof attributes === "string") {
+        const composed = decodeJsonObjectColumn(attributes, { invalid: "undefined", array: "reject", object: "accept" });
+        if (composed !== undefined)
+            assertFormulasSurvivedRebuild(composed, previousAttributes, { schemaCode: args.schemaCode, sheetCode: args.sheetCode });
+    }
     const payload = {
         ...(pre ?? {}),
         schemaCode: args.schemaCode,

package/dist/lanes/meta.js

@@ -93,7 +93,13 @@ export function registerMetaLane(tools) {
                     writeRequiresConfirmation: requiresProductionConfirmation(resolved.profile),
                     removedConfigKeys: removedProfileKeys(resolved.profile),
                 },
+                // Project-scoped: never advertise another directory's environments.
                 configuredEnvironments: environments.map((e) => e.name),
+                environmentScope: {
+                    project: store.configPaths.projectEnvPath.replace(/[\\/][^\\/]+$/u, ""),
+                    own: store.ownEnvironmentNames(),
+                    policy: "本目录只能使用 .omc-envs / .omc-env 声明的环境；跨环境需先向用户报告并取得同意（omc env allow <name>）",
+                },
                 credentialsMode: store.credentialsMode(),
                 session: sessionState,
                 coverage: { total: ctx.manifest.items.length, byStatus: statusCounts },

package/dist/lanes/online-js-contract.js

@@ -78,7 +78,7 @@ export const ONLINE_JS_LANE_CONTRACT = Object.freeze({
         }),
         "onlinejs.compose": Object.freeze({
             scope: ONLINE_JS_SCOPE,
-            description: `Compose the Online JS source as the customScript element into the form's draftHtmlJson layout array (then publish, promoting it verbatim to publishedHtmlJson). Core contract: preserve the platform template and only extend customScript.innerHTML — the six-element skeleton includes the ${PLATFORM_LIFECYCLE_WRAPPER_MARKER} lifecycle wrapper; the style, toolbar, template, beforeCustomScript, customScript, and afterCustomScript elements are kept or synthesized with platform defaults, while every layout/control element is preserved. customScript is rebuilt canonically as {tagName:'script', id:'customScript', innerHTML:<platform lifecycle wrapper containing source>, attrs:[]} because the designer requires an ARRAY attrs (e.attrs.some) and tagName, else the Online JS editor fails with t.some is not a function. Drives bizsheet/update + bizsheet/publish; publishedHtmlJson is read back verbatim and SHA-256-fingerprinted so the caller can verify byte equality. Read the EXISTING script first with onlinejs.get (decide replace vs INCREMENTAL from what is actually stored). Never overwrites the layout with a standalone script object or a partial [customScript]-only array (regression for issue 11's root cause).`,
+            description: `Compose the Online JS source as the customScript element into the form's draftHtmlJson layout array (then publish, promoting it verbatim to publishedHtmlJson). Core contract: preserve the platform template and only extend customScript.innerHTML — the six-element skeleton includes the ${PLATFORM_LIFECYCLE_WRAPPER_MARKER} lifecycle wrapper; the style, toolbar, template, beforeCustomScript, customScript, and afterCustomScript elements are kept or synthesized with platform defaults, while every layout/control element is preserved. customScript is rebuilt canonically as {tagName:'script', id:'customScript', innerHTML:<platform lifecycle wrapper containing source>, attrs:[]} because the designer requires an ARRAY attrs (e.attrs.some) and tagName, else the Online JS editor fails with t.some is not a function. Drives bizsheet/update + bizsheet/publish; publishedHtmlJson is read back verbatim and SHA-256-fingerprinted so the caller can verify byte equality. Read the EXISTING script first with onlinejs.get (decide replace vs INCREMENTAL from what is actually stored). Never overwrites the layout with a standalone script object or a partial [customScript]-only array (regression for issue 11's root cause). summary:true answers "did it land?" without any HTML/JS body (sha + byte counts + draftPublishedInSync); the default readback dedupes the composed draft and the script when they equal the published face, so the same script is never returned three times.`,
         }),
     }),
 });

package/dist/lanes/online-js.js

@@ -101,6 +101,7 @@ export function registerOnlineJsLane(tools) {
         source: z.string().min(1).describe("在线 JS 代码。默认 INCREMENTAL：并入平台 (function(form){…}) 模板的既有脚本，模板与既有注册全部保留；配 replace:true 才是整段替换。脚本不得使用 export/import；事件名必须是平台事件（onLoad/onRendered/onValidate/onPreAction/onCustomAction/onActionDone/onPrintFormDataHandle/onPrintWorkflowLogDataHandle）"),
         replace: z.boolean().optional().describe("true = 以 source 整体替换 customScript（含完整 (function(form){…}) 脚本）。默认 false = 增量并入既有脚本，保留平台模板与既有逻辑"),
         publish: z.boolean().optional(),
+        summary: z.boolean().optional().describe("true = 只回同步状态（sha/字节数/是否同步/渲染兼容），不回任何 HTML/JS 原文。确认「改动是否生效」用这个；要看原文用 onlinejs.get"),
     }, async (session, args) => {
         const shouldPublish = args.publish !== false;
         // 1. Read the existing draftHtmlJson.
@@ -159,17 +160,56 @@ export function registerOnlineJsLane(tools) {
         const publishedElements = parseLayoutElements(publishedRaw);
         // 8. SHA-256 of the verbatim content.
         const publishedSha256 = createHash("sha256").update(publishedRaw).digest("hex");
+        const draftSha256 = createHash("sha256").update(composedDraftHtml).digest("hex");
+        const publishedScript = readCustomScriptSource(publishedRaw).script;
+        const customScriptSha256 = createHash("sha256").update(composedScript, "utf8").digest("hex");
+        const draftPublishedInSync = publishedScript !== null && publishedScript === composedScript;
+        const htmlRenderCompat = { draft: validateHtmlRender(composedDraftHtml, true), published: validateHtmlRender(publishedRaw, true) };
+        // Live 2026-10-21 (customer): this readback shipped the same ~10KB script
+        // three times (composedDraftHtmlJson + publishedHtmlJson + customScript),
+        // ~45KB for a call whose only question was "did publish land?" — the
+        // session's single largest context amplification. Answer that question
+        // directly and keep 原文 opt-in.
+        if (args.summary === true) {
+            return {
+                performed: { errcode: 0, published },
+                readback: {
+                    publishedSha256,
+                    draftSha256,
+                    draftPublishedInSync,
+                    publishedElementCount: publishedElements.length,
+                    scriptElementPresent: publishedElements.some((element) => element.id === "customScript"),
+                    customScriptMerged: args.replace !== true,
+                    customScriptSha256,
+                    customScriptBytes: Buffer.byteLength(composedScript, "utf8"),
+                    composedDraftBytes: Buffer.byteLength(composedDraftHtml, "utf8"),
+                    publishedHtmlBytes: Buffer.byteLength(publishedRaw, "utf8"),
+                    htmlRenderCompat,
+                    hint: "summary 模式不回原文；要脚本原文用 onlinejs.get，要完整布局用 artifact 或 form.get --full",
+                },
+            };
+        }
         return {
             performed: { errcode: 0, published },
             readback: {
+                // Dedupe: after a successful publish the draft and the published
+                // face are the same bytes, and the script also rides inside them.
+                // Return the composed payload ONCE (composedDraftHtmlJson keeps the
+                // field every consumer already reads) and state the equality instead
+                // of repeating ~11KB + ~10KB.
+                ...(composedDraftHtml === publishedRaw
+                    ? { draftEqualsPublished: true }
+                    : { publishedHtmlJson: publishedRaw }),
                 composedDraftHtmlJson: composedDraftHtml,
-                publishedHtmlJson: publishedRaw,
                 publishedSha256,
+                draftSha256,
+                draftPublishedInSync,
                 publishedElementCount: publishedElements.length,
                 scriptElementPresent: publishedElements.some((element) => element.id === "customScript"),
                 customScript: composedScript,
+                customScriptMatchesPublished: draftPublishedInSync,
                 customScriptMerged: args.replace !== true,
-                htmlRenderCompat: { draft: validateHtmlRender(composedDraftHtml, true), published: validateHtmlRender(publishedRaw, true) },
+                htmlRenderCompat,
             },
         };
     }, 

package/dist/lanes/rule-lifecycle.js

@@ -3,7 +3,7 @@ import { ENDPOINTS } from "../endpoints.js";
 import { writeTool } from "../write.js";
 import { registerPackageTool } from "../package-tool.js";
 import { writeSummary } from "../human-summary.js";
-import { executeRuleSaveWrite, ruleNodeGraphArg, assertRuleSchemaExists } from "../rule-support.js";
+import { executeRuleSaveWrite, ruleNodeGraphArg, assertRuleSchemaExists, explainRuleSelfCheck } from "../rule-support.js";
 import { ToolRefusalError } from "../tool-types.js";
 import { prepareRuleGraph, validateRuleNodeGraph, PLATFORM_TRIGGER_RULE_CODES } from "./rule-graph.js";
 import { wireCall, wireRows, WireError } from "../wire.js";
@@ -52,7 +52,25 @@ export async function executeRuleEnableWrite(session, args) {
     const full = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id: String(row.id) } })).data;
     if (!full)
         throw new WireError("business", `rule ${args.ruleCode} 完整模型读回为空（businessrule/get id ${row.id}），拒绝用列表投影发布`, 302024);
-    const published = await wireCall(session, { path: ENDPOINTS.businessRulePublish, method: "POST", body: { ...full, enabled: true, status: "ENABLED" } });
+    let published;
+    try {
+        published = await wireCall(session, { path: ENDPOINTS.businessRulePublish, method: "POST", body: { ...full, enabled: true, status: "ENABLED" } });
+    }
+    catch (error) {
+        // 550018 is the platform's self-check refusal (see explainRuleSelfCheck).
+        if (error instanceof WireError && error.errcode === 550018) {
+            const detail = await explainRuleSelfCheck(session, { ...full, enabled: true, status: "ENABLED" });
+            throw new ToolRefusalError({
+                status: "refused",
+                blocker: "rule-self-check-failed",
+                schemaCode: args.schemaCode,
+                ruleCode: args.ruleCode,
+                ...detail,
+                message: `规则 ${args.ruleCode} 启用时被平台自检拒绝（550018）。${detail.nodeChecks.length > 0 ? `问题节点：${JSON.stringify(detail.nodeChecks).slice(0, 600)}` : "先用 field.list(all:true) 核对引用的字段是否已发布。"}`,
+            });
+        }
+        throw error;
+    }
     let enableErrcode = 0;
     let alreadyEnabled = false;
     try {

package/dist/lanes/workflow-contract.js

@@ -144,7 +144,7 @@ export const WORKFLOW_LANE_CONTRACT = Object.freeze({
         }),
         "org.role.list": Object.freeze({
             scope: "workflow participant resolution",
-            description: "列出组织角色（`GET /api/api/organization/role/list`），扁平化为 {id,name,code,roleType,corpId}。用于把审批节点的参与者解析成平台认识的引用。**真实参与者语法**（2026-09-23 生产观察）：`participant` 只能是 (a) 关键字 `{Originator}`；(b) 参与者对象数组 JSON `[{\"code\":\"<roleCode>\",\"corpId\":\"<corpId|other>\",\"id\":\"<roleId>\",\"name\":\"<角色名>\",\"type\":2}]`（type 2=角色，3=用户；多个用 `+` 连接）；(c) 函数表达式如 `FindUserByRole({Originator.OU},\"<roleCode>\",\"random\")`。**自由文本角色名（如 `部门负责人`）能 publish 但解析不到人、不生成待办**——先用本工具拿到 `code`/`id` 再构造对象数组。",
+            description: "列出组织角色（`GET /api/api/organization/role/list`），递归展开角色组，返回 {count, roleCount, groupCount, roles[{id,name,code,roleType,corpId,group}], groups[{id,name,code,path,childCount}]}。**`count` 只数角色，不含角色组**——角色组是容器（平台行标记 `group:true`），旧版把空组当角色列出，曾让调用方把「19 个角色组」误读成「目标角色未创建」；`groups[].childCount` 才说明组内是否真的没有角色。用于把审批节点的参与者解析成平台认识的引用。**真实参与者语法**（2026-09-23 生产观察）：`participant` 只能是 (a) 关键字 `{Originator}`；(b) 参与者对象数组 JSON `[{\"code\":\"<roleCode>\",\"corpId\":\"<corpId|other>\",\"id\":\"<roleId>\",\"name\":\"<角色名>\",\"type\":2}]`（type 2=角色，3=用户；多个用 `+` 连接）；(c) 函数表达式如 `FindUserByRole({Originator.OU},\"<roleCode>\",\"random\")`。**自由文本角色名（如 `部门负责人`）能 publish 但解析不到人、不生成待办**——先用本工具拿到 `code`/`id` 再构造对象数组。",
         }),
         "org.department.list": Object.freeze({
             scope: "workflow participant resolution",

package/dist/lanes/workflow.js

@@ -2302,16 +2302,7 @@ export function registerWorkflowLane(tools) {
         inputSchema: { environment: environmentArg, capability: capabilityArg },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
             const data = (await wireCall(session, { path: ENDPOINTS.organizationRoleList })).data;
-            const roles = [];
-            for (const group of wireRows(data)) {
-                const children = Array.isArray(group.children) ? group.children : [];
-                if (children.length === 0)
-                    roles.push(roleOf(group, null));
-                else
-                    for (const child of children)
-                        roles.push(roleOf(child, String(group.name ?? "")));
-            }
-            return { count: roles.length, roles };
+            return flattenRoleTree(wireRows(data));
         }),
     }));
     tools.push(defineTool({
@@ -2381,6 +2372,74 @@ export function registerWorkflowLane(tools) {
     }));
 }
 /** Flatten a role-group/role row into the participant-construction fields. */
+/**
+ * Role groups are CONTAINERS, not roles. The platform's own row marks them
+ * `group:true` (children carry `group:false`), so membership must be decided by
+ * that flag — never by `children.length`. Live 2026-10-21 (customer 8.2.96,
+ * 季度考评): every entry was a group with `children:[]`, so the old
+ * `children.length === 0 ? role : …` shape returned 19 "roles" that were all
+ * groups; the agent read `count:19` as "the 6 roles were never created" and
+ * reported a false blocker to the user. Groups also nest, so flatten
+ * recursively and keep them in a separate `groups` list.
+ */
+const ROLE_CHILD_KEYS = ["children", "roles", "childRoles", "childList", "list"];
+function roleChildren(row) {
+    for (const key of ROLE_CHILD_KEYS) {
+        const value = row[key];
+        if (Array.isArray(value))
+            return value;
+    }
+    return [];
+}
+function isRoleGroup(row) {
+    if (row.group === true)
+        return true;
+    // Older builds omit `group`; a container with children is still a container.
+    // A row that carries `groupId` is a leaf role even if it has an empty array.
+    if (row.groupId !== undefined && row.groupId !== null)
+        return false;
+    return roleChildren(row).length > 0;
+}
+export function flattenRoleTree(rows) {
+    const roles = [];
+    const groups = [];
+    const walk = (nodes, containerPath) => {
+        for (const node of nodes) {
+            if (!isRoleGroup(node)) {
+                roles.push(roleOf(node, containerPath.length > 0 ? containerPath[containerPath.length - 1] : null));
+                continue;
+            }
+            const name = String(node.name ?? "");
+            const path = [...containerPath, name];
+            const children = roleChildren(node);
+            groups.push({
+                id: node.id ?? null,
+                name: node.name ?? null,
+                code: node.code ?? null,
+                corpId: node.corpId ?? null,
+                path: path.join(" / "),
+                childCount: children.length,
+            });
+            if (children.length > 0)
+                walk(children, path);
+        }
+    };
+    walk(rows, []);
+    return {
+        // `count` stays role-only: it is what participant resolution consumes, and
+        // counting containers as roles is exactly the misread this fixes.
+        count: roles.length,
+        roleCount: roles.length,
+        groupCount: groups.length,
+        roles,
+        groups,
+        ...(roles.length === 0
+            ? {
+                hint: "本次返回里没有任何角色行（只有角色组或无数据）。角色组不是角色：不要据此断言「角色未创建」。若预期有角色，先看 groups[].childCount —— 组内为空说明该组下确实未建角色；若要验证某个 roleCode 在运行期可用，用业务数据反证（如 data.list 读取引用该 roleCode 的记录，或 org.user.search 找到人后用其角色字段）。",
+            }
+            : {}),
+    };
+}
 function roleOf(row, group) {
     return {
         id: row.id ?? null,

package/dist/rule-support.js

@@ -463,6 +463,71 @@ export async function computeCarriedNodeCodes(session, schemaCode, ruleCode, pre
         return undefined; // 取不到存量图 → 维持严格闭集，行为与放宽前一致
     }
 }
+/**
+ * 550018 is the platform's catch-all "rule self-check failed" (ErrorCode
+ * BUSINESS_RULE_PARAM_ERROR from BusinessRuleFacadeImpl.publishBusinessRule when
+ * checkBizRuleIsEnable() is false). The message names nothing, and the real原因
+ * is one of: a referenced property that does not exist, a missing org object, or
+ * a dead cycle. `businessrule/node_run_map` (BusinessRuleController.getNodeRunMaps
+ * → checkBizRuleError) returns exactly that per node, so a refusal can name the
+ * offending node and field instead of asking the caller to open the designer.
+ */
+const RULE_SELF_CHECK_ERRCODE = 550018;
+function ruleSelfCheckMessage(ruleCode, checks) {
+    if (checks.length === 0)
+        return `规则 ${ruleCode} 发布被平台自检拒绝（550018「保存规则失败，规则存在异常」），但 node_run_map 未给出具体节点——常见原因：引用的字段未发布/不存在、组织对象失效、或存在死循环。先用 field.list(all:true) 核对引用的字段是否已发布。`;
+    const detail = checks.map((check) => {
+        const parts = [];
+        const missing = check.missingProperties;
+        if (missing?.length)
+            parts.push(`字段不存在/未发布：${missing.map((item) => `${item.objectName ?? "?"}.${item.propertyName ?? item.propertyCode ?? "?"}`).join("、")}`);
+        if (check.missingOrgObjects)
+            parts.push("组织对象不存在");
+        if (check.deadCycles)
+            parts.push("存在死循环");
+        return `${String(check.nodeCode ?? "?")}${check.nodeName ? `(${String(check.nodeName)})` : ""} ${parts.join("；")}`;
+    });
+    return `规则 ${ruleCode} 发布被平台自检拒绝（550018）：${detail.join(" | ")}。节点内引用了不存在或未发布的字段时，保存能过、发布必拒——先补字段并 field.publish，再重发。`;
+}
+export async function explainRuleSelfCheck(session, model) {
+    try {
+        const response = await wireCall(session, { path: ENDPOINTS.businessRuleNodeRunMap, method: "POST", body: model });
+        const rows = wireRows(response.data);
+        const nodeChecks = rows.flatMap((row) => {
+            // Wire shape (QuoteObjectVO): {objectCode, objectName, quotePropertyList:
+            // [{propertyCode, propertyName, exist, propertyPublished}]} — the property
+            // sits one level deeper than the object.
+            const missingProperties = Array.isArray(row.notExistPropertyObjectList)
+                ? row.notExistPropertyObjectList.flatMap((object) => {
+                    const properties = Array.isArray(object.quotePropertyList) ? object.quotePropertyList : [];
+                    const broken = properties.filter((property) => property.exist === false || property.propertyPublished === false);
+                    const source = broken.length > 0 ? broken : properties;
+                    return source.map((property) => ({
+                        objectName: object.objectName ?? object.objectCode ?? null,
+                        propertyCode: property.propertyCode ?? null,
+                        propertyName: property.propertyName ?? null,
+                        published: property.propertyPublished ?? null,
+                    }));
+                })
+                : [];
+            const missingOrgObjects = Array.isArray(row.notExistOrgObjectList) ? row.notExistOrgObjectList : [];
+            const deadCycles = Array.isArray(row.deadCycleRunMapList) ? row.deadCycleRunMapList : [];
+            if (missingProperties.length === 0 && missingOrgObjects.length === 0 && deadCycles.length === 0)
+                return [];
+            return [{
+                    nodeCode: row.nodeCode ?? null,
+                    nodeName: row.nodeName ?? null,
+                    ...(missingProperties.length > 0 ? { missingProperties } : {}),
+                    ...(missingOrgObjects.length > 0 ? { missingOrgObjects } : {}),
+                    ...(deadCycles.length > 0 ? { deadCycles } : {}),
+                }];
+        });
+        return { nodeChecks };
+    }
+    catch {
+        return { nodeChecks: [] };
+    }
+}
 export async function executeRuleSaveWrite(session, args) {
     // Pre-flight dry lint (ticket 14): a mis-shaped graph must be refused BEFORE
     // any wire call, with structured blockers locating the node/key — never
@@ -594,7 +659,23 @@ export async function executeRuleSaveWrite(session, args) {
             // schedule and a TIMING_TASK rule never gets a quartz job (2026-10-06). Use
             // the authoritative `businessrule/get?id` model (same as rule.get/enable).
             const full = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id: String(row.id) } })).data;
-            await wireCall(session, { path: ENDPOINTS.businessRulePublish, method: "POST", body: full ?? row });
+            try {
+                await wireCall(session, { path: ENDPOINTS.businessRulePublish, method: "POST", body: full ?? row });
+            }
+            catch (error) {
+                if (error instanceof WireError && error.errcode === RULE_SELF_CHECK_ERRCODE) {
+                    const detail = await explainRuleSelfCheck(session, (full ?? row));
+                    throw new ToolRefusalError({
+                        status: "refused",
+                        blocker: "rule-self-check-failed",
+                        schemaCode: args.schemaCode,
+                        ruleCode: args.ruleCode,
+                        ...detail,
+                        message: ruleSelfCheckMessage(args.ruleCode, detail.nodeChecks),
+                    });
+                }
+                throw error;
+            }
         }
         const effective = await currentRow();
         // Live 8.6.26 (2026-09-17): businessrule/publish mints a version but does

package/package.json

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

package/skills/omc-business-configuration.md

@@ -274,7 +274,7 @@ BIZ_ACTION：
 - 直接执行规则：`useLocation: ROW` + `operateType: WITH_OUT_VIEW`。
 - `WITH_VIEW` 是打开表单。
 - FLOW 按钮需要 workflowCode；CLI 会补安全的 actionConfig。
-- **在线 JS 分两条**：本 CLI 只做**读写与发布**——**读现存脚本用 `onlinejs.get`**（抽 customScript innerHTML 原文+SHA-256，不必拉 form.get --full 六份 JSON；据此决定 replace 还是默认 INCREMENTAL 并入），用 `onlinejs.compose` 把已定稿的 `source` 组合进平台 skeleton 的 `customScript` 再 publish，回读 `publishedHtmlJson`+SHA-256。**脚本内容的编写/增量合并不在本 CLI**：若当前项目自带在线 JS 编写规范（例如其 `.cpdocs`/技能或项目文档），遵循它；否则向用户/设计者索取已定稿的 `source`。不要在 omc 侧手写或臆造 JS 逻辑。
+- **在线 JS 分两条**：本 CLI 只做**读写与发布**——**读现存脚本用 `onlinejs.get`**（抽 customScript innerHTML 原文+SHA-256，不必拉 form.get --full 六份 JSON；据此决定 replace 还是默认 INCREMENTAL 并入），用 `onlinejs.compose` 把已定稿的 `source` 组合进平台 skeleton 的 `customScript` 再 publish，回读 `publishedHtmlJson`+SHA-256。**确认是否落地用 `summary:true`**（只回 sha/字节数/`draftPublishedInSync`，不回原文，约 600B；默认回显也已去重，不再把同一段脚本回三次）。**脚本内容的编写/增量合并不在本 CLI**：若当前项目自带在线 JS 编写规范（例如其 `.cpdocs`/技能或项目文档），遵循它；否则向用户/设计者索取已定稿的 `source`。不要在 omc 侧手写或臆造 JS 逻辑。
 
 ## 运行验收与清理
 

package/skills/omc-config-draft-review.md

@@ -164,7 +164,7 @@ you can wait for.
 
 视图与表单脚手架都从**发布面**读字段元数据——字段未发布，列/控件就生成不出来。
 `data.list` 对未配列的自定义字段投影为 null（显示面缺配置，不是数据缺失）；核值用 `data.load`。
-字段级变更（如关联展示字段）改完后，必须重走 `field.publish` → `form.draft` → `form.publish` 运行时才生效（表单控件快照字段 options）；`field.update` 带 `"cascadeRepublish":true` 一调完成整条链（中途失败按 partial steps 如实报告），只刷新表单用 `form.publish rebuild:true`。
+字段级变更（如关联展示字段）改完后，必须重走 `field.publish` → `form.draft` → `form.publish` 运行时才生效（表单控件快照字段 options）；`field.update` 带 `"cascadeRepublish":true` 一调完成整条链（中途失败按 partial steps 如实报告），只刷新表单用 `form.publish rebuild:true`。**重建会按字段元数据重生成控件，设计器公式（`shortTextStitch`/条件/默认值）不在字段上**：0.4.71 起写前校验，会丢公式即拒绝 `form-rebuild-formula-would-be-lost`；不需要重建布局时不要带此参数。
 
 ## Invariants
 

package/skills/omc-start-here.md

@@ -82,7 +82,20 @@ execute → readback/cleanup** (`omc-five-piece-flow`).
 There is no approval token, no `--yes`, and no self-approval switch. If a call
 refuses, work out which gate or boundary produced it from `omc-refusals`.
 
-## 3. Boundaries
+## 3. Project environment isolation
+
+Each project directory may use only the environments it declares: `.omc-env` (this
+project's binding) and `.omc-envs` (its allowlist, one name per line). Any other
+environment on the machine is another project's — `resolveEnvironment` refuses it
+**before** credentials, token cache or network access, so nothing leaks. Lists
+(`omc env list`, `get_status.configuredEnvironments`) are project-scoped too.
+
+To use another environment you must ask the user first, then either
+`omc env allow <name>` (writes `.omc-envs`, durable) or a one-off
+`OMC_ALLOW_CROSS_ENV=1` (prints a `cross-env:` line to stderr). Never widen the
+scope on your own initiative.
+
+## 4. Boundaries
 
 Out-of-coverage, blocked, or unsupported faces refuse with a manifest citation —
 that refusal is the answer, not an obstacle to route around with another tool.

package/skills/omc-write-hazards.md

@@ -34,7 +34,7 @@ omc help omc-write-hazards
 - 有映射时传非空 JSON 数组字符串，并在 draft/published 两面读回。
 - **运行时写关联值是另一种形状**（`data.save`/`data.update` 的 formData）：单选关联（`propertyType 9`）传 **id 字符串或 `{ id }`**，传**数组会稳定 50000**；**多选关联（11）传分号分隔的 id 字符串 `"id1;id2"`（或 `{id:"id1;id2"}`），传数组稳定 50000**；**人员/组织（50/51/60/61）传 `[{"id","type","name"}]`，`type` 必填**（缺它稳定 50000）——`type` 是 UnitType 索引：**用户=3、部门=1**。用错形状只会拿到一个不透明的 50000。
 - **`mappings` 由表单运行时在用户选择时套用**，服务端 `data.save` **不会**自动回填映射目标字段。API 侧要自己写被映射字段，否则读回为空——别把它误判成“映射配置失败”。
-- **关联映射的事实源在字段行 `options.mappings`，不在表单控件属性**（真机 2026-10-14 实证：改表单 attributes 里的映射会被平台按字段重算覆盖、回读不生效）。改映射走：`field.update` 按完整 options 提交（只改 mappings，其余键原值保留）→ `field.publish` → `form.draft`（**rebuild:false**，保留现有布局与在线JS）重存 → `form.publish` → 回读核对。**别用 field.update 的 cascadeRepublish 刷已带自定义布局/在线JS 的表单**（它会 rebuild 脚手架）。
+- **关联映射的事实源在字段行 `options.mappings`，不在表单控件属性**（真机 2026-10-14 实证：改表单 attributes 里的映射会被平台按字段重算覆盖、回读不生效）。改映射走：`field.update` 按完整 options 提交（只改 mappings，其余键原值保留）→ `field.publish` → `form.draft`（**rebuild:false**，保留现有布局与在线JS）重存 → `form.publish` → 回读核对。**别用 cascadeRepublish 刷带布局/在线JS 的表单**：rebuild 会清空设计器公式（已做写前拒绝）。
 - **运行时写值的最小形状**（组合出错只会得到一个不透明的 `50000`/NPE，逐一最小化再合）：单选关联(9) → id 字符串 `"<id>"`；**多选关联(11) → 分号串 `"<id1>;<id2>"`**；**人员/组织(50/51/60/61) → `[{"id":"<id>","type":3,"name":"<名>"}]`，`type` 必填且为整数**（缺/非整数 → `BizField.parseFromClient` 拆箱 NPE→50000；用户=3、部门=1）；日期(3) → 字符串 `"2026-09-30 10:00:00"`；子表(8) → 行对象数组 `[{"<子列code>":<值>, ...}]`。先各写一条最小行通过，再组合。
 - **DATE(3) 字段的 `options.format` 必须是平台大写枚举**（`YYYY-MM-DD`、`YYYY-MM-DD HH:mm:ss`、`YYYY年MM月DD日`…），**不是 Java 的 `yyyy-MM-dd`**：平台 `DateBizField` 按字面比较，Java 写法能创建字段但**首次运行时 save 稳定 `50000`（`不支持的format`）**（2026-09-30 R5 实测）。`field.create`/`intent` 会就地拒绝非枚举值。