@stalfh233/omc-cli 0.4.14 → 0.4.16

package/dist/lanes/field.js

@@ -10,6 +10,7 @@ import { syncFormConditionDataRules } from "./datarule.js";
 import { FORM_CONDITION_OPTION_KEYS } from "./datarule-protocol.js";
 import { defineTool, ToolRefusalError } from "../tool-types.js";
 import { wireCall, wireRows, WireError } from "../wire.js";
+import { executeFormDraftWrite, executeFormPublishWrite } from "../form-support.js";
 import { FIELD_LANE_CONTRACT } from "./field-contract.js";
 const FIELD_LANE = FIELD_LANE_CONTRACT.lane;
 const FIELD_TOOLS = FIELD_LANE_CONTRACT.tools;
@@ -181,184 +182,21 @@ export function registerFieldLane(tools) {
         relativeCode: relativeCodeArg,
         subFields: subFieldArg,
         propertyEmpty: z.boolean().optional().describe("覆盖数据模型层的不可为空声明；传 false 可把历史误建的字段改回可为空（必填/只读应在表单与流程节点配置）"),
+        cascadeRepublish: z
+            .boolean()
+            .optional()
+            .describe("true 时一调级联生效：field.update → field.publish → form.draft(rebuild) → form.publish(force)。表单按 published fields 全量重建默认表单脚手架（保留 non-structural 控件 options）；无跨端点事务，中途失败按 partial steps（failedStep+envelope）如实报告，默认不级联"),
     }, async (session, args) => {
-        const listed = await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "false" } });
-        let rows = wireRows(listed.data);
-        if (!rows.some((row) => (row.code ?? row.propertyCode) === args.code)) {
-            const published = await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "true" } });
-            rows = wireRows(published.data);
-        }
-        const record = rows.find((row) => (row.code ?? row.propertyCode) === args.code);
-        if (!record)
-            throw new WireError("business", `field ${args.code} not found on ${args.schemaCode}`, 301001);
-        const update = {
-            schemaCode: args.schemaCode,
-            code: args.code,
-            base: record,
-            ...(args.name !== undefined ? { name: args.name } : {}),
-            ...(args.name_i18n !== undefined ? { name_i18n: args.name_i18n } : {}),
-            ...(args.options !== undefined ? { options: args.options } : {}),
-            ...(args.choices !== undefined ? { choices: args.choices } : {}),
-            ...(args.relativeCode !== undefined ? { relativeCode: args.relativeCode } : {}),
-            ...(args.subFields !== undefined ? { subFields: args.subFields } : {}),
-            ...(args.propertyEmpty !== undefined ? { propertyEmpty: args.propertyEmpty } : {}),
-        };
-        const prepared = prepareFieldUpdate(update);
-        const performed = await wireCall(session, { path: ENDPOINTS.fieldUpdate, method: "POST", body: fieldUpdateWireBody(update, prepared) });
-        const readback = await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "false" } });
-        const after = wireRows(readback.data).find((row) => (row.code ?? row.propertyCode) === args.code);
-        // Round 4 (B): a form-interaction condition must exist on BOTH faces to be
-        // complete — field options (portal runtime) AND a bizdatarule type3/4/5
-        // row (designer design-time Set/Unset). field.update historically wrote
-        // only options, so CLI-authored conditions showed "Unset" in the designer.
-        // Pair the changed condition key(s) into the rule projection; a sync
-        // failure never hides the field write (it is surfaced as formConditionSync.error).
-        let formConditionSync;
-        let formConditionSyncError;
-        if (args.options !== undefined && !prepared.isChildTable) {
-            const previous = decodeJsonObjectColumn(record.options, { invalid: "throw", array: "accept", object: "accept" }) ?? {};
-            try {
-                const sync = await syncFormConditionDataRules(session, args.schemaCode, args.code, previous, prepared.options);
-                if (sync.created.length + sync.updated.length + sync.deleted.length + sync.skipped.length > 0)
-                    formConditionSync = sync;
-            }
-            catch (error) {
-                formConditionSyncError = error instanceof Error ? error.message : String(error);
-            }
-        }
-        // Round 4: echo the EFFECTIVE stored options (parsed), not just presence.
-        // An agent setting readonlyFormula/requiredFormula/scale had no way to
-        // confirm the write landed — the readback only named the field. Field
-        // options are the form-interaction contract (ADR 0005), so read them back.
-        const storedOptions = after !== undefined ? parseFieldOptionsForReadback(after.options) : undefined;
-        return {
-            performed: { errcode: performed.errcode },
-            readback: {
-                fieldPresent: after !== undefined,
-                ...(after?.name !== undefined ? { name: after.name } : {}),
-                ...(typeof after?.name_i18n === "string" ? { name_i18n: after.name_i18n } : {}),
-                ...(after?.type !== undefined || after?.propertyType !== undefined ? { type: after?.type ?? after?.propertyType } : {}),
-                ...(storedOptions !== undefined && storedOptions !== null ? { options: storedOptions } : {}),
-                ...(formConditionSync !== undefined ? { formConditionSync } : {}),
-                ...(formConditionSyncError !== undefined ? { formConditionSync: { error: formConditionSyncError } } : {}),
-            },
-        };
+        const outcome = await runFieldUpdate(session, args);
+        if (args.cascadeRepublish !== true)
+            return outcome;
+        return runFieldUpdateCascade(session, args, outcome);
     }, (args) => assertNameI18nArg(args.name_i18n));
     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"),
         codes: z.array(z.string().min(1)).optional().describe("optional list of fields to verify; publishing is model-scoped, do NOT call once per field"),
-    }, async (session, args) => {
-        // bizproperty/publish is MODEL-SCOPED: one call publishes every draft
-        // field of the schema. `code`/`codes` only select which fields to verify
-        // on the published face after the single publish; omit them to publish
-        // and read back all codes (the batch path).
-        //
-        // Ticket 81 idempotent retry: with explicit code/codes, read the
-        // published face FIRST (a retry after a timeout hits the wire read
-        // cache — zero extra wires) and skip the publish POST entirely when
-        // every requested field is already published. A genuinely missing
-        // field still drives the publish.
-        const requestedCodes = [...(args.code ? [args.code] : []), ...(args.codes ?? [])];
-        const codeOf = (row) => String(row.code ?? row.propertyCode ?? "");
-        // cpdocs base3.0 parity (cp-bizproperty verifyPlan): presence on the
-        // published LIST face is proven later, against a map of each field's
-        // pre-publish DRAFT shape (name + type). The draft face must be
-        // snapshotted BEFORE the publish because a model-scoped publish can leave
-        // it empty; the draft row is the caller-visible expectation.
-        const draftSnapshot = new Map(wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "false" } })).data)
-            .map((row) => [codeOf(row), { name: String(row.name ?? ""), propertyType: Number(row.type ?? row.propertyType) }]));
-        const verifyFieldDetails = async (targets) => {
-            const bounded = targets.slice(0, 25);
-            const mismatches = [];
-            for (const code of bounded) {
-                const expected = draftSnapshot.get(code);
-                if (!expected)
-                    continue;
-                let detail;
-                try {
-                    detail = (await wireCall(session, { path: ENDPOINTS.fieldGet, query: { schemaCode: args.schemaCode, propertyCode: code } })).data;
-                }
-                catch {
-                    // The detail endpoint is optional across builds: report the
-                    // verification as unavailable rather than failing the publish.
-                    return { mode: "unavailable", verified: false, note: "bizproperty/get 不可用，字段详情未核对（仅列表面存在性）" };
-                }
-                const actual = { name: String(detail.name ?? ""), propertyType: Number(detail.propertyType ?? detail.type) };
-                if (actual.name !== expected.name || actual.propertyType !== expected.propertyType)
-                    mismatches.push({ code, expected, actual });
-            }
-            return { mode: "detail", verified: true, checked: bounded.length, ok: mismatches.length === 0, ...(mismatches.length > 0 ? { mismatches } : {}) };
-        };
-        const preRead = await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "true" } });
-        const prePublished = wireRows(preRead.data).map(codeOf).filter((code) => code.length > 0);
-        if (requestedCodes.length > 0 && requestedCodes.every((code) => prePublished.includes(code))) {
-            return {
-                performed: { skipped: "already-published", scope: "model" },
-                readback: {
-                    publishedCodes: prePublished,
-                    ...(args.code ? { publishedFieldPresent: true } : {}),
-                    ...(args.codes ? { publishedFieldsPresent: Object.fromEntries(args.codes.map((code) => [code, true])) } : {}),
-                    allRequestedPresent: true,
-                    verification: await verifyFieldDetails(requestedCodes),
-                },
-            };
-        }
-        // Ticket 79 live-fidelity (docker log evidence, 2026-09-13 21:43-21:45,
-        // cloud8_launcher log_error.log + nginx access timings): under DB
-        // connection-pool contention a model publish can fail with a transient
-        // `表单:<t>_<schema>不存在列:<col>` 50000 — the addIndexes/updateColumns
-        // assert reads the serializer view while the failed attempt's DDL
-        // auto-commits, so the state SELF-HEALS across retries (live: three
-        // consecutive attempts each healed one column, the fourth succeeded).
-        // Retry that exact signature up to 3 attempts; anything else rethrows.
-        let performed;
-        // Backoff matches the observed healing cadence on the small env (live:
-        // attempts ~25s/73s apart each reconciled one column).
-        const backoffMs = [2000, 5000];
-        for (let attempt = 1; attempt <= 3; attempt++) {
-            try {
-                performed = await wireCall(session, {
-                    path: ENDPOINTS.fieldPublish,
-                    method: "POST",
-                    body: { bizSchemaCode: args.schemaCode, sendMessage: false },
-                });
-                break;
-            }
-            catch (error) {
-                const transientColumnSync = error instanceof WireError && error.kind === "business" && error.errcode === 50000 && error.message.includes("不存在列");
-                if (!(transientColumnSync && attempt < 3))
-                    throw error;
-                await new Promise((resolve) => setTimeout(resolve, backoffMs[attempt - 1] ?? 5000));
-            }
-        }
-        const publishOutcome = performed;
-        const readback = await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "true" } });
-        const publishedCodes = wireRows(readback.data).map(codeOf).filter((code) => code.length > 0);
-        const requested = [...(args.code ? [args.code] : []), ...(args.codes ?? [])];
-        const present = requested.filter((code) => publishedCodes.includes(code));
-        const targets = (requested.length > 0 ? requested : [...draftSnapshot.keys()]).filter((code) => publishedCodes.includes(code));
-        const verification = await verifyFieldDetails(targets);
-        const mismatches = verification.mismatches;
-        if (mismatches !== undefined)
-            throw new ToolRefusalError({
-                status: "refused",
-                blocker: "field-publish-readback-mismatch",
-                performed: { errcode: publishOutcome.errcode, scope: "model" },
-                mismatches,
-                message: `字段已发布，但发布后详情回读与草稿面不一致（${mismatches.map((item) => String(item.code)).join("、")}）：这是元数据与预期形状相异的信号，先核对再决定后续；不要当作成功`,
-            });
-        return {
-            performed: { errcode: publishOutcome.errcode, scope: "model" },
-            readback: {
-                publishedCodes,
-                ...(args.code ? { publishedFieldPresent: publishedCodes.includes(args.code) } : {}),
-                ...(args.codes ? { publishedFieldsPresent: Object.fromEntries(args.codes.map((code) => [code, publishedCodes.includes(code)])) } : {}),
-                ...(requested.length > 0 ? { allRequestedPresent: present.length === requested.length } : {}),
-                verification,
-            },
-        };
-    });
+    }, async (session, args) => executeFieldPublish(session, args));
     writeTool(tools, "field.delete", FIELD_LANE, FIELD_TOOLS["field.delete"].scope, FIELD_TOOLS["field.delete"].description, { schemaCode: z.string().min(1), code: z.string().min(1) }, async (session, args) => {
         const performed = await wireCall(session, {
             path: ENDPOINTS.fieldForceDelete,
@@ -371,4 +209,262 @@ export function registerFieldLane(tools) {
         return { performed: { errcode: performed.errcode }, readback: { absentDraft: gone(draft.data), absentPublished: gone(published.data) } };
     });
 }
+/** The proven field.update write body — shared by the write tool and the cascade path. */
+async function runFieldUpdate(session, args) {
+    const listed = await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "false" } });
+    let rows = wireRows(listed.data);
+    if (!rows.some((row) => (row.code ?? row.propertyCode) === args.code)) {
+        const published = await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "true" } });
+        rows = wireRows(published.data);
+    }
+    const record = rows.find((row) => (row.code ?? row.propertyCode) === args.code);
+    if (!record)
+        throw new WireError("business", `field ${args.code} not found on ${args.schemaCode}`, 301001);
+    const update = {
+        schemaCode: args.schemaCode,
+        code: args.code,
+        base: record,
+        ...(args.name !== undefined ? { name: args.name } : {}),
+        ...(args.name_i18n !== undefined ? { name_i18n: args.name_i18n } : {}),
+        ...(args.options !== undefined ? { options: args.options } : {}),
+        ...(args.choices !== undefined ? { choices: args.choices } : {}),
+        ...(args.relativeCode !== undefined ? { relativeCode: args.relativeCode } : {}),
+        ...(args.subFields !== undefined ? { subFields: args.subFields } : {}),
+        ...(args.propertyEmpty !== undefined ? { propertyEmpty: args.propertyEmpty } : {}),
+    };
+    const prepared = prepareFieldUpdate(update);
+    const performed = await wireCall(session, { path: ENDPOINTS.fieldUpdate, method: "POST", body: fieldUpdateWireBody(update, prepared) });
+    const readback = await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "false" } });
+    const after = wireRows(readback.data).find((row) => (row.code ?? row.propertyCode) === args.code);
+    // Round 4 (B): a form-interaction condition must exist on BOTH faces to be
+    // complete — field options (portal runtime) AND a bizdatarule type3/4/5
+    // row (designer design-time Set/Unset). field.update historically wrote
+    // only options, so CLI-authored conditions showed "Unset" in the designer.
+    // Pair the changed condition key(s) into the rule projection; a sync
+    // failure never hides the field write (it is surfaced as formConditionSync.error).
+    let formConditionSync;
+    let formConditionSyncError;
+    if (args.options !== undefined && !prepared.isChildTable) {
+        const previous = decodeJsonObjectColumn(record.options, { invalid: "throw", array: "accept", object: "accept" }) ?? {};
+        try {
+            const sync = await syncFormConditionDataRules(session, args.schemaCode, args.code, previous, prepared.options);
+            if (sync.created.length + sync.updated.length + sync.deleted.length + sync.skipped.length > 0)
+                formConditionSync = sync;
+        }
+        catch (error) {
+            formConditionSyncError = error instanceof Error ? error.message : String(error);
+        }
+    }
+    // Round 4: echo the EFFECTIVE stored options (parsed), not just presence.
+    // An agent setting readonlyFormula/requiredFormula/scale had no way to
+    // confirm the write landed — the readback only named the field. Field
+    // options are the form-interaction contract (ADR 0005), so read them back.
+    const storedOptions = after !== undefined ? parseFieldOptionsForReadback(after.options) : undefined;
+    return {
+        performed: { errcode: performed.errcode },
+        readback: {
+            fieldPresent: after !== undefined,
+            ...(after?.name !== undefined ? { name: after.name } : {}),
+            ...(typeof after?.name_i18n === "string" ? { name_i18n: after.name_i18n } : {}),
+            ...(after?.type !== undefined || after?.propertyType !== undefined ? { type: after?.type ?? after?.propertyType } : {}),
+            ...(storedOptions !== undefined && storedOptions !== null ? { options: storedOptions } : {}),
+            ...(formConditionSync !== undefined ? { formConditionSync } : {}),
+            ...(formConditionSyncError !== undefined ? { formConditionSync: { error: formConditionSyncError } } : {}),
+        },
+    };
+}
+/**
+ * The proven field.publish write body. Shared by the field.publish write tool
+ * and the field.update cascade path — a cascade must never bypass the
+ * already-published short-circuit semantics, the transient-column retry, or
+ * the post-publish detail verification by inlining a bare wire call.
+ * `force:true` (cascade only) skips the already-published short-circuit: a
+ * cascaded republish exists precisely because the PUBLISHED face carries the
+ * stale shape while the field is present there.
+ */
+export async function executeFieldPublish(session, args) {
+    // bizproperty/publish is MODEL-SCOPED: one call publishes every draft
+    // field of the schema. `code`/`codes` only select which fields to verify
+    // on the published face after the single publish; omit them to publish
+    // and read back all codes (the batch path).
+    //
+    // Ticket 81 idempotent retry: with explicit code/codes, read the
+    // published face FIRST (a retry after a timeout hits the wire read
+    // cache — zero extra wires) and skip the publish POST entirely when
+    // every requested field is already published. A genuinely missing
+    // field still drives the publish.
+    const requestedCodes = [...(args.code ? [args.code] : []), ...(args.codes ?? [])];
+    const codeOf = (row) => String(row.code ?? row.propertyCode ?? "");
+    // cpdocs base3.0 parity (cp-bizproperty verifyPlan): presence on the
+    // published LIST face is proven later, against a map of each field's
+    // pre-publish DRAFT shape (name + type). The draft face must be
+    // snapshotted BEFORE the publish because a model-scoped publish can leave
+    // it empty; the draft row is the caller-visible expectation.
+    const draftSnapshot = new Map(wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "false" } })).data)
+        .map((row) => [codeOf(row), { name: String(row.name ?? ""), propertyType: Number(row.type ?? row.propertyType) }]));
+    const verifyFieldDetails = async (targets) => {
+        const bounded = targets.slice(0, 25);
+        const mismatches = [];
+        for (const code of bounded) {
+            const expected = draftSnapshot.get(code);
+            if (!expected)
+                continue;
+            let detail;
+            try {
+                detail = (await wireCall(session, { path: ENDPOINTS.fieldGet, query: { schemaCode: args.schemaCode, propertyCode: code } })).data;
+            }
+            catch {
+                // The detail endpoint is optional across builds: report the
+                // verification as unavailable rather than failing the publish.
+                return { mode: "unavailable", verified: false, note: "bizproperty/get 不可用，字段详情未核对（仅列表面存在性）" };
+            }
+            const actual = { name: String(detail.name ?? ""), propertyType: Number(detail.propertyType ?? detail.type) };
+            if (actual.name !== expected.name || actual.propertyType !== expected.propertyType)
+                mismatches.push({ code, expected, actual });
+        }
+        return { mode: "detail", verified: true, checked: bounded.length, ok: mismatches.length === 0, ...(mismatches.length > 0 ? { mismatches } : {}) };
+    };
+    const preRead = await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "true" } });
+    const prePublished = wireRows(preRead.data).map(codeOf).filter((code) => code.length > 0);
+    if (args.force !== true && requestedCodes.length > 0 && requestedCodes.every((code) => prePublished.includes(code))) {
+        return {
+            performed: { skipped: "already-published", scope: "model" },
+            readback: {
+                publishedCodes: prePublished,
+                ...(args.code ? { publishedFieldPresent: true } : {}),
+                ...(args.codes ? { publishedFieldsPresent: Object.fromEntries(args.codes.map((code) => [code, true])) } : {}),
+                allRequestedPresent: true,
+                verification: await verifyFieldDetails(requestedCodes),
+            },
+        };
+    }
+    // Ticket 79 live-fidelity (docker log evidence, 2026-09-13 21:43-21:45,
+    // cloud8_launcher log_error.log + nginx access timings): under DB
+    // connection-pool contention a model publish can fail with a transient
+    // `表单:<t>_<schema>不存在列:<col>` 50000 — the addIndexes/updateColumns
+    // assert reads the serializer view while the failed attempt's DDL
+    // auto-commits, so the state SELF-HEALS across retries (live: three
+    // consecutive attempts each healed one column, the fourth succeeded).
+    // Retry that exact signature up to 3 attempts; anything else rethrows.
+    let performed;
+    // Backoff matches the observed healing cadence on the small env (live:
+    // attempts ~25s/73s apart each reconciled one column).
+    const backoffMs = [2000, 5000];
+    for (let attempt = 1; attempt <= 3; attempt++) {
+        try {
+            performed = await wireCall(session, {
+                path: ENDPOINTS.fieldPublish,
+                method: "POST",
+                body: { bizSchemaCode: args.schemaCode, sendMessage: false },
+            });
+            break;
+        }
+        catch (error) {
+            const transientColumnSync = error instanceof WireError && error.kind === "business" && error.errcode === 50000 && error.message.includes("不存在列");
+            if (!(transientColumnSync && attempt < 3))
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, backoffMs[attempt - 1] ?? 5000));
+        }
+    }
+    const publishOutcome = performed;
+    const readback = await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "true" } });
+    const publishedCodes = wireRows(readback.data).map(codeOf).filter((code) => code.length > 0);
+    const requested = [...(args.code ? [args.code] : []), ...(args.codes ?? [])];
+    const present = requested.filter((code) => publishedCodes.includes(code));
+    const targets = (requested.length > 0 ? requested : [...draftSnapshot.keys()]).filter((code) => publishedCodes.includes(code));
+    const verification = await verifyFieldDetails(targets);
+    const mismatches = verification.mismatches;
+    if (mismatches !== undefined)
+        throw new ToolRefusalError({
+            status: "refused",
+            blocker: "field-publish-readback-mismatch",
+            performed: { errcode: publishOutcome.errcode, scope: "model" },
+            mismatches,
+            message: `字段已发布，但发布后详情回读与草稿面不一致（${mismatches.map((item) => String(item.code)).join("、")}）：这是元数据与预期形状相异的信号，先核对再决定后续；不要当作成功`,
+        });
+    return {
+        performed: { errcode: publishOutcome.errcode, scope: "model" },
+        readback: {
+            publishedCodes,
+            ...(args.code ? { publishedFieldPresent: publishedCodes.includes(args.code) } : {}),
+            ...(args.codes ? { publishedFieldsPresent: Object.fromEntries(args.codes.map((code) => [code, publishedCodes.includes(code)])) } : {}),
+            ...(requested.length > 0 ? { allRequestedPresent: present.length === requested.length } : {}),
+            verification,
+        },
+    };
+}
+/**
+ * Ticket T06 — field.update cascadeRepublish. After a successful field.update,
+ * republish the model's fields, rebuild the default form from the PUBLISHED
+ * face (non-structural control options are preserved by the shared scaffold),
+ * and force-promote the rebuilt draft. Steps follow the configure_model
+ * protocol: a mid-chain failure returns {status:"partial", steps,
+ * failedStep, envelope} — the completed prefix is reported honestly; there is
+ * no cross-endpoint transaction to roll back to.
+ */
+async function runFieldUpdateCascade(session, args, update) {
+    const steps = [{ step: "field.update", errcode: update.performed.errcode, readback: update.readback }];
+    // The cascade targets the model's default form slot (sheetCode = schemaCode,
+    // the form lane's proven default rule).
+    const sheetCode = args.schemaCode;
+    const stop = (index, tool, error) => {
+        const envelope = error instanceof ToolRefusalError
+            ? Object.fromEntries(Object.entries(error.payload).filter(([key]) => key !== "status"))
+            : error instanceof WireError
+                ? { blocker: `wire-${error.kind}`, errcode: error.errcode, message: error.message }
+                : { blocker: "field-update-cascade-step-failed", message: error instanceof Error ? error.message : String(error) };
+        return {
+            status: "partial",
+            steps,
+            failedStep: { index, tool },
+            envelope: { ...envelope, message: `${String(envelope.message ?? "步骤失败")}；后续步骤未执行` },
+        };
+    };
+    const stepOf = (step, outcome) => {
+        const skipped = outcome.performed.skipped;
+        return { step, ...(skipped !== undefined ? { skipped } : { errcode: outcome.performed.errcode }), readback: outcome.readback };
+    };
+    let published;
+    let formPublished;
+    try {
+        // force: the field IS present on the published face — with the stale
+        // shape. The cascade exists to replace that shape, so the
+        // already-published short-circuit must not skip the publish.
+        published = await executeFieldPublish(session, { schemaCode: args.schemaCode, code: args.code, force: true });
+        steps.push(stepOf("field.publish", published));
+    }
+    catch (error) {
+        return stop(1, "field.publish", error);
+    }
+    try {
+        // No fieldCodes / no caller layout: the scaffold binds EVERY published
+        // field (a draftAttributesJson would bypass the published-face source).
+        const draft = await executeFormDraftWrite(session, { schemaCode: args.schemaCode, sheetCode, rebuild: true });
+        steps.push(stepOf("form.draft", draft));
+    }
+    catch (error) {
+        return stop(2, "form.draft", error);
+    }
+    try {
+        // force: the form was published before the cascade; without force the
+        // promotion would short-circuit on `published === true`.
+        formPublished = await executeFormPublishWrite(session, { schemaCode: args.schemaCode, sheetCode, force: true });
+        steps.push(stepOf("form.publish", formPublished));
+    }
+    catch (error) {
+        return stop(3, "form.publish", error);
+    }
+    const fieldReadback = published.readback;
+    return {
+        performed: { errcode: steps[0].errcode, scope: "cascade" },
+        steps,
+        readback: {
+            ...update.readback,
+            cascade: {
+                fieldPublished: fieldReadback.publishedFieldPresent === true,
+                formPublished: formPublished.readback.published === true,
+            },
+        },
+    };
+}
 //# sourceMappingURL=field.js.map

package/dist/lanes/form-contract.js

@@ -19,7 +19,7 @@ export const FORM_WIRE = Object.freeze({
 });
 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_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.";
+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({
     lane: LANES.form,
@@ -77,7 +77,7 @@ export function assertFormContract() {
     assertDescriptionCarries(FORM_LANE_CONTRACT, "form.draft", ["bizsheet/update", "draftViewJson", "draftAttributesJson", "scaffold", "draftHtmlJson", "form-empty-layout"]);
     if (!FORM_WIRE.redundantFieldVisibility.includes("propertyPermissions"))
         throw new Error("form contract must carry the redundant-field visibility (propertyPermissions) fact");
-    assertDescriptionCarries(FORM_LANE_CONTRACT, "form.publish", ["bizsheet/publish", "draft*Json", "published*Json", "verbatim", "form-publish-degrade", "history/list"]);
+    assertDescriptionCarries(FORM_LANE_CONTRACT, "form.publish", ["bizsheet/publish", "draft*Json", "published*Json", "verbatim", "form-publish-degrade", "history/list", "rebuild:true", "force-promote"]);
     assertDescriptionCarries(FORM_LANE_CONTRACT, "configure_form", ["form.draft", "form.publish", "scaffold", "draftHtmlJson"]);
     if (!FORM_WIRE.draftBody.includes("bizsheet/update"))
         throw new Error("form contract must pin the draft update endpoint");

package/dist/lanes/form.js

@@ -134,6 +134,10 @@ export function registerFormLane(tools) {
         publishRemarks: z.string().optional(),
         force: z.boolean().optional().describe("强制重新提拔（跳过 already-published 短路）；重写草稿后的再发布需要它"),
         allowDegrade: z.boolean().optional().describe("显式放行降级提拔（草稿控件数 < 已发布面）；默认拒绝（form-publish-degrade），防把空/残草稿提拔成发布版"),
+        rebuild: z
+            .boolean()
+            .optional()
+            .describe("true 时一步刷新：先丢弃现有草稿、按已发布字段重建脚手架（保留非结构性控件 options），再强制提拔——改字段形状后刷新表单用一个调用；默认只发布现有草稿（无草稿时自动补默认）"),
     }, async (session, args) => executeFormPublishWrite(session, { ...args, sheetCode: resolveSheetCode(args.schemaCode, args.sheetCode) }));
     registerPackageTool(tools, {
         name: "configure_form",

package/dist/lanes/meta.js

@@ -197,7 +197,7 @@ export function registerMetaLane(tools) {
         layer: "meta",
         kind: "meta",
         description: META_TOOLS["doctor"].description,
-        inputSchema: { environment: environmentArg },
+        inputSchema: { environment: environmentArg, serviceCode: z.string().min(1).optional().describe("可选：体检单个业务集成服务的鉴权参数形状（掩码/占位/全 0 检出；非致命 WARN）") },
         handler: async (ctx, args, self) => {
             const store = ctx.sessions.config();
             const steps = [];
@@ -243,6 +243,16 @@ export function registerMetaLane(tools) {
                     note: familyOk === null ? "缺少版本证据；写入将保守拒绝" : familyOk ? "兼容" : "不兼容；写入将保守拒绝",
                 });
                 steps.push({ step: "环境指纹", ok: true, fingerprint: session.environmentFingerprint() });
+                // T09 — optional per-service credential shape probe (non-fatal).
+                if (args.serviceCode !== undefined) {
+                    const { probeServiceCredentials } = await import("../service-doctor.js");
+                    const probe = await probeServiceCredentials(session, args.serviceCode);
+                    steps.push(probe.status === "not-found"
+                        ? { step: "服务凭据", ok: null, serviceCode: probe.serviceCode, note: "未找到（get_by_code 无行）" }
+                        : probe.status === "error"
+                            ? { step: "服务凭据", ok: null, serviceCode: probe.serviceCode, note: `探测失败：${probe.message}` }
+                            : { step: "服务凭据", ok: probe.findings.length === 0, serviceCode: probe.serviceCode, adapterCode: probe.adapterCode, parameterCount: probe.parameterCount, findings: probe.findings, note: probe.findings.length === 0 ? "掩码/占位/全 0 均未检出" : "掩码/占位值不可用于真实调用；真值从任务环境事实取，不要抄 service.get 读回" });
+                }
                 return { status: "ok", steps };
             }
             catch (error) {

package/dist/lanes/model.js

@@ -916,7 +916,7 @@ export function registerModelLane(tools) {
                     throw new ToolRefusalError({ status: "refused", blocker: "configure-model-listview-unavailable", message: "listview.configure 未注册写执行" });
                 failed = await run(results.length, "listview.configure", async () => {
                     const outcome = await target.writeExecute(session, { schemaCode: args.code, ...args.listview });
-                    return { step: "listview.configure", readback: outcome.readback };
+                    return { step: "listview.configure", readback: "readback" in outcome ? outcome.readback : outcome.envelope };
                 });
                 if (failed)
                     return failed;

package/dist/lanes/workflow.js

@@ -1614,6 +1614,8 @@ export function registerWorkflowLane(tools) {
                     throw new ToolRefusalError({ status: "refused", blocker: "configure-workflow-step-unavailable", message: `configure_workflow 需要 ${toolName}，但它未注册写执行` });
                 try {
                     const outcome = await target.writeExecute(session, toolArgs);
+                    if ("status" in outcome)
+                        throw new ToolRefusalError({ status: "refused", blocker: "configure-workflow-inner-stop", message: `步骤 ${toolName} 返回中途停止：${String(outcome.envelope?.message ?? outcome.status)}` });
                     steps.push({ step: toolName, ...outcome });
                     return outcome.readback;
                 }

package/dist/omc-core-lazy.js

@@ -0,0 +1,6 @@
+let pending;
+export function omcCore() {
+    pending ??= import("omc-core");
+    return pending;
+}
+//# sourceMappingURL=omc-core-lazy.js.map