@stalfh233/omc-cli 0.5.6 → 0.5.8

package/dist/bench/intent-face-eval.js

@@ -122,24 +122,24 @@ function freshHome(url) {
     writeFileSync(join(home, "credentials"), JSON.stringify({ eval: { username: "tester", password: "eval-face-password" } }));
     return home;
 }
-const LADDER_INTENT = `intentVersion: 1
-models:
-  - code: eval_m1
-    name: 评测建模
-    fields:
-      - code: f_title
-        name: 标题
-        type: SHORT_TEXT
-      - code: f_amount
-        name: 金额
-        type: NUMERICAL
-        options:
-          scale: 3
-      - code: f_when
-        name: 日期
-        type: DATE
-    form:
-      publish: true
+const LADDER_INTENT = `intentVersion: 1
+models:
+  - code: eval_m1
+    name: 评测建模
+    fields:
+      - code: f_title
+        name: 标题
+        type: SHORT_TEXT
+      - code: f_amount
+        name: 金额
+        type: NUMERICAL
+        options:
+          scale: 3
+      - code: f_when
+        name: 日期
+        type: DATE
+    form:
+      publish: true
 `;
 export const INTENT_FACE_TASKS = [
     {
@@ -163,12 +163,12 @@ export const INTENT_FACE_TASKS = [
         id: "rule-backfill-ladder",
         description: "two models via intent + DYNAMIC backfill rule + enable + trigger row + verified target readback (mixed face: intent + escape hatch)",
         async run(agent, server) {
-            const modelsIntent = agent.writeIntent("models.yaml", `intentVersion: 1
-models:
-  - code: eval_rs
-    name: 回填源
-  - code: eval_rt
-    name: 回填目标
+            const modelsIntent = agent.writeIntent("models.yaml", `intentVersion: 1
+models:
+  - code: eval_rs
+    name: 回填源
+  - code: eval_rt
+    name: 回填目标
 `);
             await agent.intentValidate(modelsIntent);
             const { plan, planFile } = await agent.intentPlan(modelsIntent);
@@ -209,27 +209,27 @@ models:
         id: "input-error-recovery",
         description: "bad intent -> validate exit 10 with source location -> fix -> plan/apply -> idempotent re-plan/re-apply with zero duplicate wires",
         async run(agent, server) {
-            const bad = agent.writeIntent("intent.yaml", `intentVersion: 1
-models:
-  - code: eval_idem
-    name: 幂等模型
-    fields:
-      - code: f_bad
-        name: 坏类型
-        type: HOLOGRAM
+            const bad = agent.writeIntent("intent.yaml", `intentVersion: 1
+models:
+  - code: eval_idem
+    name: 幂等模型
+    fields:
+      - code: f_bad
+        name: 坏类型
+        type: HOLOGRAM
 `);
             const rejected = await agent.run(["intent", "validate", bad]);
             ok(rejected.code === 10 && rejected.envelope.error?.code === "invalid-input", `expected invalid-input exit 10, got ${String(rejected.code)}`);
             const first = rejected.envelope.result.errors[0];
             ok(first.code === "intent-field-type-unknown" && typeof first.line === "number", `located error: ${JSON.stringify(first).slice(0, 200)}`);
-            const fixed = agent.writeIntent("intent.yaml", `intentVersion: 1
-models:
-  - code: eval_idem
-    name: 幂等模型
-    fields:
-      - code: f_bad
-        name: 改正的字段
-        type: SHORT_TEXT
+            const fixed = agent.writeIntent("intent.yaml", `intentVersion: 1
+models:
+  - code: eval_idem
+    name: 幂等模型
+    fields:
+      - code: f_bad
+        name: 改正的字段
+        type: SHORT_TEXT
 `);
             const validated = await agent.intentValidate(fixed);
             ok(validated.valid === true, `fixed validate: ${JSON.stringify(validated).slice(0, 200)}`);

package/dist/cli.js

@@ -13,6 +13,7 @@ import { redactText } from "./redact.js";
 import { readArgsFile, readStdinArgs, runToolCall, validateAgentPaths } from "./call.js";
 import { BATCH_MAX_ENTRIES, runBatchCall } from "./batch-call.js";
 import { cmdModelScaffold } from "./model-scaffold.js";
+import { cmdFieldAdd } from "./field-add.js";
 import { cmdModelPurge } from "./model-purge.js";
 import { environmentWritable, requiresProductionConfirmation } from "./environment-policy.js";
 import { CLI_EXIT_CODES, classifyResult, envelope, errorEnvelope, installCodePageSafeStderr, refusalText, requestId } from "./cli-contract.js";
@@ -1733,6 +1734,35 @@ async function main() {
         const rest = ["form-default", ...(options.schema ? ["--schema", options.schema] : []), ...(options.schemaCode ? ["--schema-code", options.schemaCode] : []), ...(options.field ? ["--field", options.field] : []), ...(options.default !== undefined ? ["--default", options.default] : []), ...(options.env ? ["--env", options.env] : []), ...(options.environment ? ["--environment", options.environment] : []), ...(options.apply ? ["--apply"] : [])];
         commandExitCode = await cmdFormDefault(rest);
     });
+    command
+        .command("field-add")
+        .option("--schema <schemaCode>", "存量模型 code")
+        .option("--schema-code <schemaCode>")
+        .option("--code <schemaCode>")
+        .option("--fields <json>", "JSON 数组，每条是一个 field.create 参数（choices/字典 options 原样透传）")
+        .option("--fields-json <json>")
+        .option("--env <environment>")
+        .option("--environment <environment>")
+        .option("--no-form", "跳过表单重建")
+        .option("--no-list", "跳过列表加列")
+        .option("--force-publish", "有字段失败也发布（默认停在发布前）")
+        .option("--apply")
+        .addHelpText("after", `\n存量模型加字段一条命令：建字段 → 发布字段 → 重建表单 → 列表追加列（增量合并，保留既有列/条件/排序）。\n默认 dry-run 只列计划；--apply 执行。幂等：字段已存在记 skipped 继续。\n子表不属于本命令（存量挂子表走 field.create CHILD_TABLE + 子列，见 model-scaffold）。\n\nr30/r31 探针实证：同一条链手工要走 4 次写调用 + 各自回读。\n`)
+        .action(async (options) => {
+        const rest = ["field-add",
+            ...(options.schema ? ["--schema", options.schema] : []),
+            ...(options.schemaCode ? ["--schema-code", options.schemaCode] : []),
+            ...(options.code ? ["--code", options.code] : []),
+            ...(options.fields !== undefined ? ["--fields", options.fields] : []),
+            ...(options.fieldsJson !== undefined ? ["--fields-json", options.fieldsJson] : []),
+            ...(options.env ? ["--env", options.env] : []),
+            ...(options.environment ? ["--environment", options.environment] : []),
+            ...(options.form === false ? ["--no-form"] : []),
+            ...(options.list === false ? ["--no-list"] : []),
+            ...(options.forcePublish ? ["--force-publish"] : []),
+            ...(options.apply ? ["--apply"] : [])];
+        commandExitCode = await cmdFieldAdd(rest);
+    });
     command.command("script [file]").option("--env <environment>", "行内无 env 时的默认环境").option("--continue", "某行失败后继续执行剩余行（默认停在首个失败）").description("NDJSON 多调脚本：每行 {\"tool\":\"<名称>\",\"args\":{...},\"env\":\"<环境>\",\"dryRun\":true}（# 注释/空行忽略；file 为 - 读 stdin）；一个进程一次会话跑完全部，逐行输出 {index,tool,exitCode,result}").action(async (file, options) => {
         const { runScript, parseScript, readScriptInput } = await import("./script.js");
         let lines;
@@ -1906,7 +1936,7 @@ main().then((code) => {
     // envelope (or, for `env --json`, their own JSON) and were printing a second
     // empty envelope after it (live 2026-10-23: `omc rollback apply` answered two
     // lines, violating the one-envelope stdout contract).
-    const ownsStdout = ["call", "script", "artifact", "commands", "describe", "contract", "capabilities", "capability", "next", "usage", "intent", "help", "form-default", "compute", "rule-when", "approval-flow", "model-scaffold", "model-purge", "rollback", "env", "graph", "--version", "-V"];
+    const ownsStdout = ["call", "script", "artifact", "commands", "describe", "contract", "capabilities", "capability", "next", "usage", "intent", "help", "form-default", "compute", "rule-when", "approval-flow", "model-scaffold", "field-add", "model-purge", "rollback", "env", "graph", "--version", "-V"];
     if (ownsStdout.includes(argv[2] ?? "")) {
         completeUsage(code);
         finish(code);

package/dist/field-add.js

@@ -0,0 +1,314 @@
+/**
+ * `omc field-add` — 存量模型加字段一条命令：建字段 → 发布字段 → 重建表单 → 列表加列。
+ *
+ * r30/r31 两轮探针实证同一条手工链（4 次写调用 + 各自回读）：
+ * field.create → field.publish → form.publish(rebuild) → listview.configure。
+ * 「给既有模型加一个字段并显示到列表」是变更类需求的最高频动作，值得一条命令。
+ *
+ * 语义（与 model-scaffold 同族约定）：
+ *   - **幂等**：字段已存在（duplicate）→ 记 skipped 继续（补建场景不该整批失败）。
+ *   - **不猜**：--fields 每项原样透传给 field.create（只补 schemaCode）。
+ *   - **失败不发布**：有真失败默认停在发布前（--force-publish 强发）。
+ *   - **列表增量**：listview.configure 默认合并语义（保留既有列/条件），只把新字段
+ *     追加进列集——不需要先读旧列（r31 实证 conditions 原样保留）。
+ *   - 子表不属于本拼装器（存量模型挂子表有独立顺序），--fields 带 subFields 直接拒。
+ */
+import { argvValue } from "./args.js";
+import { runToolCall } from "./call.js";
+import { CLI_EXIT_CODES, classifyResult, envelope, refusalText, requestId } from "./cli-contract.js";
+import { writeEnvelope } from "./cli-output.js";
+/**
+ * 字典简写展开（r30/r36 实证：字典字段要先 names 查 id、records 取记录、
+ * 再拼 optionsSet.dictionary 三段 4–5 调；`dictCode` 把它折进 field-add 一步）：
+ * `{"code":"x","propertyType":"DROPDOWN_BOX","dictCode":"purchase_coop_status"}`
+ * → 内部解析 checkedDictionary(id)+checkedDictionaryCode+useDictionariesData(records)
+ * 按 dictionary-backed-single-select recipe 形状组装 options.optionsSet。
+ */
+async function expandDictShorthand(fields, environment, contextForTest, request) {
+    const problems = [];
+    const expanded = [];
+    const call = async (tool, args) => {
+        const outcome = await runToolCall(tool, {
+            args,
+            requestId: request,
+            ...(environment !== undefined ? { environment } : {}),
+            ...(contextForTest !== undefined ? { context: contextForTest } : {}),
+            print: () => undefined,
+        });
+        return outcome.exitCode === 0 ? outcome.result : null;
+    };
+    const out = [];
+    for (const field of fields) {
+        const dictCode = field.dictCode;
+        if (typeof dictCode !== "string" || dictCode.length === 0) {
+            out.push({ ...field });
+            continue;
+        }
+        const rest = { ...field };
+        delete rest.dictCode;
+        // dictionary.list 是真假两平台都稳的清单面（names 的 getDictionaryIdAndNames
+        // 在 fake 上未实现）；list 的回执可能是 {dictionaries:{content:[...]}} 分页
+        // 或裸数组，两种都吃。
+        const listResult = await call("dictionary.list", { limit: 200 });
+        const listPayload = listResult === null ? null : (listResult.dictionaries ?? listResult.names ?? listResult.content ?? listResult);
+        const names = Array.isArray(listPayload)
+            ? listPayload
+            : (Array.isArray(listPayload?.content) ? listPayload.content : []);
+        const hit = names.find((row) => String(row.code ?? row.dictionaryCode ?? "") === dictCode);
+        if (hit === undefined) {
+            problems.push(`${String(field.code)}: 字典 ${dictCode} 不存在（dictionary.names 未命中）——先 dictionary.save 或修正 dictCode`);
+            continue;
+        }
+        const dictId = String(hit.id ?? hit.dictionaryId ?? "");
+        const recordsResult = await call("dictionary.records", { code: dictCode, enabledOnly: true });
+        const recordsRaw = recordsResult === null ? [] : (recordsResult.records ?? {});
+        const recordRows = (Array.isArray(recordsRaw) ? recordsRaw : (recordsRaw.content ?? []));
+        if (recordRows.length === 0) {
+            problems.push(`${String(field.code)}: 字典 ${dictCode} 无启用记录——先补 dictionary.records`);
+            continue;
+        }
+        const useDictionariesData = recordRows.map((row) => ({ id: String(row.id ?? ""), code: String(row.code ?? ""), name: String(row.name ?? row.code ?? "") }));
+        out.push({
+            ...rest,
+            options: {
+                optionsSet: {
+                    optionsType: "dictionary",
+                    dictionary: { checkedDictionary: dictId, checkedDictionaryCode: dictCode, useDictionariesData },
+                },
+            },
+        });
+        expanded.push(String(field.code));
+    }
+    return { fields: out, expanded, problems };
+}
+export function validateFields(schemaCode, fields) {
+    const problems = [];
+    const seen = new Set();
+    for (const [index, field] of fields.entries()) {
+        const at = `fields[${index}]`;
+        const code = field.code;
+        if (typeof code !== "string" || code.length === 0)
+            problems.push(`${at}.code 必填`);
+        else if (seen.has(code))
+            problems.push(`${at}.code 与前面的字段重复（${code}）`);
+        else
+            seen.add(code);
+        if (typeof field.name !== "string" || field.name.length === 0)
+            problems.push(`${at}.name 必填`);
+        if (typeof field.propertyType !== "string" || field.propertyType.length === 0)
+            problems.push(`${at}.propertyType 必填`);
+        if (field.subFields !== undefined || field.childFields !== undefined)
+            problems.push(`${at}: field-add 不处理子表（存量模型挂子表先 field.create CHILD_TABLE 再建子列，见 model-scaffold 的子表序）`);
+    }
+    if (problems.length === 0 && schemaCode.length === 0)
+        problems.push("--schema 必填");
+    return problems;
+}
+export async function cmdFieldAdd(args, contextForTest) {
+    const request = requestId();
+    const flag = (name) => argvValue(args, name);
+    const schemaCode = flag("--schema") ?? flag("--schema-code") ?? flag("--code");
+    const fieldsJson = flag("--fields") ?? flag("--fields-json");
+    const environment = flag("--env") ?? flag("--environment");
+    const apply = args.includes("--apply");
+    const publishForm = !args.includes("--no-form");
+    const addToList = !args.includes("--no-list");
+    const forcePublish = args.includes("--force-publish");
+    const usage = [
+        "用法：omc field-add --schema <模型code> --fields '<JSON 数组>' [--apply]",
+        "  --fields 每项是一个 field.create 的参数：{\"code\",\"name\",\"propertyType\",...}（choices/字典 options 原样透传）；",
+        "  字典简写：{\"dictCode\":\"<字典code>\"} 代替手拼 options.optionsSet（内部解析字典 id+启用记录，recipe 同形状）。",
+        "  默认 dry-run；--apply 依次执行 建字段 → 发布字段 → 重建表单 → 列表追加列。",
+        "  幂等：字段已存在记 skipped 继续；有真失败默认不发布/不重建（--force-publish 强发）。",
+        "  --no-form 跳过表单重建；--no-list 跳过列表加列（默认两者都做）。",
+    ].join("\n");
+    const invalid = (message) => {
+        writeEnvelope(envelope("error", {}, request, { code: "invalid-input", message: `${message}\n${usage}`, retryable: false }));
+        return CLI_EXIT_CODES.invalidInput;
+    };
+    if (!schemaCode)
+        return invalid("--schema 必填（存量模型 code）");
+    if (fieldsJson === undefined)
+        return invalid("--fields 必填（JSON 数组）");
+    let fields;
+    try {
+        const parsed = JSON.parse(fieldsJson);
+        if (!Array.isArray(parsed) || parsed.length === 0)
+            throw new Error("--fields 必须是非空 JSON 数组");
+        fields = parsed;
+    }
+    catch (error) {
+        return invalid(`--fields 解析失败：${error instanceof Error ? error.message : String(error)}`);
+    }
+    const problems = validateFields(schemaCode, fields);
+    if (problems.length > 0)
+        return invalid(`--fields 有 ${problems.length} 处问题：\n  - ${problems.join("\n  - ")}`);
+    // 字典简写展开（dictCode → optionsSet.dictionary，含 id/记录解析）——展开失败
+    // 在任何写之前拒绝（名字对不上/无启用记录）。
+    let dictExpanded = 0;
+    if (fields.some((field) => typeof field.dictCode === "string")) {
+        const expandedResult = await expandDictShorthand(fields, environment, contextForTest, request);
+        if (expandedResult.problems.length > 0)
+            return invalid(`dictCode 展开失败（未写入）：\n  - ${expandedResult.problems.join("\n  - ")}`);
+        fields = expandedResult.fields;
+        dictExpanded = expandedResult.expanded.length;
+    }
+    const options = {
+        schemaCode, fields, apply, publishForm, addToList, forcePublish,
+        ...(environment !== undefined ? { environment } : {}),
+    };
+    // 零 wire 形状预检（与 model-scaffold 同层防线）：dry-run 走本地能力门。
+    const preflightProblems = [];
+    for (const field of fields) {
+        const probe = await runToolCall("field.create", {
+            args: { schemaCode, ...field },
+            requestId: request,
+            dryRun: true,
+            ...(environment !== undefined ? { environment } : {}),
+            ...(contextForTest !== undefined ? { context: contextForTest } : {}),
+            print: () => undefined,
+        });
+        const status = String(probe.result.status ?? "ok");
+        if (probe.exitCode !== 0 || (status !== "dry-run" && status !== "ok"))
+            preflightProblems.push({ code: String(field.code), message: refusalText(probe.result) });
+    }
+    if (preflightProblems.length > 0) {
+        writeEnvelope(envelope("error", {
+            status: "refused",
+            blocker: "field-add-preflight-failed",
+            schema: schemaCode,
+            written: false,
+            failed: preflightProblems.length,
+            preflightProblems,
+            message: `有 ${preflightProblems.length} 个字段的预检没过，**尚未写入任何东西**。` +
+                `按 message 改 --fields 后重跑（常见：NUMERICAL 缺 options.scale、自定义选项应用顶层 choices）。`,
+        }, request, { code: "policy-refused", message: "字段形状预检未通过（未写入）", retryable: false }));
+        return CLI_EXIT_CODES.policyRefused;
+    }
+    if (!apply) {
+        writeEnvelope(envelope("ok", {
+            status: "dry-run",
+            schema: schemaCode,
+            fields: fields.map((field) => String(field.code)),
+            ...(dictExpanded > 0 ? { dictExpanded } : {}),
+            steps: [
+                `field.create ×${fields.length}`,
+                "field.publish（发布失败/有字段失败则停）",
+                ...(publishForm ? [`form.publish ${schemaCode} --rebuild（重建让新字段进默认表单）`] : []),
+                ...(addToList ? [`listview.configure ${schemaCode} 增量追加列（保留既有列与条件）`] : []),
+            ],
+            preflight: { checked: fields.length, passed: true },
+            note: "dry-run 只列计划；已对每个字段跑过本地形状预检（零 wire）。--apply 依次执行全部步骤。",
+        }, request));
+        return CLI_EXIT_CODES.ok;
+    }
+    const steps = [];
+    const lastSummaries = [];
+    const call = async (tool, toolArgs) => {
+        const outcome = await runToolCall(tool, {
+            args: toolArgs,
+            requestId: request,
+            ...(environment !== undefined ? { environment } : {}),
+            ...(contextForTest !== undefined ? { context: contextForTest } : {}),
+            print: () => undefined,
+        });
+        const result = outcome.result;
+        if (outcome.exitCode === 0 && typeof result.summary === "string" && result.summary.length > 0)
+            lastSummaries.push(String(result.summary));
+        return { ok: outcome.exitCode === 0, result };
+    };
+    steps.push({ step: "preflight", status: "ok", detail: { checked: fields.length, wrote: false } });
+    // 1) 建字段：duplicate 记 skipped，其余失败继续跑完（一次看全）。
+    const failedFields = [];
+    const createdCodes = [];
+    for (const field of fields) {
+        const outcome = await call("field.create", { schemaCode, ...field });
+        const message = String(outcome.result.message ?? "");
+        if (outcome.ok) {
+            steps.push({ step: "field.create", status: "ok", detail: { schemaCode, code: String(field.code) } });
+            createdCodes.push(String(field.code));
+        }
+        else if (/已存在|duplicate/i.test(message)) {
+            steps.push({ step: "field.create", status: "skipped", detail: { schemaCode, code: String(field.code), reason: "already-present" } });
+            createdCodes.push(String(field.code)); // 已存在同样在发布面上，列表加列依然有意义
+        }
+        else {
+            const reason = refusalText(outcome.result);
+            failedFields.push({ code: String(field.code), message: reason });
+            steps.push({ step: "field.create", status: "failed", detail: { schemaCode, code: String(field.code), message: reason } });
+        }
+    }
+    // 2) 发布字段：半成品不发布。
+    const publishingBlocked = failedFields.length > 0 && !forcePublish;
+    let fieldPublishOk = false;
+    if (publishingBlocked) {
+        steps.push({
+            step: "field.publish",
+            status: "skipped",
+            detail: { reason: "有字段创建失败，默认不发布（用 --force-publish 强制）", failedFields: failedFields.map((entry) => entry.code) },
+        });
+    }
+    else {
+        const published = await call("field.publish", { schemaCode });
+        fieldPublishOk = published.ok;
+        steps.push({
+            step: "field.publish",
+            status: published.ok ? "ok" : "failed",
+            detail: published.ok ? { schemaCode } : { schemaCode, message: String(published.result.message ?? "") },
+        });
+    }
+    // 3) 表单重建：发布被挡/失败时同样不做（会把缺字段的布局烤进表单）。
+    if (publishForm && fieldPublishOk && !publishingBlocked) {
+        const published = await call("form.publish", { schemaCode, rebuild: true });
+        steps.push({
+            step: "form.publish",
+            status: published.ok ? "ok" : "failed",
+            detail: published.ok ? { schemaCode, rebuild: true } : { schemaCode, rebuild: true, message: String(published.result.message ?? "") },
+        });
+    }
+    else if (publishForm) {
+        steps.push({
+            step: "form.publish",
+            status: "skipped",
+            detail: { reason: publishingBlocked ? "有字段创建失败，默认不重建（--force-publish 可强发）" : "字段发布失败" },
+        });
+    }
+    // 4) 列表增量加列：默认合并语义保留既有列/条件/排序（r31 实证）；只有字段全部
+    //    失败才跳过（部分成功时把成功的列加上去仍有意义）。
+    if (addToList && createdCodes.length > 0 && !publishingBlocked) {
+        const configured = await call("listview.configure", { schemaCode, fieldCodes: createdCodes });
+        steps.push({
+            step: "listview.configure",
+            status: configured.ok ? "ok" : "failed",
+            detail: configured.ok
+                ? { schemaCode, appended: createdCodes, semantics: "增量合并：保留既有列/条件/排序" }
+                : { schemaCode, fieldCodes: createdCodes, message: String(configured.result.message ?? "") },
+        });
+    }
+    else if (addToList) {
+        steps.push({
+            step: "listview.configure",
+            status: "skipped",
+            detail: { reason: createdCodes.length === 0 ? "没有字段落到发布面" : "有字段创建失败，默认不动列表（--force-publish 可强发）" },
+        });
+    }
+    const failedSteps = steps.filter((step) => step.status === "failed");
+    const status = failedSteps.length > 0 ? "partial" : "ok";
+    const result = {
+        status,
+        schema: schemaCode,
+        fieldCount: fields.length,
+        created: steps.filter((step) => step.step === "field.create" && step.status === "ok").length,
+        skipped: steps.filter((step) => step.step === "field.create" && step.status === "skipped").length,
+        failed: failedFields.length,
+        ...(failedFields.length > 0 ? { failedFields } : {}),
+        ...(failedSteps.length > 0 ? { failedSteps } : {}),
+        ...(lastSummaries.length > 0 ? { summaries: lastSummaries } : {}),
+        steps,
+        folded: "field.create → field.publish → form.publish(rebuild) → listview.configure(增量) 4 写调合成 1 条命令",
+    };
+    const classified = classifyResult(status === "partial" ? { ...result, requested: steps.length, succeeded: steps.length - failedSteps.length } : result);
+    writeEnvelope(envelope(classified.status, result, request, classified.error));
+    return status === "partial" ? 1 : 0;
+}
+//# sourceMappingURL=field-add.js.map

package/dist/form-support.js

@@ -1147,6 +1147,15 @@ export async function executeFormDraftWrite(session, args) {
                 }
                 : {}),
             ...(args.rebuild === true && previousAttributes ? { rebuildPreservedControls } : {}),
+            // r36（2026-11-01）：rebuild 后草稿与重建前逐字节一致时明示——rebuild 的
+            // 语义就是"按已发布字段重搭"，一致通常意味着预期的新控件没进来（字段未
+            // 发布/写错槽位），静默 no-op 会让"新增字段后刷新表单"看起来成功实则没变。
+            ...(args.rebuild === true && previousAttributes !== undefined && typeof attributes === "string" && attributes.trim() === JSON.stringify(previousAttributes).trim()
+                ? {
+                    rebuildUnchanged: true,
+                    rebuildNote: "rebuild 后草稿与重建前完全一致——若你预期新增控件（新字段上表单），检查：① 字段是否已 field.publish；② 写入槽位 sheetCode 是否正确（省略=模型 code 槽位）；r36 实测同序列下重建静默 no-op。",
+                }
+                : {}),
         },
     };
 }