@stalfh233/omc-cli 0.0.0-stage → 0.4.0

package/dist/lanes/meta-contract.js

@@ -0,0 +1,85 @@
+import { assertDescriptionCarries, assertLaneContract, behaviorBinding, CONTRACT_FAMILY, CONTRACT_REFERENCE_VERSION } from "./contract-support.js";
+import { LANES } from "./lane-ids.js";
+/**
+ * meta-governance wire facts. This is the thin, no-wire-endpoint governance
+ * surface (coverage manifest, status, setup, doctor); its contract is the
+ * single source for the tool descriptions only.
+ */
+export const META_WIRE = Object.freeze({
+    coverageManifest: "the runtime tool surface is bounded by coverage/m1-coverage-manifest-v1.json; out-of-coverage calls are rejected and cite the entry",
+    writePermission: "writing is decided by the environment's writable permission (the single machine gate); a production environment additionally requires a per-write confirmProduction acknowledgement recorded in the audit artifact; the human gate is the conversational draft review",
+    credentials: "setup.commit writes omc.config.json (non-secret) and a 0600 credential store; secrets never appear in any output",
+    doctor: "doctor runs read-only: config readable → credentials → login → version-family compatibility (advisory, anchored on 8.6) → environment fingerprint",
+    versionFamily: CONTRACT_FAMILY,
+});
+export const META_LANE_CONTRACT = Object.freeze({
+    lane: LANES.meta,
+    family: CONTRACT_FAMILY,
+    referenceVersion: CONTRACT_REFERENCE_VERSION,
+    endpoints: Object.freeze({}),
+    wire: Object.freeze({
+        coverageManifest: META_WIRE.coverageManifest,
+        writePermission: META_WIRE.writePermission,
+        credentials: META_WIRE.credentials,
+        doctor: META_WIRE.doctor,
+        versionFamily: META_WIRE.versionFamily,
+    }),
+    wireBindings: Object.freeze({
+        coverageManifest: Object.freeze([behaviorBinding("test/coverage-gate.test.ts#S23: the gate is structured", assertMetaContract)]),
+        writePermission: Object.freeze([behaviorBinding("test/ticket-87-production-write-denial.test.ts#production write without confirmation is refused", assertMetaContract)]),
+        credentials: Object.freeze([behaviorBinding("test/config-store.test.ts#S22: credential store is written with mode 0600", assertMetaContract)]),
+        doctor: Object.freeze([behaviorBinding("test/protocol.test.ts#tool surface: doctor returns the step chain", assertMetaContract)]),
+        versionFamily: Object.freeze([behaviorBinding("test/coverage-gate.test.ts#version family is advisory: an off-family version is accepted with a compatibility notice", assertMetaContract)]),
+    }),
+    evidence: Object.freeze([
+        "packages/omc-cli/src/lanes/meta.ts",
+        "packages/omc-cli/src/args.ts",
+        "packages/omc-cli/src/plan.ts",
+        "packages/omc-cli/src/write.ts",
+        "packages/omc-cli/src/package.ts",
+        "packages/omc-cli/src/context.ts",
+        "packages/omc-cli/test/protocol.test.ts",
+    ]),
+    tools: Object.freeze({
+        "coverage.manifest": Object.freeze({
+            scope: "coverage manifest readback",
+            description: "List the M1 coverage manifest with status per capability. The tool surface is bounded by this manifest; out-of-coverage calls are rejected citing the entry.",
+        }),
+        get_status: Object.freeze({
+            scope: "environment health status",
+            description: "Environment health: connectivity, login, version-family compatibility, credential store mode, lease state, coverage summary, write posture (writable permission; production requires per-write confirmation; removed config keys).",
+        }),
+        "setup.start": Object.freeze({
+            scope: "setup bootstrap",
+            description: "配置引导入口（中文）：返回需要填写的字段与当前非密值，供人工在会话内配置；填好后用 setup.commit 提交。",
+        }),
+        "setup.commit": Object.freeze({
+            scope: "setup commit",
+            description: "提交环境配置（幂等）：写 omc.config.json 与 0600 凭据库；配置是否生产环境（风险标签）与是否允许写入（唯一的写入机器门）；随后连通性+登录+版本族兼容提示。",
+        }),
+        doctor: Object.freeze({
+            scope: "health self-check",
+            description: "健康自检：配置可读 → 连通性 → 登录 → 8.6 版本族兼容 → 环境指纹。只报告，不修改。",
+        }),
+    }),
+});
+export function assertMetaContract() {
+    assertLaneContract(META_LANE_CONTRACT);
+    if (META_WIRE.versionFamily !== "8.6")
+        throw new Error("meta contract pins the version family to 8.6");
+    assertDescriptionCarries(META_LANE_CONTRACT, "coverage.manifest", ["manifest", "out-of-coverage"]);
+    assertDescriptionCarries(META_LANE_CONTRACT, "get_status", ["version-family", "coverage"]);
+    assertDescriptionCarries(META_LANE_CONTRACT, "setup.start", ["setup.commit"]);
+    assertDescriptionCarries(META_LANE_CONTRACT, "setup.commit", ["omc.config.json", "0600", "生产环境", "允许写入"]);
+    assertDescriptionCarries(META_LANE_CONTRACT, "get_status", ["writable", "confirmation"]);
+    assertDescriptionCarries(META_LANE_CONTRACT, "doctor", ["只报告", "8.6"]);
+    if (!META_WIRE.coverageManifest.includes("m1-coverage-manifest-v1.json"))
+        throw new Error("meta contract must pin the coverage manifest ledger");
+    if (!META_WIRE.writePermission.includes("writable"))
+        throw new Error("meta contract must pin the write permission gate");
+    if (!META_WIRE.credentials.includes("0600"))
+        throw new Error("meta contract must pin the 0600 credential store");
+    if (!META_WIRE.doctor.includes("version-family"))
+        throw new Error("meta contract must pin the doctor step chain");
+}
+//# sourceMappingURL=meta-contract.js.map

package/dist/lanes/meta.js

@@ -0,0 +1,255 @@
+import { z } from "zod";
+import { environmentArg } from "../args.js";
+import { environmentNotice, environmentWritable, requiresProductionConfirmation } from "../environment-policy.js";
+import { removedProfileKeys } from "../config-store.js";
+import { defineTool } from "../tool-types.js";
+import { META_LANE_CONTRACT } from "./meta-contract.js";
+const META_TOOLS = META_LANE_CONTRACT.tools;
+export function registerMetaLane(tools) {
+    tools.push(defineTool({
+        name: "coverage.manifest",
+        layer: "meta",
+        kind: "meta",
+        description: META_TOOLS["coverage.manifest"].description,
+        inputSchema: { full: z.boolean().optional().describe("返回完整覆盖投影；默认返回紧凑摘要") },
+        handler: async (ctx, args) => {
+            const full = args.full === true;
+            const items = ctx.manifest.items.map((item) => full
+                ? {
+                    lane: item.lane,
+                    capability: item.capability,
+                    status: item.status,
+                    scope: item.scope,
+                    ...(item.tools ? { tools: item.tools } : {}),
+                    ...(item.scopes ? { scopes: item.scopes } : {}),
+                    ...(item.excluded_or_unsupported_reason ? { reason: item.excluded_or_unsupported_reason } : {}),
+                }
+                : {
+                    lane: item.lane,
+                    capability: item.capability,
+                    status: item.status,
+                });
+            if (full) {
+                return {
+                    status: "ok",
+                    manifest: {
+                        version_family: ctx.manifest.version_family,
+                        anchor_version: ctx.manifest.anchor_version,
+                        items,
+                    },
+                };
+            }
+            const byStatus = ctx.manifest.items.reduce((acc, item) => {
+                acc[item.status] = (acc[item.status] ?? 0) + 1;
+                return acc;
+            }, {});
+            return {
+                status: "ok",
+                manifest: {
+                    version_family: ctx.manifest.version_family,
+                    anchor_version: ctx.manifest.anchor_version,
+                    counts: { total: items.length, byStatus },
+                    items,
+                    hint: "coverage.manifest full:true 取完整投影（含 scope/reason/tools/scopes）；lane 能力面用 omc capabilities / omc capability <id>；工具清单用 commands --json --compact",
+                },
+            };
+        },
+    }));
+    tools.push(defineTool({
+        name: "get_status",
+        layer: "high",
+        kind: "meta",
+        description: META_TOOLS["get_status"].description,
+        inputSchema: { environment: environmentArg },
+        handler: async (ctx, args, self) => {
+            const store = ctx.sessions.config();
+            const resolved = store.resolveEnvironment(args.environment);
+            const environments = store.listEnvironments();
+            let sessionState;
+            try {
+                const session = await ctx.sessions.session(args.environment);
+                const version = session.detectedVersion();
+                sessionState = {
+                    login: "ok",
+                    version: version ?? null,
+                    versionFamilyOk: version ? version.startsWith(ctx.manifest.version_family + ".") : null,
+                    environmentFingerprint: session.environmentFingerprint(),
+                };
+            }
+            catch (error) {
+                sessionState = { login: "failed", error: error.message };
+            }
+            const statusCounts = ctx.manifest.items.reduce((acc, item) => {
+                acc[item.status] = (acc[item.status] ?? 0) + 1;
+                return acc;
+            }, {});
+            return {
+                status: "ok",
+                environment: {
+                    name: resolved.name,
+                    source: resolved.source,
+                    production: requiresProductionConfirmation(resolved.profile),
+                    writable: environmentWritable(resolved.profile),
+                    writeRequiresConfirmation: requiresProductionConfirmation(resolved.profile),
+                    removedConfigKeys: removedProfileKeys(resolved.profile),
+                },
+                configuredEnvironments: environments.map((e) => e.name),
+                credentialsMode: store.credentialsMode(),
+                session: sessionState,
+                coverage: { total: ctx.manifest.items.length, byStatus: statusCounts },
+                writeLease: { activeHolder: ctx.lease.holder(resolved.name) ?? null },
+            };
+        },
+    }));
+    tools.push(defineTool({
+        name: "setup.start",
+        layer: "meta",
+        kind: "meta",
+        description: META_TOOLS["setup.start"].description,
+        inputSchema: {},
+        handler: async (ctx) => {
+            const store = ctx.sessions.config();
+            const environments = store.listEnvironments();
+            return {
+                status: "ok",
+                fields: [
+                    { name: "environmentName", required: true, description: "环境名称，例如 test" },
+                    { name: "baseUrl", required: true, description: "CloudPivot 服务地址" },
+                    { name: "applicationCode", required: true, description: "默认应用 code（可选：Agent 可用 discover_environment 自行发现其它应用）" },
+                    { name: "isDefault", required: false, description: "是否设为默认环境" },
+                    { name: "production", required: false, description: "是否生产环境（高危风险标签）：写入仍需每笔显式 confirmProduction:true；它不是第二把钥匙，也不改变 writable" },
+                    { name: "writable", required: false, description: "是否允许新增、修改、删除和发布（唯一的写入机器门）；关闭后仍可查询" },
+                    { name: "username", required: true, secret: true, description: "登录账号" },
+                    { name: "password", required: true, secret: true, description: "登录密码；以 0600 存储，绝不回显" },
+                ],
+                current: environments.map((entry) => ({
+                    name: entry.name,
+                    baseUrl: entry.profile.baseUrl,
+                    applicationCode: entry.profile.applicationCode,
+                    isDefault: entry.profile.isDefault === true,
+                    production: requiresProductionConfirmation(entry.profile),
+                    writable: environmentWritable(entry.profile),
+                    removedConfigKeys: removedProfileKeys(entry.profile),
+                })),
+                credentialsMode: store.credentialsMode(),
+                note: "密钥绝不会出现在任何输出中；请由人工提供账号密码后调用 setup.commit 提交",
+            };
+        },
+    }));
+    tools.push(defineTool({
+        name: "setup.commit",
+        layer: "meta",
+        kind: "meta",
+        description: META_TOOLS["setup.commit"].description,
+        inputSchema: {
+            environmentName: z.string().min(1),
+            baseUrl: z.string().url(),
+            applicationCode: z.string().min(1),
+            isDefault: z.boolean().optional(),
+            production: z.boolean().optional(),
+            writable: z.boolean().optional(),
+            username: z.string().optional(),
+            password: z.string().optional(),
+            setProjectEnv: z.boolean().optional(),
+        },
+        handler: async (ctx, args, self) => {
+            const store = ctx.sessions.config();
+            const name = args.environmentName;
+            const previous = store.readConfig().environments[name];
+            const production = args.production ?? previous?.production ?? false;
+            store.upsertEnvironment(name, {
+                baseUrl: args.baseUrl,
+                applicationCode: args.applicationCode,
+                ...(args.isDefault === true ? { isDefault: true } : previous?.isDefault === true ? { isDefault: true } : {}),
+                production,
+                ...(args.writable !== undefined ? { writable: args.writable } : previous?.writable !== undefined ? { writable: previous.writable } : {}),
+            });
+            if (args.username && args.password)
+                store.writeCredential(name, { username: args.username, password: args.password });
+            if (args.setProjectEnv === true)
+                store.bindProjectEnvironment(name);
+            let check;
+            try {
+                const session = await ctx.sessions.session(name);
+                check = { login: "ok", version: session.detectedVersion() ?? null, environmentFingerprint: session.environmentFingerprint() };
+            }
+            catch (error) {
+                check = { login: "failed", error: error.message };
+            }
+            const saved = store.readConfig().environments[name];
+            return {
+                status: "ok",
+                environment: name,
+                idempotent: previous !== undefined,
+                policy: {
+                    production: saved ? requiresProductionConfirmation(saved) : false,
+                    writable: saved ? environmentWritable(saved) : false,
+                    writeRequiresConfirmation: saved ? requiresProductionConfirmation(saved) : false,
+                },
+                removedConfigKeys: saved ? removedProfileKeys(saved) : [],
+                credentialsMode: store.credentialsMode(),
+                check,
+            };
+        },
+    }));
+    tools.push(defineTool({
+        name: "doctor",
+        layer: "meta",
+        kind: "meta",
+        description: META_TOOLS["doctor"].description,
+        inputSchema: { environment: environmentArg },
+        handler: async (ctx, args, self) => {
+            const store = ctx.sessions.config();
+            const steps = [];
+            let resolved;
+            const resolveEnv = () => store.resolveEnvironment(args.environment);
+            try {
+                resolved = resolveEnv();
+                steps.push({
+                    step: "配置",
+                    ok: true,
+                    environment: resolved.name,
+                    source: resolved.source,
+                    production: requiresProductionConfirmation(resolved.profile),
+                    writable: environmentWritable(resolved.profile),
+                    writeRequiresConfirmation: requiresProductionConfirmation(resolved.profile),
+                    removedConfigKeys: removedProfileKeys(resolved.profile),
+                    notice: environmentNotice(resolved.profile),
+                });
+            }
+            catch (error) {
+                steps.push({ step: "配置", ok: false, error: error.message });
+                return { status: "failed", steps };
+            }
+            try {
+                const credential = store.readCredential(resolved.name);
+                steps.push({ step: "凭据", ok: true, mode: store.credentialsMode(), username: credential.username });
+            }
+            catch (error) {
+                steps.push({ step: "凭据", ok: false, error: error.message });
+                return { status: "failed", steps };
+            }
+            try {
+                const session = await ctx.sessions.session(args.environment);
+                const version = session.detectedVersion();
+                steps.push({ step: "登录", ok: true, enterpriseId: session.enterpriseId(), administrator: session.administrator() });
+                const familyOk = version ? version.startsWith(ctx.manifest.version_family + ".") : null;
+                steps.push({
+                    step: "版本族",
+                    ok: familyOk === true,
+                    version: version ?? null,
+                    expectedFamily: ctx.manifest.version_family,
+                    anchor: ctx.manifest.anchor_version,
+                    note: familyOk === null ? "缺少版本证据；写入将保守拒绝" : familyOk ? "兼容" : "不兼容；写入将保守拒绝",
+                });
+                steps.push({ step: "环境指纹", ok: true, fingerprint: session.environmentFingerprint() });
+                return { status: "ok", steps };
+            }
+            catch (error) {
+                steps.push({ step: "登录", ok: false, error: error.message });
+                return { status: "failed", steps };
+            }
+        },
+    }));
+}
+//# sourceMappingURL=meta.js.map

package/dist/lanes/model-contract.js

@@ -0,0 +1,168 @@
+import { assertDescriptionCarries, assertLaneContract, behaviorBinding, CONTRACT_FAMILY, CONTRACT_REFERENCE_VERSION, emitterBinding } from "./contract-support.js";
+import { LANES } from "./lane-ids.js";
+/**
+ * model-management wire facts (live-proven). The create body, the
+ * exits_bizschema readback, and the physical-delete cascade are the single
+ * source for the handler descriptions and the coverage declarations.
+ */
+export const MODEL_WIRE = Object.freeze({
+    createBody: "bizmodels/create carries appCode, parentId (folder), modelType, bizSchemaCode, icon, name_i18n, pcAble/mobileAble, options{statisticEnabled:false}",
+    readback: "exits_bizschema readback via apppackage/trees (type==='BizModel' && code===schemaCode)",
+    folderResolution: "explicit folderId > first non-BizModel tree node (auto-default-folder); none found → 302001",
+    deleteBody: "apppackage/physically_delete body [{id,code,type:'BizModel'}] where id MUST be the app-tree node id (AppFunction id)",
+    deleteIdNamespace: "physically_delete resolves each row id as an AppFunction id (removeBizModel → getAppFunction(id), AppIntegrationFacadeImpl) and answers 601003 业务模型不存在 for a biz-model record id; the two id spaces are NOT interchangeable. model.delete/deleteMany resolve the node across applications (default app first, then applicationList per-app trees) and refuse fail-closed with model-application-unresolved when the record exists but no tree node does — never guessing a record id",
+    deleteTolerance: "already-absent short-circuits; the authoritative record face polls to verified absence; the tree node is eventually consistent and reported as treeNodePending",
+    referencePrecheck: "before physically_delete, every same-app sibling model's bizproperty faces (draft + published) are scanned for relation fields targeting the model (relativeCode or options.schemaCode of WORK_SHEET/MULT_WORK_SHEET/RELEVANCE_DATA); any hit refuses with blocker model-referenced-by + referencingModels — the server-side async 'xxx被模型 yyy 引用,不能删除' (AppIntegrationFacadeImpl.deleteFunctions:2201, live TID xydiq8enji3ziq4bl2diurx9c) surfaced at call time instead of errcode 0 followed by a silent async failure",
+    dependencyInvertedDelete: "referenced cleanup is dependency-inverted: delete referencing models first, then the referenced model; the physical delete cascades per-column asynchronously (3-4s per column, 40-60s for a 12-column model), so absent:false + treeNodePending:true means wait-and-recheck (the poll runs ~60s and returns nextAction guidance), never an immediate failure verdict — especially right after deleting a referencing model, whose cascade may still be dropping the relation columns",
+    usableLadder: "model.create → field.create → model-scoped field.publish (rung-1..3); configure_model performs an authoritative readback immediately after every model.create, field.create, field.publish, form.draft, and form.publish step and stops with completed/failed step evidence on failure; form draft/publish is the separate configure_form capability",
+    summaryWire: "bizmodels/get_summary (GET ?schemaCode) returns the data-title string; bizmodels/update_summary (POST {schemaCode, summary}) requires a non-empty summary (validateNotEmpty) and answers 300014 BIZ_SCHEMA_NOT_PUBLISHED (ErrorCode.java:194) for a missing schema — 8.6.26 BizSchemaController.java:668-736",
+});
+/**
+ * Fake-side refusal errcode for a referenced physical delete. Live evidence
+ * (ticket 23): the sync face answers errcode 0 + deletedId while the async
+ * deleteFunctions dispatcher fails with ServiceException — no live envelope
+ * exists for the check. The fake surfaces the check synchronously so the
+ * blocker and the referencing-model list are visible even when a caller
+ * bypasses the tool precheck; 50000 stands for the generic ServiceException
+ * envelope family and the authoritative signal is the verbatim errmsg text.
+ */
+export const MODEL_REFERENCED_DELETE_ERRCODE = 50000;
+/**
+ * The platform create-body defaults the emitter sends verbatim. The emitter
+ * imports THIS constant to build the wire body (model.create and the
+ * configure_model inline step), so changing a value here changes the actual
+ * request — the contract fact is enforced, not just documented.
+ */
+export const MODEL_CREATE_BODY_DEFAULTS = Object.freeze({
+    modelType: "LIST",
+    icon: "h-icon-all-yingyong",
+    pcAble: true,
+    mobileAble: true,
+    options: JSON.stringify({ statisticEnabled: false }),
+});
+const MODEL_SCOPE = "create publish physical delete absence read list inspect";
+export const MODEL_LANE_CONTRACT = Object.freeze({
+    lane: LANES.model,
+    family: CONTRACT_FAMILY,
+    referenceVersion: CONTRACT_REFERENCE_VERSION,
+    endpoints: Object.freeze({
+        list: "modelList",
+        get: "modelGet",
+        create: "modelCreate",
+        tree: "applicationTree",
+        physicallyDelete: "appPackagePhysicallyDelete",
+        fieldCreate: "fieldCreate",
+        fieldPublish: "fieldPublish",
+        fieldList: "fieldList",
+    }),
+    wire: Object.freeze({
+        createBody: MODEL_WIRE.createBody,
+        readback: MODEL_WIRE.readback,
+        folderResolution: MODEL_WIRE.folderResolution,
+        deleteBody: MODEL_WIRE.deleteBody,
+        deleteIdNamespace: MODEL_WIRE.deleteIdNamespace,
+        deleteTolerance: MODEL_WIRE.deleteTolerance,
+        referencePrecheck: MODEL_WIRE.referencePrecheck,
+        dependencyInvertedDelete: MODEL_WIRE.dependencyInvertedDelete,
+        usableLadder: MODEL_WIRE.usableLadder,
+    }),
+    wireBindings: Object.freeze({
+        createBody: Object.freeze([
+            emitterBinding("lanes/model-contract.MODEL_CREATE_BODY_DEFAULTS", () => {
+                if (MODEL_CREATE_BODY_DEFAULTS.modelType !== "LIST")
+                    throw new Error("model create body default modelType must be LIST");
+                if (MODEL_CREATE_BODY_DEFAULTS.icon !== "h-icon-all-yingyong")
+                    throw new Error("model create body default icon drifted");
+                if (MODEL_CREATE_BODY_DEFAULTS.pcAble !== true || MODEL_CREATE_BODY_DEFAULTS.mobileAble !== true)
+                    throw new Error("model create body must enable pc/mobile");
+                if (MODEL_CREATE_BODY_DEFAULTS.options !== JSON.stringify({ statisticEnabled: false }))
+                    throw new Error("model create body options drifted");
+            }),
+            behaviorBinding("test/model-create-body.test.ts#model.create emits the platform create body", assertModelContract),
+        ]),
+        readback: Object.freeze([behaviorBinding("test/configure-model-multi.test.ts#configure_model: N fields + form publish in one call reaches the structurally usable shape", assertModelContract)]),
+        folderResolution: Object.freeze([behaviorBinding("test/e2e.test.ts#S26-cli happy path", assertModelContract)]),
+        deleteBody: Object.freeze([behaviorBinding("test/model-delete-many.test.ts#model.deleteMany removes two models in one request", assertModelContract)]),
+        deleteIdNamespace: Object.freeze([behaviorBinding("test/model-delete-cross-app.test.ts#model.delete refuses fail-closed when the record exists", assertModelContract)]),
+        deleteTolerance: Object.freeze([behaviorBinding("test/model-delete-many.test.ts#model.deleteMany short-circuits already-absent codes", assertModelContract)]),
+        referencePrecheck: Object.freeze([
+            emitterBinding("lanes/model-contract.MODEL_REFERENCED_DELETE_ERRCODE", assertModelContract),
+            behaviorBinding("test/model-delete-reference-block.test.ts#model.delete refuses with model-referenced-by", assertModelContract),
+        ]),
+        dependencyInvertedDelete: Object.freeze([behaviorBinding("test/model-delete-reference-block.test.ts#dependency-inverted cleanup chain passes", assertModelContract)]),
+        usableLadder: Object.freeze([behaviorBinding("test/configure-model-multi.test.ts#configure_model: N fields + form publish in one call", assertModelContract)]),
+    }),
+    evidence: Object.freeze([
+        ".scratch/omc-route-wayfinder/leg2-closeout.md",
+        "packages/omc-cli/src/lanes/model.ts",
+        "packages/omc-cli/src/field-families.ts (field.create default options)",
+    ]),
+    tools: Object.freeze({
+        "model.list": Object.freeze({
+            scope: MODEL_SCOPE,
+            description: "List the models in an application (apppackage/trees, type==='BizModel') as a compact { code, name } inventory. Fills the gap where enumerating models otherwise required discover_environment + an artifact read. `applicationCode` optional (configured/default app); `filter` is a substring match on code/name.",
+        }),
+        "model.inspect": Object.freeze({
+            scope: MODEL_SCOPE,
+            description: "Read ONE model's whole design-time configuration in a single call: business fields (SYSTEM_FIELD_CODES filtered unless all:true), default form (present/published/control count), default list view (columns), business rules (platform defaultRule filtered unless all:true), field-level data rules, and the model's workflow summary (by schemaCode). Aggregates the existing read faces; `--all` includes system fields and platform default rules. Runtime data (data.*) is deliberately NOT included.",
+        }),
+        "model.create": Object.freeze({
+            scope: MODEL_SCOPE,
+            description: "Create a design-time model (bizmodels/create) with exits_bizschema readback. folderId optional (auto-resolved from the app tree). applicationCode optional — defaults to the configured app, else the tenant's first application.",
+        }),
+        "model.delete": Object.freeze({
+            scope: MODEL_SCOPE,
+            description: "Physically delete a model (apppackage/physically_delete with the proven [{id,code,type:BizModel}] body) with exact-absence readback. The row id MUST be the app-tree node id (AppFunction id) — a biz-model record id is refused by the platform with 601003 业务模型不存在; without `applicationCode` the tool resolves the node across every application (default app first, then applicationList per-app trees) and refuses fail-closed (`model-application-unresolved`) when the record exists but no tree node does, never guessing an id. Inbound references are prechecked: relation fields (relativeCode / options.schemaCode) on same-app models refuse with blocker `model-referenced-by` plus the referencingModels list — clean up dependency-inverted (delete referencing models first, then the referenced one). The async per-column cascade takes 40-60s: absent:false with treeNodePending:true means wait ~60s and re-run (idempotent; already-absent short-circuits; nextAction guidance is returned) rather than judging failure. Accepts an explicit `applicationCode` (priority over the configured default) for cross-application model management.",
+        }),
+        configure_model: Object.freeze({
+            scope: MODEL_SCOPE,
+            description: "High-level: create a model with one field (fieldCode/fieldName/propertyType, legacy) or N fields (fields:[{code,name,propertyType,choices?,relativeCode?,options?}]) and drive it to the structurally usable state (model.create → field.create×N → model-scoped field.publish), optionally drafting and publishing the default form in the same package (publishForm:true → form.draft → form.publish) and configuring the default list view (`listview:{fieldCodes,...}` → listview.configure). Resumable: if the model already exists in the application tree, the model.create step is SKIPPED (reported as `skipped:\"model-exists\"`) and the field/publish steps still run — it does not abort on a pre-existing model. Family gates run per field BEFORE the write permission gate; for the form-only path use configure_form.",
+        }),
+        "model.deleteMany": Object.freeze({
+            scope: MODEL_SCOPE,
+            description: "Physically delete several models in ONE request: apppackage/physically_delete is list-shaped (@RequestBody List<AppDeleteParamVO>, AppPackageController.java:1424), so schemaCodes[] is sent as one [{id,code,type:BizModel}] batch. Each row id is the app-tree node id (AppFunction id) resolved across applications; a target whose record exists but has no tree node refuses the whole batch fail-closed (`model-application-unresolved`) rather than sending a record id. Every target's inbound references are prechecked first — a referenced model refuses the whole batch with per-target blockedTargets evidence and zero side effects (batch members themselves never block each other; put referencing models INTO the list for dependency-inverted cleanup). Already-absent codes short-circuit; per-model absence is polled with the same wait-and-recheck guidance as model.delete.",
+        }),
+        "model.setSummary": Object.freeze({
+            scope: MODEL_SCOPE,
+            description: "Set the model's data title / 数据标题 (POST bizmodels/update_summary {schemaCode, summary}) — the fallback display of relation fields and the portal list title. The platform stores `Summary[]` JSON and runtime resolution runs JsonUtility.toList(summaryExpression, Summary.class) (BizObjectTitleSetter :140-160); Summary is {int isDataItem (1=表单字段, 2=查询字段), String code, String param}. The tool normalizes: canonical Summary[] JSON is validated/re-serialized, a PURE {field} placeholder template is converted to [{isDataItem:1,code}], and anything else (literal text, malformed JSON) refuses `model-summary-invalid` — a raw template stored verbatim poisoned the model so ALL later data.save/data.submit answered a bare 50000 (live-verified). Readback is the sibling GET bizmodels/get_summary face; it warns when the STORED value is not a valid Summary[]. Empty summary refuses `model-summary-empty`; a missing schema answers 300014 数据模型未发布.",
+        }),
+        "model.update": Object.freeze({
+            scope: MODEL_SCOPE,
+            description: "Rename a model's app-tree node (POST bizmodels/update with AppFunctionVO; source-pinned BizSchemaController.update:266-305 — bizSchemaCode, id=<AppFunction node id>, name, parentId are ALL validateNotEmpty-required; the tool resolves id/parentId from the app tree). The endpoint patches the MENU NODE only: the underlying schema is fixed at create (modelType refused `model-type-immutable`; get_all keeps the original type/name — the authoritative rename readback is the tree node, recordName reported informationally). Absent tree node refuses `model-update-target-absent`; an empty patch refuses `model-update-empty-patch` (data title belongs to model.setSummary).",
+        }),
+    }),
+});
+export function assertModelContract() {
+    assertLaneContract(MODEL_LANE_CONTRACT);
+    if (!MODEL_WIRE.usableLadder.includes("rung-1..3"))
+        throw new Error("model contract pins the usable-model ladder to rung-1..3");
+    assertDescriptionCarries(MODEL_LANE_CONTRACT, "model.create", ["bizmodels/create", "exits_bizschema", "folderId", "applicationCode"]);
+    assertDescriptionCarries(MODEL_LANE_CONTRACT, "model.delete", ["apppackage/physically_delete", "BizModel", "absence", "`applicationCode`", "model-referenced-by", "dependency-inverted", "treeNodePending", "601003", "model-application-unresolved"]);
+    if (!MODEL_WIRE.deleteIdNamespace.includes("601003"))
+        throw new Error("model contract must carry the physically_delete id-namespace 601003 fact");
+    assertDescriptionCarries(MODEL_LANE_CONTRACT, "configure_model", ["model.create", "field.create", "field.publish", "publishForm", "configure_form"]);
+    if (!MODEL_WIRE.usableLadder.includes("authoritative readback immediately after every"))
+        throw new Error("model contract must require per-step authoritative readbacks");
+    assertDescriptionCarries(MODEL_LANE_CONTRACT, "model.deleteMany", ["physically_delete", "List<AppDeleteParamVO>", "blockedTargets", "wait-and-recheck"]);
+    assertDescriptionCarries(MODEL_LANE_CONTRACT, "model.setSummary", ["update_summary", "get_summary", "数据标题", "300014", "model-summary-empty", "model-summary-invalid", "Summary[]"]);
+    assertDescriptionCarries(MODEL_LANE_CONTRACT, "model.update", ["bizmodels/update", "get_all", "model-type-immutable", "model-update-target-absent", "model-update-empty-patch"]);
+    if (!MODEL_WIRE.summaryWire.includes("validateNotEmpty"))
+        throw new Error("model contract must carry the update_summary validateNotEmpty fact");
+    if (!MODEL_WIRE.createBody.includes("appCode") || !MODEL_WIRE.createBody.includes("name_i18n"))
+        throw new Error("model contract must pin the create body");
+    if (!MODEL_WIRE.readback.includes("exits_bizschema"))
+        throw new Error("model contract must pin the create readback");
+    if (!MODEL_WIRE.folderResolution.includes("auto-default-folder") || !MODEL_WIRE.folderResolution.includes("302001"))
+        throw new Error("model contract must pin folder resolution and its absent-folder errcode");
+    if (!MODEL_WIRE.deleteBody.includes("physically_delete"))
+        throw new Error("model contract must pin the physical delete endpoint");
+    if (!MODEL_WIRE.deleteIdNamespace.includes("601003"))
+        throw new Error("model contract must pin the delete id-namespace errcode");
+    if (!MODEL_WIRE.deleteTolerance.includes("treeNodePending"))
+        throw new Error("model contract must pin the delete tolerance readback");
+    if (!MODEL_WIRE.referencePrecheck.includes("model-referenced-by"))
+        throw new Error("model contract must pin the reference-precheck blocker");
+    if (!MODEL_WIRE.dependencyInvertedDelete.includes("dependency-inverted"))
+        throw new Error("model contract must pin the dependency-inverted cleanup");
+}
+//# sourceMappingURL=model-contract.js.map

package/dist/lanes/model-coverage.js

@@ -0,0 +1,20 @@
+import { claim, declareLaneCoverage } from "./coverage-declaration.js";
+import { MODEL_LANE_CONTRACT } from "./model-contract.js";
+const T = MODEL_LANE_CONTRACT.tools;
+export const MODEL_COVERAGE = declareLaneCoverage(MODEL_LANE_CONTRACT.lane, [
+    {
+        capability: "Model management lifecycle (create/publish/physical delete/absence)",
+        evidence: [".scratch/omc-route-wayfinder/leg2-closeout.md", "packages/omc-cli/src/lanes/model.ts"],
+        tools: [
+            claim("model.create", T["model.create"].scope),
+            claim("model.update", T["model.update"].scope),
+            claim("model.delete", T["model.delete"].scope),
+            claim("model.deleteMany", T["model.deleteMany"].scope),
+            claim("model.setSummary", T["model.setSummary"].scope),
+            claim("configure_model", T["configure_model"].scope),
+            claim("model.list", T["model.list"].scope),
+            claim("model.inspect", T["model.inspect"].scope),
+        ],
+    },
+]);
+//# sourceMappingURL=model-coverage.js.map