@stalfh233/omc-cli 0.4.40 → 0.4.42

package/coverage/m1-coverage-manifest-v1.json

@@ -905,10 +905,12 @@
       ],
       "lane": "online-js",
       "tools": [
-        "onlinejs.compose"
+        "onlinejs.compose",
+        "onlinejs.get"
       ],
       "scopes": [
-        "draft promotion publish verbatim readback"
+        "draft promotion publish verbatim readback",
+        "draft published script readback"
       ]
     },
     {
@@ -1276,4 +1278,4 @@
       ]
     }
   ]
-}
+}

package/dist/call.js

@@ -136,16 +136,22 @@ export async function runToolCall(toolName, options = {}) {
 }
 /**
  * The single stderr diagnostic line for a call result, or null when the result
- * is a bare success (the envelope already carries it). Errors keep their payload
- * because it is small and useful; a write's `summary` is the human-facing line.
+ * needs no human echo (the stdout envelope is the single machine truth). A
+ * write's `summary` is the human-facing line; errors keep their payload
+ * because it is small and useful. A DRY-RUN is a plan, not an error — its full
+ * body already lives in the envelope, and dumping it here doubled every
+ * dry-run payload on stderr (Windows live report 2026-10-14: two JSON lines,
+ * one raw + one escaped, read as "奇奇怪怪的乱码").
  */
 function humanResultLine(result) {
     if (typeof result.summary === "string" && result.summary.trim().length > 0)
         return result.summary;
     const status = String(result?.status ?? "ok");
-    if (status !== "ok")
-        return redact(result, []);
-    return null;
+    if (status === "ok" || status === "dry-run")
+        return null;
+    if (result?.blocker === undefined && status !== "error" && status !== "uncertain")
+        return null;
+    return redact(result, []);
 }
 export function validateAgentPaths(args) {
     const root = resolve(process.env.OMC_CONFIG_HOME ?? process.cwd());

package/dist/cli-contract.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { spawnSync } from "node:child_process";
 export const CLI_EXIT_CODES = {
     ok: 0,
     invalidInput: 10,
@@ -38,9 +39,33 @@ export function asciiStdout() {
         return true;
     if (override === "0")
         return false;
-    if (process.platform !== "win32")
+    return asciiStdoutFor(process.platform, process.stdout.isTTY === true, activeCodePage());
+}
+let cachedCodePage;
+function activeCodePage() {
+    if (cachedCodePage !== undefined)
+        return cachedCodePage;
+    cachedCodePage = null;
+    try {
+        const chcp = spawnSync("chcp.com", [], { encoding: "utf8" });
+        cachedCodePage = /([0-9]{3,5})\s*$/.exec((chcp.stdout || "").trim().split("\n").pop() ?? "")?.[1] ?? null;
+    }
+    catch {
+        // chcp unavailable (modern terminal hosts) — assume UTF-8 rather than
+        // forcing \u escapes the user cannot read (Windows live 2026-10-14).
+    }
+    return cachedCodePage;
+}
+/** Pure core of asciiStdout for tests: platform × tty × active code page. */
+export function asciiStdoutFor(platform, isTty, codePage) {
+    if (platform !== "win32")
+        return false;
+    if (isTty)
         return false;
-    return process.stdout.isTTY !== true;
+    // Unknown code page (chcp unavailable — modern terminal hosts): trust
+    // UTF-8. Windows Terminal defaults to it, and \u escapes are unreadable to
+    // humans either way.
+    return codePage !== null && codePage !== "65001";
 }
 export function serializeEnvelope(value) {
     const json = JSON.stringify(value);

package/dist/cli.js

@@ -30,6 +30,7 @@ import { listSkills, readSkill, readSkillSection } from "./skills.js";
 import { parseToolInput, ToolInputError } from "./tool-types.js";
 import { WireError, wireCall } from "./wire.js";
 import { ENDPOINTS } from "./endpoints.js";
+import { cmdRollbackList, cmdRollbackPlan, cmdRollbackApply } from "./rollback.js";
 async function ask(question) {
     const rl = createInterface({ input: stdin, output: process.stderr });
     try {
@@ -953,6 +954,16 @@ async function main() {
         }
         commandExitCode = await runScript(lines, { defaultEnv: options.env, continueOnError: options.continue === true });
     });
+    const rollbackCommand = command.command("rollback").description("配置回滚（git-revert 语义）：list 列写时间线 / plan 预览恢复（diff+后续写覆盖警告）/ apply 执行恢复——恢复走完整写闸门并记 journal（回滚可再回滚）。接入全部配置写面（workflow/规则/数据规则/视图/表单草稿/在线JS/字典/字段/模型/应用/报表）；publish 类生命周期推进不可逆（plan 会说明）；journal 与 before 快照为本机边界（不跨机器）");
+    rollbackCommand.command("list").option("--env <environment>").option("--environment <environment>").option("--target <substr>").option("--tool <name>").option("--limit <n>").action(async (options) => {
+        commandExitCode = await withTransport(options, "rollback list", (transport) => cmdRollbackList({ environment: options.env ?? options.environment, target: options.target, tool: options.tool, limit: options.limit }, transport));
+    });
+    rollbackCommand.command("plan <ref>").option("--env <environment>").option("--environment <environment>").action(async (ref, options) => {
+        commandExitCode = await withTransport(options, "rollback plan", (transport) => cmdRollbackPlan(ref, { environment: options.env ?? options.environment }, transport));
+    });
+    rollbackCommand.command("apply <ref>").option("--env <environment>").option("--environment <environment>").option("--confirm-production").action(async (ref, options) => {
+        commandExitCode = await withTransport(options, "rollback apply", (transport) => cmdRollbackApply(ref, { environment: options.env ?? options.environment, confirmProduction: options.confirmProduction === true }, transport));
+    });
     command.command("artifact").command("get <id>").option("--jq <path>").option("--path-only").option("--summary").option("--keys [a,b]").option("--max-output-bytes <bytes>").action(async (id, options) => {
         commandExitCode = await withTransport(options, request, (transport) => cmdArtifactGet(id, transport, { ...(options.jq ? { jq: options.jq } : {}), pathOnly: options.pathOnly === true, summary: options.summary === true || options.keys === true, ...(typeof options.keys === "string" ? { keys: options.keys } : {}) }));
     });

package/dist/form-support.js

@@ -274,7 +274,7 @@ export function redundantFieldCodes(fields) {
  * ("表单不存在！") when the model has no form row yet — that is absence, not a
  * failure, so callers get null and may create it.
  */
-async function readFormOrNull(session, schemaCode, sheetCode) {
+export async function readFormOrNull(session, schemaCode, sheetCode) {
     try {
         const result = await wireCall(session, { path: ENDPOINTS.sheetGet, query: { schemaCode, sheetCode } });
         return (result.data ?? null);
@@ -551,6 +551,26 @@ function controlCount(face) {
  * to bizsheet/update. Used by the form.draft write tool AND by configure_form,
  * so the high-level orchestrator never bypasses the scaffold.
  */
+/** Ticket 74 pure gate (no session): caller-provided "[]"/"{}" layouts refuse. */
+export function refuseEmptyCallerLayout(args) {
+    if (args.allowEmptyLayout === true)
+        return;
+    const emptyFaces = [];
+    if (typeof args.draftViewJson === "string" && isEmptyLayoutJson(args.draftViewJson))
+        emptyFaces.push("draftViewJson");
+    if (typeof args.draftAttributesJson === "string" && isEmptyLayoutJson(args.draftAttributesJson))
+        emptyFaces.push("draftAttributesJson");
+    if (emptyFaces.length === 0)
+        return;
+    throw new ToolRefusalError({
+        status: "refused",
+        blocker: "form-empty-layout",
+        schemaCode: args.schemaCode,
+        sheetCode: args.sheetCode,
+        faces: emptyFaces,
+        message: `显式提供的 ${emptyFaces.join("、")} 是空布局（"[]"/"{}"）——平台设计器 Save 会把草稿清成该形态（非无损），照写会丢控件。若确要清空布局请显式传 allowEmptyLayout:true；若是设计器 Save 后的修复，先用表单版本历史（/api/api/app/bizsheet/history/list）取回完好版本原文再写回`,
+    });
+}
 export async function executeFormDraftWrite(session, args) {
     if (args.draftHtmlJson !== undefined) {
         assertHtmlRender(args.draftHtmlJson, { schemaCode: args.schemaCode, sheetCode: args.sheetCode, face: "draftHtmlJson" });

package/dist/journal.js

@@ -0,0 +1,73 @@
+import { existsSync, mkdirSync, readFileSync, appendFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+/**
+ * Per-environment append-only journal of delivered governed config writes.
+ *
+ * Journal root = the SIBLING of the write-artifacts dir the governedWrite
+ * pipeline uses (ctx.artifactsDir, `<cwd>/.omc/artifacts` by default), so the
+ * timeline always lives next to the artifacts it references — one `.omc`
+ * home per project directory, independent of OMC_CONFIG_HOME /
+ * OMC_ARTIFACTS_HOME which govern the SEPARATE transport-spill artifact
+ * system (`omc artifact get`).
+ *
+ * Local-machine boundary (deliberate, v1): the journal and the before
+ * snapshots inside artifacts stay on the machine that performed the writes;
+ * teaching says so. A fresh machine has no rollback history.
+ */
+function journalRoot(artifactsDir) {
+    return join(resolve(artifactsDir), "..", "journal");
+}
+export function journalFile(environment, artifactsDir) {
+    return join(journalRoot(artifactsDir), `${environment}.ndjson`);
+}
+export function appendJournalEntry(artifactsDir, entry) {
+    const file = journalFile(entry.environment, artifactsDir);
+    mkdirSync(journalRoot(artifactsDir), { recursive: true });
+    const seq = countLines(file) + 1;
+    const full = { ...entry, seq, ts: new Date().toISOString() };
+    appendFileSync(file, `${JSON.stringify(full)}\n`, "utf8");
+    return full;
+}
+export function readJournal(environment, artifactsDir) {
+    const file = journalFile(environment, artifactsDir);
+    if (!existsSync(file))
+        return [];
+    const entries = [];
+    for (const line of readFileSync(file, "utf8").split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed === "")
+            continue;
+        try {
+            entries.push(JSON.parse(trimmed));
+        }
+        catch {
+            // A torn tail line (crash mid-append) must not hide the timeline.
+        }
+    }
+    return entries;
+}
+/** Resolve a `rollback plan/apply` reference: seq number or artifact id. */
+export function resolveJournalEntry(environment, ref, artifactsDir) {
+    const entries = readJournal(environment, artifactsDir);
+    const asSeq = Number(ref);
+    if (Number.isInteger(asSeq) && asSeq > 0) {
+        const bySeq = entries.find((entry) => entry.seq === asSeq);
+        if (bySeq)
+            return bySeq;
+    }
+    return entries.find((entry) => entry.artifactId === ref || entry.artifactFile === ref);
+}
+/** Writes recorded AFTER `seq` that touched the same target (clobber warning). */
+export function laterWritesOnTarget(environment, artifactsDir, seq, target) {
+    return readJournal(environment, artifactsDir).filter((entry) => entry.seq > seq && entry.target === target);
+}
+function countLines(file) {
+    if (!existsSync(file))
+        return 0;
+    let count = 0;
+    for (const line of readFileSync(file, "utf8").split("\n"))
+        if (line.trim() !== "")
+            count += 1;
+    return count;
+}
+//# sourceMappingURL=journal.js.map

package/dist/lanes/app.js

@@ -8,6 +8,26 @@ import { wireCall, wireRows } from "../wire.js";
 import { APP_LANE_CONTRACT } from "./app-contract.js";
 const APP_LANE = APP_LANE_CONTRACT.lane;
 const APP_TOOLS = APP_LANE_CONTRACT.tools;
+function appRollbackSpec(toolName) {
+    return {
+        target: (args) => `app:${String(args.code ?? "")}`,
+        read: async (session, args) => {
+            const row = (await wireCall(session, { path: ENDPOINTS.applicationGet, query: { appCode: String(args.code) } })).data;
+            return row && Object.keys(row).length > 0 ? row : null;
+        },
+        inverse: ({ before, args }) => {
+            const code = String(args.code);
+            if (toolName === "app.create")
+                return before == null ? { kind: "calls", calls: [{ tool: "app.delete", args: { code } }] } : { kind: "calls", calls: [], notes: ["应用已存在，create 未写入"] };
+            if (before == null)
+                return { kind: "calls", calls: [] };
+            const row = before;
+            if (toolName === "app.update")
+                return { kind: "calls", calls: [{ tool: "app.update", args: { code, groupId: String(row.groupId) } }] };
+            return { kind: "calls", calls: [{ tool: "app.create", args: { code, name: String(row.name ?? row.appName ?? code), ...(row.groupId ? { groupId: row.groupId } : {}) } }] };
+        },
+    };
+}
 /**
  * Portal visibility is group membership: the portal renders NAMED groups, and
  * an app parked in the fallback group (`code === "all"`, case-insensitive) is
@@ -115,7 +135,7 @@ export function registerAppLane(tools) {
                 note: "应用发布属边界外：建成后需人工在设计器发布并核对该分组，否则门户不可见",
             },
         };
-    });
+    }, undefined, undefined, appRollbackSpec("app.create"));
     writeTool(tools, "app.update", APP_LANE, APP_TOOLS["app.update"].scope, APP_TOOLS["app.update"].description, { code: z.string().min(1), groupId: z.string().min(1) }, async (session, args) => {
         const record = (await wireCall(session, { path: ENDPOINTS.applicationGet, query: { appCode: args.code } })).data;
         if (!record || (typeof record === "object" && Object.keys(record).length === 0))
@@ -155,7 +175,7 @@ export function registerAppLane(tools) {
                 portalHidden: portalHiddenByGroup,
             },
         };
-    });
+    }, undefined, undefined, appRollbackSpec("app.update"));
     writeTool(tools, "app.delete", APP_LANE, APP_TOOLS["app.delete"].scope, APP_TOOLS["app.delete"].description, { code: z.string().min(1) }, async (session, args) => {
         const readApps = async () => wireRows((await wireCall(session, { path: ENDPOINTS.applicationList, query: {} })).data);
         const target = (await readApps()).find((row) => (row.appCode ?? row.code) === args.code);
@@ -169,6 +189,6 @@ export function registerAppLane(tools) {
             absent = !(await readApps()).some((row) => (row.appCode ?? row.code) === args.code);
         }
         return { performed: { errcode: performed.errcode, code: args.code }, readback: { absent } };
-    });
+    }, undefined, undefined, appRollbackSpec("app.delete"));
 }
 //# sourceMappingURL=app.js.map

package/dist/lanes/businessrule.js

@@ -11,6 +11,29 @@ import { wireCall, wireRows } from "../wire.js";
 import { BUSINESSRULE_LANE_CONTRACT } from "./businessrule-contract.js";
 const RULE_LANE = BUSINESSRULE_LANE_CONTRACT.lane;
 const RULE_TOOLS = BUSINESSRULE_LANE_CONTRACT.tools;
+async function readRuleRollback(session, args) {
+    const id = await resolveRuleRowId(session, String(args.schemaCode), String(args.ruleCode));
+    if (!id)
+        return null;
+    const record = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id } })).data;
+    if (!record)
+        return null;
+    const parse = (value) => decodeJsonColumn(value, JSON_COLUMN_NULL_COALESCE);
+    return { schemaCode: record.schemaCode, ruleCode: record.code, name: record.name, nodeGraph: { nodes: parse(record.node), routes: parse(record.route), schedulerSetting: parse(record.schedulerSetting) } };
+}
+function businessRuleRollbackSpec(toolName) {
+    return {
+        target: (args) => `rule:${String(args.schemaCode ?? "")}/${String(args.ruleCode ?? "")}`,
+        read: readRuleRollback,
+        inverse: ({ before, args, readback }) => {
+            const base = { schemaCode: String(args.schemaCode), ruleCode: String(args.ruleCode) };
+            if (before == null)
+                return { kind: "calls", calls: [{ tool: "rule.delete", args: base }] };
+            const row = before;
+            return { kind: "calls", calls: [{ tool: "rule.save", args: { ...base, name: String(row.name ?? args.ruleCode), nodeGraph: row.nodeGraph } }], ...(toolName === "rule.node.update" ? { notes: ["节点级回退按整张 nodeGraph 恢复"] } : {}) };
+        },
+    };
+}
 /**
  * Deterministic layout keys the designer/canvas derives and `prepareRuleGraph`
  * re-injects on save: a node's `x/y/width/height` and a route's `points`. They
@@ -194,7 +217,7 @@ export function registerBusinessRuleLane(tools) {
         nodeGraph: ruleNodeGraphArg,
         publish: z.boolean().optional().describe("also publish the new version in this call (businessrule/publish) so the designer sees it; enabling stays with rule.enable — default false keeps the legacy draft-only save"),
         customTrigger: z.boolean().optional().describe("默认开：自定义 ruleCode + bizRuleType 0（非平台触发码 Create/Update/Delete/GetList/Load/Available/Cancel）即按钮/流程规则，工具在 START 后合成平台标准 CUSTOM_NODE「自定义按钮/流程触发」系统触发节点（nodeCode=ruleCode，live 布局 x558/y233）；调用方已写 CUSTOM_NODE 则原样保留；显式 false 退回"),
-    }, async (session, args) => executeRuleSaveWrite(session, args));
+    }, async (session, args) => executeRuleSaveWrite(session, args), undefined, undefined, businessRuleRollbackSpec("rule.save"));
     // Round 10 (issue 04) — precise modify. `rule.save` replaces the WHOLE nodeGraph,
     // so changing one branch threshold meant read the whole graph, edit, resend. This
     // tool reads the current graph, patches ONE node, and reuses the same save seam
@@ -229,6 +252,6 @@ export function registerBusinessRuleLane(tools) {
         const mergedNode = { ...target, ...args.patch };
         const mergedGraph = { nodes: nodeList.map((node) => (node.nodeCode === args.nodeCode ? mergedNode : node)), ...(Array.isArray(routes) ? { routes } : {}) };
         return executeRuleSaveWrite(session, { schemaCode: args.schemaCode, ruleCode: args.ruleCode, name: String(record.name ?? args.ruleCode), nodeGraph: mergedGraph, ...(args.publish === true ? { publish: true } : {}), ...(args.customTrigger === true ? { customTrigger: true } : {}) });
-    });
+    }, undefined, undefined, businessRuleRollbackSpec("rule.node.update"));
 }
 //# sourceMappingURL=businessrule.js.map

package/dist/lanes/datarule.js

@@ -562,6 +562,27 @@ async function listDataRules(session, schemaCode, dataRuleType) {
         query.dataRuleType = String(dataRuleType);
     return wireRows((await wireCall(session, { path: ENDPOINTS.dataRuleList, query })).data);
 }
+function dataruleRollbackSpec(toolName) {
+    return {
+        target: (args) => `datarule:${String(args.schemaCode ?? "")}/${Array.isArray(args.propertyCodes) ? args.propertyCodes.join("+") : String(args.propertyCode ?? "")}`,
+        read: async (session, args) => {
+            const codes = dataRuleTargetCodes({ propertyCode: args.propertyCode, propertyCodes: args.propertyCodes });
+            const rows = await listDataRules(session, String(args.schemaCode), args.dataRuleType);
+            return rows.filter((row) => storedTargetCodes(row).some((code) => codes.includes(code))).map(decodeDataRule);
+        },
+        inverse: ({ before, args }) => {
+            const rows = Array.isArray(before) ? before : [];
+            const schemaCode = String(args.schemaCode);
+            const codes = dataRuleTargetCodes({ propertyCode: args.propertyCode, propertyCodes: args.propertyCodes });
+            const locator = { schemaCode, propertyCode: codes.length === 1 ? codes[0] : undefined, propertyCodes: codes.length > 1 ? codes : undefined, dataRuleType: args.dataRuleType };
+            if (toolName === "datarule.create")
+                return rows.length === 0 ? { kind: "calls", calls: [{ tool: "datarule.delete", args: locator }] } : { kind: "calls", calls: [], notes: ["create 前已有匹配规则，未产生可归因的新行"] };
+            if (toolName === "datarule.delete")
+                return { kind: "calls", calls: rows.map((row) => ({ tool: "datarule.create", args: { schemaCode, propertyCode: row.propertyCode ?? undefined, propertyCodes: row.propertyCodes, dataRuleType: row.dataRuleType, options: row.options, ...(row.checkType != null ? { checkType: row.checkType } : {}), ...(row.childRule != null ? { childRule: row.childRule } : {}), ...(row.name != null ? { name: row.name } : {}), ...(row.sortKey != null ? { sortKey: row.sortKey } : {}) } })) };
+            return { kind: "calls", calls: rows.map((row) => ({ tool: "datarule.update", args: { schemaCode, ...(row.id != null ? { id: row.id } : {}), propertyCode: row.propertyCode ?? undefined, propertyCodes: row.propertyCodes, dataRuleType: row.dataRuleType, options: row.options, ...(row.checkType != null ? { checkType: row.checkType } : {}), ...(row.childRule != null ? { childRule: row.childRule } : {}), ...(row.name != null ? { name: row.name } : {}), ...(row.sortKey != null ? { sortKey: row.sortKey } : {}) } })) };
+        },
+    };
+}
 /**
  * Identity seam: resolve a data-rule row from either its physical `id` or the
  * business locator `(propertyCode, dataRuleType)`. The latter removes the forced
@@ -738,7 +759,7 @@ export function registerDataRuleLane(tools) {
         assertDataRuleTarget(args);
         assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
         assertDataRuleCheckType(args.dataRuleType, args.checkType);
-    });
+    }, undefined, dataruleRollbackSpec("datarule.create"));
     writeTool(tools, "datarule.update", DATARULE_LANE, DATARULE_TOOLS["datarule.update"].scope, DATARULE_TOOLS["datarule.update"].description, {
         id: z.string().min(1).optional().describe("数据规则记录 id；省略时可改用业务键 schemaCode + propertyCode(+dataRuleType) 定位"),
         schemaCode: z.string().min(1),
@@ -793,7 +814,7 @@ export function registerDataRuleLane(tools) {
         };
     }, (args) => {
         assertDataRuleOptions(args.dataRuleType, args.options, args.checkType);
-    });
+    }, undefined, dataruleRollbackSpec("datarule.update"));
     writeTool(tools, "datarule.delete", DATARULE_LANE, DATARULE_TOOLS["datarule.delete"].scope, DATARULE_TOOLS["datarule.delete"].description, {
         id: z.string().min(1).optional().describe("数据规则记录 id；省略时可改用业务键 schemaCode + propertyCode(+dataRuleType) 定位"),
         schemaCode: z.string().min(1),
@@ -813,6 +834,6 @@ export function registerDataRuleLane(tools) {
             performed: { errcode: performed.errcode },
             readback: { id, existedBefore: before !== undefined, absent: !after.some((row) => row.id === id) },
         };
-    });
+    }, undefined, undefined, dataruleRollbackSpec("datarule.delete"));
 }
 //# sourceMappingURL=datarule.js.map

package/dist/lanes/dictionary.js

@@ -10,6 +10,37 @@ const LANE = DICTIONARY_LANE_CONTRACT.lane;
 const TOOLS = DICTIONARY_LANE_CONTRACT.tools;
 const dictionaryType = z.union([z.literal(0), z.literal(1)]).describe("KEY_VALUE=0 or TREE=1");
 const nameI18n = z.record(z.string(), z.unknown()).optional();
+function dictionaryRollbackSpec(toolName) {
+    return {
+        target: (args) => toolName === "dictionary.save" ? `dictionary:${String(args.code ?? "")}` : `dictionary-class:${String(args.id ?? args.name ?? "")}`,
+        read: async (session, args) => {
+            if (toolName === "dictionary.save") {
+                const header = (await wireCall(session, { path: ENDPOINTS.dictionaryGetByCode, query: { code: String(args.code) } })).data;
+                if (!header || Object.keys(header).length === 0)
+                    return null;
+                const records = (await wireCall(session, { path: ENDPOINTS.dictionaryRecordsByCode, query: { code: String(args.code), searchWord: "", page: "1", size: "200" } })).data;
+                return { header, records: recordsPage(records).content };
+            }
+            const listed = (await wireCall(session, { path: ENDPOINTS.dictionaryClasses, query: {} })).data;
+            return Array.isArray(listed) ? listed.find((row) => String(row.id ?? "") === String(args.id ?? "") || String(row.name ?? "") === String(args.name ?? "")) ?? null : null;
+        },
+        inverse: ({ before, args }) => {
+            if (toolName === "dictionary.save") {
+                if (before == null)
+                    return { kind: "irreversible", reason: "平台无字典删除端点；可回滚内容：对后续 dictionary.save 的 before 执行 plan/apply" };
+                const snapshot = before;
+                const h = snapshot.header;
+                return { kind: "calls", calls: [{ tool: "dictionary.save", args: { code: h.code, name: h.name, ...(h.classificationId ? { classificationId: h.classificationId } : {}), records: snapshot.records } }] };
+            }
+            if (before == null)
+                return { kind: "calls", calls: [] };
+            const row = before;
+            if (toolName === "dictionary.class.save")
+                return { kind: "calls", calls: [{ tool: "dictionary.class.save", args: { id: row.id, name: row.name, dictionaryIds: row.dictionaryIds, sortKey: row.sortKey } }] };
+            return { kind: "calls", calls: [{ tool: "dictionary.class.save", args: { name: String(row.name), dictionaryIds: row.dictionaryIds, sortKey: row.sortKey } }] };
+        },
+    };
+}
 const recordSchema = z.object({
     id: z.string().optional(),
     code: z.string().min(1),
@@ -172,7 +203,7 @@ export function registerDictionaryLane(tools) {
             // failure must not turn a landed write into a failure.
         }
         return { performed: { errcode: performed.errcode }, readback: { present: Boolean(after && Object.keys(after).length > 0), dictionary: dictionaryView(after), records: recordsReadback } };
-    });
+    }, undefined, undefined, dictionaryRollbackSpec("dictionary.save"));
     writeTool(tools, "dictionary.status", LANE, TOOLS["dictionary.status"].scope, TOOLS["dictionary.status"].description, {
         target: z.enum(["dictionary", "record"]), id: z.string().min(1), status: z.boolean(),
     }, async (session, args) => {
@@ -222,7 +253,7 @@ export function registerDictionaryLane(tools) {
         const classes = Array.isArray(listed) ? listed : [];
         const saved = classes.find((entry) => entry.name === args.name && (args.id === undefined || entry.id === args.id)) ?? classes.find((entry) => entry.name === args.name);
         return { performed: { errcode: performed.errcode }, readback: { present: saved !== undefined, id: saved?.id, name: args.name, dictionaryIds: args.dictionaryIds ?? [] } };
-    });
+    }, undefined, undefined, dictionaryRollbackSpec("dictionary.class.save"));
     writeTool(tools, "dictionary.class.delete", LANE, TOOLS["dictionary.class.delete"].scope, TOOLS["dictionary.class.delete"].description, {
         ids: z.array(z.string().min(1)).min(1),
     }, async (session, args) => {
@@ -230,6 +261,6 @@ export function registerDictionaryLane(tools) {
         const body = args.ids.length === 1 ? { id: args.ids[0] } : { ids: args.ids };
         const performed = await wireCall(session, { path, method: "POST", body });
         return { performed: { errcode: performed.errcode, ids: args.ids }, readback: { absent: true, ids: args.ids } };
-    });
+    }, undefined, undefined, dictionaryRollbackSpec("dictionary.class.delete"));
 }
 //# sourceMappingURL=dictionary.js.map

package/dist/lanes/field-contract.js

@@ -180,7 +180,7 @@ export const FIELD_LANE_CONTRACT = Object.freeze({
             scope: "create publish readback",
             description: describeTool("Update an existing field (bizproperty/update) — merges `options` (and optional `choices`/`relativeCode`) onto the current draft/published record.", [
                 "**不切换 propertyType**：field.update 传 propertyType 会被静默忽略（errcode 0 但类型不变，r6 实证 2026-10-10）——已发布字段改类型只能 field.delete + field.create 重建（含关联 mappings 的同类型对齐场景：人员单选只能映射给人员单选）。choices 只对文本单选族（RADIO/DROPDOWN_BOX 等）合法，传给其它类型会被出门校验拒。",
-                "Use it to add relation `mappings` (source/target carry-through) or change field options.",
+                "Use it to add relation `mappings` (source/target carry-through) or change field options. **关联填充映射的事实源是字段行 `options.mappings`**（真机 2026-10-14 中冶实证：改表单控件属性里的 mappings 会被平台按字段重算覆盖、回读不生效）。改映射的正确链：`field.update` 按完整 options 提交（只改 mappings，其余键 queryCode/displayField/schemaCode/conditions… 原值保留）→ `field.publish` → 已发布表单重派生一次：`form.draft`（**rebuild:false**，保留现有布局与已挂在线JS）重存 → `form.publish` → 回读核对。**不要用 field.update 的 cascadeRepublish 刷已带自定义布局/在线JS 的表单**——它会 rebuild 脚手架，可能动到现有自定义布局（rebuild:false 手动链才安全）。",
                 "A relation's display field is the field-row top-level `relativePropertyCode` (options.displayField is mirrored but not what the runtime reads); the tool rewrites it when you pass a new displayField.",
                 "表单条件（`options.requiredFormula`（必填）/`readonlyCondition`（只读）/`displayFormula`（显示））会**自动配对**一条 `bizdatarule` type3/4/5 行：门户**运行时**读字段 options，表单设计器**设计态** Set/Unset 读 `bizdatarule/list`——只写 options 会让设计器显示 Unset。readback.formConditionSync 报 created/updated/deleted/skipped；清空条件传空串（如 requiredFormula:\"\"）会同时删规则行；字段未发布时只写 options 并在 skipped 说明原因。",
                 "Re-publish with field.publish for the change to take effect — or pass `cascadeRepublish:true` for the one-call chain: field.update → field.publish → form.draft(rebuild) → form.publish(force). The cascade re-scaffolds the default form from the published fields (non-structural control options are preserved); there is no cross-endpoint transaction, so a mid-chain failure is reported honestly as partial (status:partial) with steps/failedStep/envelope (the completed prefix stays).",

package/dist/lanes/field.js

@@ -15,6 +15,32 @@ import { FIELD_LANE_CONTRACT } from "./field-contract.js";
 import { mapBounded } from "../support.js";
 const FIELD_LANE = FIELD_LANE_CONTRACT.lane;
 const FIELD_TOOLS = FIELD_LANE_CONTRACT.tools;
+async function readFieldRollback(session, args) {
+    for (const published of [false, true]) {
+        const row = wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: String(args.schemaCode), isPublish: String(published) } })).data).find((entry) => String(entry.code ?? entry.propertyCode) === String(args.code));
+        if (row)
+            return row;
+    }
+    return null;
+}
+function fieldRollbackSpec(toolName) {
+    return {
+        target: (args) => `field:${String(args.schemaCode ?? "")}/${String(args.code ?? "")}`,
+        read: readFieldRollback,
+        inverse: ({ before, args }) => {
+            const schemaCode = String(args.schemaCode), code = String(args.code);
+            if (toolName === "field.create")
+                return before == null ? { kind: "calls", calls: [{ tool: "field.delete", args: { schemaCode, code } }] } : { kind: "calls", calls: [], notes: ["字段已存在，create 未写入"] };
+            if (before == null)
+                return { kind: "calls", calls: [] };
+            const row = before;
+            const options = row.options !== undefined ? decodeJsonColumn(row.options, JSON_COLUMN_PASSTHROUGH) : undefined;
+            if (toolName === "field.delete")
+                return { kind: "calls", calls: [{ tool: "field.create", args: { schemaCode, code, name: String(row.name ?? code), propertyType: String(row.propertyType ?? row.type), ...(options !== undefined ? { options } : {}), ...(row.choices !== undefined ? { choices: row.choices } : {}), ...(row.relativeCode !== undefined ? { relativeCode: row.relativeCode } : {}), ...(row.subFields !== undefined ? { subFields: row.subFields } : {}) } }] };
+            return { kind: "calls", calls: [{ tool: "field.update", args: { schemaCode, code, ...(row.name !== undefined ? { name: row.name } : {}), ...(row.name_i18n !== undefined ? { name_i18n: row.name_i18n } : {}), ...(options !== undefined ? { options } : {}), ...(row.choices !== undefined ? { choices: row.choices } : {}), ...(row.relativeCode !== undefined ? { relativeCode: row.relativeCode } : {}), ...(row.subFields !== undefined ? { subFields: row.subFields } : {}), ...(row.propertyEmpty !== undefined ? { propertyEmpty: row.propertyEmpty } : {}) } }] };
+        },
+    };
+}
 /** Parse a raw options JSON string for readback; policy: non-strings and unparseable strings pass through verbatim. */
 function parseFieldOptionsForReadback(options) {
     return decodeJsonColumn(options, JSON_COLUMN_PASSTHROUGH);
@@ -210,7 +236,7 @@ export function registerFieldLane(tools) {
             performed: { errcode: performed.errcode },
             readback: { draftFieldPresent: rows.some((row) => (row.code ?? row.propertyCode) === args.code) },
         };
-    });
+    }, undefined, undefined, fieldRollbackSpec("field.create"));
     writeTool(tools, "field.update", FIELD_LANE, FIELD_TOOLS["field.update"].scope, FIELD_TOOLS["field.update"].description, {
         schemaCode: z.string().min(1),
         code: z.string().min(1),
@@ -230,7 +256,7 @@ export function registerFieldLane(tools) {
         if (args.cascadeRepublish !== true)
             return outcome;
         return runFieldUpdateCascade(session, args, outcome);
-    }, (args) => assertNameI18nArg(args.name_i18n));
+    }, (args) => assertNameI18nArg(args.name_i18n), undefined, fieldRollbackSpec("field.update"));
     writeTool(tools, "field.publish", FIELD_LANE, FIELD_TOOLS["field.publish"].scope, FIELD_TOOLS["field.publish"].description, {
         schemaCode: z.string().min(1),
         code: z.string().min(1).optional().describe("optional single field to verify on the published face"),
@@ -246,7 +272,7 @@ export function registerFieldLane(tools) {
         const published = await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "true" } });
         const gone = (value) => !wireRows(value).some((row) => (row.code ?? row.propertyCode) === args.code);
         return { performed: { errcode: performed.errcode }, readback: { absentDraft: gone(draft.data), absentPublished: gone(published.data) } };
-    });
+    }, undefined, undefined, fieldRollbackSpec("field.delete"));
 }
 /** The proven field.update write body — shared by the write tool and the cascade path. */
 async function runFieldUpdate(session, args) {

package/dist/lanes/form-contract.js

@@ -18,7 +18,7 @@ export const FORM_WIRE = Object.freeze({
     actionsColumns: "ticket 100: draftActionsJson/publishedActionsJson are REAL bizsheet columns (BizForm.java:95-100 @SerializableField; BizFormModel.java:59-62 serialized by bizsheet/get) — the designer writes draftActionsJson on save and both faces on publish (frontend-dist/admin/js/4280.cfa75764.js offsets 193538/185347); form.get full:true surfaces them; publish promotes draftActionsJson → publishedActionsJson",
 });
 const FORM_GET_DESCRIPTION = '读取默认表单（bizsheet/get）的发布状态与控件清单（紧凑默认）。**发布态以返回的 `published` / `existDraft` 布尔为准**（`published:true`=已发布；`published:false,existDraft:true`=只有草稿，**未发布**）——不要用 `publishedControlCodes` 是否非空来推断（草稿字段会让它非空，误判为已发布）。**每个模型交付前其默认表单必须 `published:true`**：用 `configure_form` 或 `form.draft(rebuild:true)`+`form.publish` 发布，并逐模型 `form.get` 核对。传 `controls:["code",…]` 只取指定控件的 options（如关联控件的 mappings）；传 `full:true` 才返回 draft/published 的完整 view/attributes/html/actions JSON（actions 列为设计器保存/发布的表单级按钮动作）。体积大，仅在需要整体布局时用。';
-const FORM_DRAFT_DESCRIPTION = "Save the default-form DRAFT (bizsheet/update). Reads the current sheet, merges the caller's explicit draftViewJson/draftAttributesJson (or preserves the existing draft); when both are absent on a fresh default form, composes the designer-standard scaffold from the model's published fields. A redundant field (relation-mapping carry-through target) always stays bound; with no workflow it is hidden in the design (options.visible=false), with a workflow it stays visible for per-node propertyPermissions. Pass `draftHtmlJson` to thread custom online-script HTML through. Empty-layout guard: explicitly passing \"[]\"/\"{}\" view/attributes is refused (form-empty-layout) — the platform designer's Save is NOT lossless and clears drafts to exactly that shape; escape with allowEmptyLayout:true, and recover cleared drafts from the form version history (/api/api/app/bizsheet/history/list).";
+const FORM_DRAFT_DESCRIPTION = "Save the default-form DRAFT (bizsheet/update). Reads the current sheet, merges the caller's explicit draftViewJson/draftAttributesJson (or preserves the existing draft); when both are absent on a fresh default form, composes the designer-standard scaffold from the model's published fields. A redundant field (relation-mapping carry-through target) always stays bound; with no workflow it is hidden in the design (options.visible=false), with a workflow it stays visible for per-node propertyPermissions. Pass `draftHtmlJson` to thread custom online-script HTML through. Empty-layout guard: explicitly passing \"[]\"/\"{}\" view/attributes is refused (form-empty-layout) — the platform designer's Save is NOT lossless and clears drafts to exactly that shape; escape with allowEmptyLayout:true, and recover cleared drafts from the form version history (/api/api/app/bizsheet/history/list). **表单控件属性（含关联填充 mappings）从字段行派生**：改关联映射的事实源在字段 options.mappings（field.update → field.publish），直接改这里的控件映射会被平台按字段重算覆盖（真机 2026-10-14 实证）；字段发布后如需刷新已发布表单的控件映射，用本工具 rebuild:false 重存（保留现有布局与在线JS）再 form.publish。";
 const FORM_PUBLISH_DESCRIPTION = "Publish the default form (bizsheet/publish, proven shape: draft*Json promoted to published*Json verbatim) with published-face readback. Degrade guard: refuses to promote a draft carrying FEWER controls than the published face (form-publish-degrade) — the designer's Save clears drafts non-losslessly; recover via the form version history (/api/api/app/bizsheet/history/list) and rewrite the draft first, or pass allowDegrade:true to force the reduction. rebuild:true is the one-call refresh: discard the existing draft, re-scaffold from the published fields (non-structural control options preserved), then force-promote — use it after a field shape change.";
 const CONFIGURE_FORM_DESCRIPTION = "High-level: bind fields into the default form and publish it (form.draft → form.publish), subject to the write permission gate. Delegates to the proven form.draft scaffold + form.publish paths so the real empty-form layout (and any caller-supplied draftHtmlJson) is persisted and promoted — never bypasses with a shortcut body. `sheetCode` is optional: omitted means the model's default sheet (sheetCode = schemaCode).";
 export const FORM_LANE_CONTRACT = Object.freeze({

package/dist/lanes/form.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { ENDPOINTS } from "../endpoints.js";
-import { executeFormDraftWrite, executeFormPublishWrite, validateHtmlRender } from "../form-support.js";
+import { executeFormDraftWrite, executeFormPublishWrite, readFormOrNull, refuseEmptyCallerLayout, validateHtmlRender } from "../form-support.js";
 import { capabilityArg, environmentArg } from "../args.js";
 import { governedRead } from "../read.js";
 import { writeTool } from "../write.js";
@@ -127,7 +127,24 @@ export function registerFormLane(tools) {
         fieldCodes: z.array(z.string().min(1)).optional().describe("脚手架绑定的已发布字段（按此顺序）；由 configure_form/intent 显式传入"),
         rebuild: z.boolean().optional().describe("true 时丢弃现有草稿布局，按已发布字段重新生成（新增字段/子表要用它；默认保留现有草稿）"),
         allowEmptyLayout: z.boolean().optional().describe("显式放行空布局（\"[]\"/\"{}\"）写入；默认拒绝（form-empty-layout），防设计器 Save 清空后照写丢控件"),
-    }, async (session, args) => executeFormDraftWrite(session, { ...args, sheetCode: resolveSheetCode(args.schemaCode, args.sheetCode) }));
+    }, async (session, args) => executeFormDraftWrite(session, { ...args, sheetCode: resolveSheetCode(args.schemaCode, args.sheetCode) }), (args) => {
+        // Zero-wire refusal (ticket 74): fires in semanticGate BEFORE the
+        // governed pipeline — including the rollback before-capture read.
+        refuseEmptyCallerLayout({ ...args, sheetCode: resolveSheetCode(args.schemaCode, args.sheetCode) });
+    }, undefined, {
+        target: (args) => `form:${String(args.schemaCode ?? "")}/${String(args.sheetCode ?? args.schemaCode ?? "")}`,
+        read: (session, args) => readFormOrNull(session, String(args.schemaCode), resolveSheetCode(String(args.schemaCode), args.sheetCode)),
+        inverse: ({ before, args }) => {
+            if (before == null)
+                return { kind: "irreversible", reason: "表单写入前不存在；平台没有删除表单端点，无法撤销创建" };
+            const row = before;
+            const restored = { schemaCode: String(args.schemaCode), sheetCode: resolveSheetCode(String(args.schemaCode), args.sheetCode) };
+            for (const key of ["draftViewJson", "draftAttributesJson", "draftHtmlJson"])
+                if (typeof row[key] === "string")
+                    restored[key] = row[key];
+            return { kind: "calls", calls: [{ tool: "form.draft", args: restored }] };
+        },
+    });
     writeTool(tools, "form.publish", FORM_LANE, FORM_TOOLS["form.publish"].scope, FORM_TOOLS["form.publish"].description, {
         schemaCode: z.string().min(1),
         sheetCode: z.string().min(1).optional().describe("表单槽位码；省略时默认 = schemaCode（模型码即默认表单槽位）"),