@stalfh233/omc-cli 0.0.0-stage → 0.4.10

package/dist/lanes/rule-lifecycle-contract.js

@@ -0,0 +1,92 @@
+import { assertDescriptionCarries, assertLaneContract, behaviorBinding, CONTRACT_FAMILY, CONTRACT_REFERENCE_VERSION, emitterBinding } from "./contract-support.js";
+import { LANES } from "./lane-ids.js";
+import { RULE_PLATFORM_QUIRK } from "./businessrule-contract.js";
+/**
+ * The live-proven enable chain (2026-09-11): `publish` creates a new version
+ * (the server runs its enableability check) and `enable` flips the DRAFT row's
+ * switch. The runtime dispatcher reads the DRAFT row's `enabled` plus the
+ * latest PUBLISH content (getExecutableBySchemaCodeAndCode), so publishing
+ * without enabling silently does nothing.
+ */
+export const RULE_ENABLE_CHAIN = Object.freeze({
+    publish: "publish 以完整规则模型出新版本（平台内部跑可启用了性校验）",
+    enable: "enable 以 {schemaCode, ruleCode} 翻转 DRAFT 行的启用开关",
+    dispatch: "运行时分发读的是 DRAFT 行 enabled + 最新 PUBLISH 内容（getExecutableBySchemaCodeAndCode）",
+    conclusion: "只 publish 不 enable 时规则静默不生效",
+    readbackRule: "Readback must reflect the platform's `enabled` field directly — never infer from `status`.",
+    idempotentErrcode: 550014,
+});
+export const RULE_SCHEMA_GATE = Object.freeze({
+    probe: "bizmodels/get_all (GET ?schemaCode) — BizSchemaController.java:615-633, miss answers SCHEMA_NOT_FOUNT_ERR 10011 业务模型不存在",
+    reason: "list_by_schemacode 对任意 schemaCode 自动补建 7 条预置规则并自动 publish（BusinessRuleFacadeImpl.listViewsBySchemaCode:179-185 → BusinessRuleServiceImpl.checkAndFillDefaultBusinessRule:315-344，不校验模型存在；publish 才拦 601003）——幻影 schema 的规则写入会在 API 不可删除的预置行上留下残留，故 rule.save/enable/disable/delete 写前一律先探测模型存在，缺失即 refused `rule-schema-unresolved`",
+    presetDelete: "预置 ruleCode（Create/Update/Delete/GetList/Load/Available/Cancel）删除不可达：list 自动重灌缺失预置，删除后下一次 list 复活且版本行增殖——rule.delete 对预置 code 直接 refused `rule-preset-delete-unreachable`",
+});
+export function ruleEnableDescription() {
+    const chain = RULE_ENABLE_CHAIN;
+    return `启用业务规则（businessrule/publish + businessrule/enable）。两步缺一不可（2026-09-11 live 取证）：${chain.publish}，${chain.enable}——${chain.dispatch}，${chain.conclusion}。${chain.readbackRule}。${RULE_SCHEMA_GATE.reason}。`;
+}
+export function ruleDisableDescription() {
+    return `停用业务规则（businessrule/update）。读回规则行后以整行 + \`enabled:false\` 作为请求体提交。${RULE_ENABLE_CHAIN.readbackRule}。${RULE_SCHEMA_GATE.reason}。`;
+}
+export const RULE_LIFECYCLE_LANE_CONTRACT = Object.freeze({
+    lane: LANES.ruleLifecycle,
+    family: CONTRACT_FAMILY,
+    referenceVersion: CONTRACT_REFERENCE_VERSION,
+    endpoints: Object.freeze({
+        list: "businessRuleListBySchemaCode",
+        publish: "businessRulePublish",
+        enable: "businessRuleEnable",
+        update: "businessRuleUpdate",
+        delete: "businessRuleDelete",
+    }),
+    wire: Object.freeze({
+        chain: Object.freeze(["publish", "enable"]),
+        enableBodyKeys: Object.freeze(["schemaCode", "ruleCode"]),
+        idempotentErrcode: RULE_ENABLE_CHAIN.idempotentErrcode,
+        platformQuirk: RULE_PLATFORM_QUIRK,
+    }),
+    wireBindings: Object.freeze({
+        chain: Object.freeze([behaviorBinding("test/rule-list.test.ts#rule-lifecycle lane contract pins the publish+enable chain", assertRuleLifecycleContract)]),
+        enableBodyKeys: Object.freeze([behaviorBinding("test/rule-list.test.ts#rule-lifecycle lane contract pins the publish+enable chain", assertRuleLifecycleContract)]),
+        idempotentErrcode: Object.freeze([emitterBinding("lanes/rule-lifecycle-contract.RULE_ENABLE_CHAIN", assertRuleLifecycleContract)]),
+        platformQuirk: Object.freeze([emitterBinding("lanes/businessrule-contract.RULE_PLATFORM_QUIRK", assertRuleLifecycleContract)]),
+    }),
+    evidence: Object.freeze([
+        "ticket 02 (2026-09-11): only-publish leaves the rule silently ineffective; publish then enable is required",
+        "getExecutableBySchemaCodeAndCode reads the DRAFT row enabled + latest PUBLISH content",
+        "re-enabling an already-enabled rule answers 550014 业务规则当前是启用状态 (idempotent)",
+    ]),
+    tools: Object.freeze({
+        "rule.enable": Object.freeze({ scope: "enable invoke disable delete", description: ruleEnableDescription() }),
+        "rule.disable": Object.freeze({ scope: "enable invoke disable delete", description: ruleDisableDescription() }),
+        "rule.delete": Object.freeze({
+            scope: "enable invoke disable delete",
+            description: `删除业务规则（businessrule/delete，id 先经 list 解析）并精确回读缺失。${RULE_SCHEMA_GATE.presetDelete}。${RULE_SCHEMA_GATE.reason}。`,
+        }),
+        "rule.disableMany": Object.freeze({
+            scope: "enable invoke disable delete",
+            description: "批量停用某模型的业务规则（一次调用，逐条 businessrule/update enabled:false）。**默认停用全部匹配规则（含平台预置触发码 Create/Update/…）**——用户逻辑常写进预置行，跳过会静默漏停；`customOnly:true` 只停自定义、跳过预置，`ruleCodes` 限定子集。返回 disabled/skipped 与仍在启用的兜底核对。",
+        }),
+        configure_rule: Object.freeze({
+            scope: "enable invoke disable delete",
+            description: "High-level: save a business rule and enable it (rule.save → rule.enable → readback), subject to the write permission gate.",
+        }),
+    }),
+});
+export function assertRuleLifecycleContract() {
+    assertLaneContract(RULE_LIFECYCLE_LANE_CONTRACT);
+    if (RULE_ENABLE_CHAIN.idempotentErrcode !== 550014)
+        throw new Error("rule-lifecycle contract pins the idempotent re-enable errcode to 550014");
+    assertDescriptionCarries(RULE_LIFECYCLE_LANE_CONTRACT, "rule.enable", ["businessrule/publish", "businessrule/enable", "DRAFT", "PUBLISH", "`enabled`", "`status`"]);
+    assertDescriptionCarries(RULE_LIFECYCLE_LANE_CONTRACT, "rule.disable", ["businessrule/update", "`enabled:false`", "`enabled`", "`status`"]);
+    assertDescriptionCarries(RULE_LIFECYCLE_LANE_CONTRACT, "rule.disableMany", ["businessrule/update", "enabled:false", "customOnly", "ruleCodes", "disabled"]);
+    assertDescriptionCarries(RULE_LIFECYCLE_LANE_CONTRACT, "rule.delete", ["businessrule/delete", "rule-preset-delete-unreachable", "预置", "rule-schema-unresolved"]);
+    assertDescriptionCarries(RULE_LIFECYCLE_LANE_CONTRACT, "configure_rule", ["rule.save", "rule.enable"]);
+    if (JSON.stringify(RULE_LIFECYCLE_LANE_CONTRACT.wire.chain) !== JSON.stringify(["publish", "enable"]))
+        throw new Error("rule-lifecycle contract pins the enable chain to publish+enable");
+    if (JSON.stringify(RULE_LIFECYCLE_LANE_CONTRACT.wire.enableBodyKeys) !== JSON.stringify(["schemaCode", "ruleCode"]))
+        throw new Error("rule-lifecycle contract pins the enable body keys");
+    if (!RULE_PLATFORM_QUIRK.includes("status"))
+        throw new Error("rule-lifecycle contract must pin the enabled/status quirk");
+}
+//# sourceMappingURL=rule-lifecycle-contract.js.map

package/dist/lanes/rule-lifecycle-coverage.js

@@ -0,0 +1,20 @@
+import { claim, declareLaneCoverage } from "./coverage-declaration.js";
+import { RULE_LIFECYCLE_LANE_CONTRACT } from "./rule-lifecycle-contract.js";
+const T = RULE_LIFECYCLE_LANE_CONTRACT.tools;
+export const RULE_LIFECYCLE_COVERAGE = declareLaneCoverage(RULE_LIFECYCLE_LANE_CONTRACT.lane, [
+    {
+        capability: "S25 business-rule enable/invoke/disable/delete lifecycle",
+        evidence: [
+            ".scratch/omc-business-rules/acceptance/s25-enable-20260910001115307.md",
+            ".scratch/omc-business-rules/acceptance/s25-cleanup-20260910001140227.md",
+        ],
+        tools: [
+            claim("rule.enable", T["rule.enable"].scope),
+            claim("rule.disable", T["rule.disable"].scope),
+            claim("rule.delete", T["rule.delete"].scope),
+            claim("rule.disableMany", T["rule.disableMany"].scope),
+            claim("configure_rule", T["configure_rule"].scope),
+        ],
+    },
+]);
+//# sourceMappingURL=rule-lifecycle-coverage.js.map

package/dist/lanes/rule-lifecycle.js

@@ -0,0 +1,176 @@
+import { z } from "zod";
+import { ENDPOINTS } from "../endpoints.js";
+import { writeTool } from "../write.js";
+import { registerPackageTool } from "../package-tool.js";
+import { writeSummary } from "../human-summary.js";
+import { executeRuleSaveWrite, ruleNodeGraphArg, assertRuleSchemaExists } from "../rule-support.js";
+import { ToolRefusalError } from "../tool-types.js";
+import { prepareRuleGraph, validateRuleNodeGraph, PLATFORM_TRIGGER_RULE_CODES } from "./rule-graph.js";
+import { wireCall, wireRows, WireError } from "../wire.js";
+import { RULE_ENABLE_CHAIN, RULE_LIFECYCLE_LANE_CONTRACT } from "./rule-lifecycle-contract.js";
+const RULE_LIFECYCLE_LANE = RULE_LIFECYCLE_LANE_CONTRACT.lane;
+const RULE_LIFECYCLE_TOOLS = RULE_LIFECYCLE_LANE_CONTRACT.tools;
+export async function executeRuleEnableWrite(session, args) {
+    await assertRuleSchemaExists(session, args.schemaCode);
+    const list = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
+    const row = wireRows(list.data).find((item) => item.code === args.ruleCode);
+    if (!row?.id)
+        throw new WireError("business", `rule ${args.ruleCode} not found for enable`, 302024);
+    // Publish must carry the FULL model, not the list-projection row. The list
+    // face (`list_by_schemacode`) omits `node`/`route`/`schedulerSetting`; for a
+    // TIMING_TASK rule that makes `BusinessRuleServiceImpl.updateTimerJob` see a
+    // null scheduler and early-return — the quartz job is NEVER created, so the
+    // rule reads back "enabled" but never fires (2026-10-06 live: rule.enable from
+    // the list row → no `create Job`, `qrtz_job_details` empty). Fetch the
+    // authoritative model via `businessrule/get?id` (same face `rule.get` uses),
+    // stamp enabled+status, then publish — which creates/reschedules the job.
+    const full = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id: String(row.id) } })).data;
+    if (!full)
+        throw new WireError("business", `rule ${args.ruleCode} 完整模型读回为空（businessrule/get id ${row.id}），拒绝用列表投影发布`, 302024);
+    const published = await wireCall(session, { path: ENDPOINTS.businessRulePublish, method: "POST", body: { ...full, enabled: true, status: "ENABLED" } });
+    let enableErrcode = 0;
+    let alreadyEnabled = false;
+    try {
+        const enabled = await wireCall(session, { path: ENDPOINTS.businessRuleEnable, method: "POST", body: { schemaCode: args.schemaCode, ruleCode: args.ruleCode } });
+        enableErrcode = enabled.errcode;
+    }
+    catch (error) {
+        if (error instanceof WireError && error.kind === "business" && error.errcode === RULE_ENABLE_CHAIN.idempotentErrcode)
+            alreadyEnabled = true;
+        else
+            throw error;
+    }
+    const readback = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
+    const after = wireRows(readback.data).find((item) => item.code === args.ruleCode);
+    if (after?.enabled !== true)
+        throw new ToolRefusalError({ status: "refused", blocker: "rule-enable-readback-failed", message: `rule ${args.ruleCode} 发布后未启用；enabled 必须为 true` });
+    return { performed: { errcode: published.errcode, enableErrcode, ...(alreadyEnabled ? { alreadyEnabled: true } : {}) }, readback: { enabled: true } };
+}
+export function registerRuleLifecycleLane(tools) {
+    writeTool(tools, "rule.enable", RULE_LIFECYCLE_LANE, RULE_LIFECYCLE_TOOLS["rule.enable"].scope, RULE_LIFECYCLE_TOOLS["rule.enable"].description, { schemaCode: z.string().min(1), ruleCode: z.string().min(1) }, async (session, args) => executeRuleEnableWrite(session, args));
+    writeTool(tools, "rule.disable", RULE_LIFECYCLE_LANE, RULE_LIFECYCLE_TOOLS["rule.disable"].scope, RULE_LIFECYCLE_TOOLS["rule.disable"].description, { schemaCode: z.string().min(1), ruleCode: z.string().min(1) }, async (session, args) => {
+        await assertRuleSchemaExists(session, args.schemaCode);
+        const list = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
+        const row = wireRows(list.data).find((item) => item.code === args.ruleCode);
+        if (!row?.id)
+            throw new WireError("business", `rule ${args.ruleCode} not found for disable`, 302024);
+        const performed = await wireCall(session, { path: ENDPOINTS.businessRuleUpdate, method: "POST", body: { ...row, enabled: false, status: "DISABLED" } });
+        const readback = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
+        const after = wireRows(readback.data).find((item) => item.code === args.ruleCode);
+        return { performed: { errcode: performed.errcode }, readback: { enabled: after?.enabled === true } };
+    });
+    writeTool(tools, "rule.delete", RULE_LIFECYCLE_LANE, RULE_LIFECYCLE_TOOLS["rule.delete"].scope, RULE_LIFECYCLE_TOOLS["rule.delete"].description, { schemaCode: z.string().min(1), ruleCode: z.string().min(1) }, async (session, args) => {
+        // Ticket 96 finding: the preset rule codes are platform-managed —
+        // listViewsBySchemaCode re-fills any missing preset for the schema, so
+        // deleting one via the API is unreachable (it resurrects on the next
+        // list). Refuse up front instead of "succeeding" and multiplying rows.
+        if (PLATFORM_TRIGGER_RULE_CODES.has(args.ruleCode))
+            throw new ToolRefusalError({
+                status: "refused",
+                blocker: "rule-preset-delete-unreachable",
+                message: `ruleCode "${args.ruleCode}" 是平台预置触发规则——list_by_schemacode 会自动重灌缺失预置（BusinessRuleFacadeImpl.listViewsBySchemaCode:179-185），API 删除不可达且会增殖版本行；预置规则请用 rule.save 覆盖图或 rule.disable 停用`,
+            });
+        await assertRuleSchemaExists(session, args.schemaCode);
+        const list = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
+        const row = wireRows(list.data).find((item) => item.code === args.ruleCode);
+        if (!row?.id)
+            throw new WireError("business", `rule ${args.ruleCode} not found for delete`, 302024);
+        const performed = await wireCall(session, { path: ENDPOINTS.businessRuleDelete, method: "POST", query: { id: String(row.id) } });
+        const readback = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
+        return { performed: { errcode: performed.errcode }, readback: { absent: !wireRows(readback.data).some((item) => item.code === args.ruleCode) } };
+    });
+    // Round 10 issue 05 — lifecycle batch. Disabling a model's rules one by one was
+    // N calls; this flips `enabled:false` on every matching rule in one tool. Only
+    // CUSTOM rules by default (platform preset trigger rows must not be disabled —
+    // they are platform-managed); `includePresets:true` opts in explicitly.
+    writeTool(tools, "rule.disableMany", RULE_LIFECYCLE_LANE, RULE_LIFECYCLE_TOOLS["rule.disableMany"].scope, RULE_LIFECYCLE_TOOLS["rule.disableMany"].description, {
+        schemaCode: z.string().min(1),
+        ruleCodes: z.array(z.string().min(1)).optional().describe("只停用这些 code；省略=该模型全部规则"),
+        customOnly: z.boolean().optional().describe("默认 false：停用全部匹配规则（含平台预置触发码 Create/Update/…，因为用户逻辑常写在其中）；true 只停用自定义规则、跳过预置。"),
+    }, async (session, args) => {
+        await assertRuleSchemaExists(session, args.schemaCode);
+        const list = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } });
+        const wanted = args.ruleCodes ? new Set(args.ruleCodes) : undefined;
+        const targets = wireRows(list.data).filter((row) => {
+            const code = String(row.code ?? "");
+            if (wanted && !wanted.has(code))
+                return false;
+            // NOTE: presets are INCLUDED by default — user logic is frequently
+            // authored INTO preset trigger rows (Create/Update/…), so skipping them
+            // would silently leave the user's rules enabled. customOnly:true opts out.
+            if (args.customOnly === true && PLATFORM_TRIGGER_RULE_CODES.has(code))
+                return false;
+            return true;
+        });
+        const disabled = [];
+        const skipped = [];
+        for (const row of targets) {
+            const code = String(row.code ?? "");
+            try {
+                await wireCall(session, { path: ENDPOINTS.businessRuleUpdate, method: "POST", body: { ...row, enabled: false, status: "DISABLED" } });
+                disabled.push(code);
+            }
+            catch (error) {
+                skipped.push({ ruleCode: code, reason: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        const after = wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode: args.schemaCode } })).data);
+        const stillEnabled = after.filter((row) => row.enabled === true && disabled.includes(String(row.code ?? ""))).map((row) => String(row.code));
+        return { performed: { disabled }, readback: { disabledCount: disabled.length, disabled, skipped, stillEnabled } };
+    });
+    registerPackageTool(tools, {
+        name: "configure_rule",
+        lane: RULE_LIFECYCLE_LANE,
+        scope: RULE_LIFECYCLE_TOOLS.configure_rule.scope,
+        description: RULE_LIFECYCLE_TOOLS.configure_rule.description,
+        inputSchema: {
+            schemaCode: z.string().min(1),
+            ruleCode: z.string().min(1),
+            name: z.string().min(1),
+            nodeGraph: ruleNodeGraphArg,
+            customTrigger: z.boolean().optional().describe("默认开：自定义 ruleCode + bizRuleType 0 会在 START 后合成 CUSTOM_NODE 系统触发节点；显式 false 退回（见 rule.save 描述）"),
+        },
+        // CFG-02/CFG-26: lint the SAME normalized graph the executor sends, before
+        // the plan is built — a bad graph must refuse here, not after the
+        // human has already approved a package that cannot run.
+        preflight: (args) => {
+            const prepared = prepareRuleGraph(args.ruleCode, (args.nodeGraph ?? {}), args.customTrigger, args.schemaCode);
+            const blockers = [...prepared.warnings, ...validateRuleNodeGraph(prepared.graph, args.ruleCode, typeof args.schemaCode === "string" ? args.schemaCode : undefined)];
+            // Ticket 113: warning-severity findings ride the payload but never gate.
+            if (blockers.some((blocker) => blocker.severity !== "warning"))
+                throw new ToolRefusalError({ status: "refused", blocker: "rule-graph-validation-failed", message: "nodeGraph 未过出门前校验（dry lint）；按 validation 逐项修正，校验器不猜不改", validation: blockers });
+        },
+        plan: (args) => ({
+            summary: writeSummary("configure_rule", args, undefined, "plan"),
+            actions: [
+                { tool: "rule.save", args: { schemaCode: args.schemaCode, ruleCode: args.ruleCode, name: args.name, nodeGraph: args.nodeGraph, ...(args.customTrigger === true ? { customTrigger: true } : {}) } },
+                { tool: "rule.enable", args: { schemaCode: args.schemaCode, ruleCode: args.ruleCode } },
+            ],
+        }),
+        execute: async (session, args) => {
+            const results = [];
+            // configure_rule MUST delegate to rule.save's upsert (which can also
+            // update the platform's preset trigger rules like Create/Update) —
+            // never bypass with a direct create-only call.
+            const saveOutcome = await executeRuleSaveWrite(session, {
+                schemaCode: args.schemaCode,
+                ruleCode: args.ruleCode,
+                name: args.name,
+                nodeGraph: args.nodeGraph,
+                ...(args.customTrigger === true ? { customTrigger: true } : {}),
+            });
+            results.push({ step: "rule.save", errcode: saveOutcome.performed.errcode, mode: saveOutcome.performed.mode });
+            try {
+                const enableOutcome = await executeRuleEnableWrite(session, args);
+                results.push({ step: "rule.enable", ...enableOutcome });
+                return { steps: results, readback: { rulePresent: true, enabled: true } };
+            }
+            catch (error) {
+                const envelope = error instanceof ToolRefusalError ? { ...error.payload } : error instanceof WireError ? { blocker: `wire-${error.kind}`, errcode: error.errcode, message: error.message } : { blocker: "configure-rule-step-failed", message: String(error) };
+                return { status: "refused", steps: results, failedStep: { index: results.length, tool: "rule.enable" }, envelope };
+            }
+        },
+        summarize: (args, _outcome, phase) => writeSummary("configure_rule", args, undefined, phase),
+    });
+}
+//# sourceMappingURL=rule-lifecycle.js.map

package/dist/lanes/runtime-data-contract.js

@@ -0,0 +1,264 @@
+import { z } from "zod";
+import { assertDescriptionCarries, assertLaneContract, behaviorBinding, CONTRACT_FAMILY, CONTRACT_REFERENCE_VERSION, describeTool, emitterBinding } from "./contract-support.js";
+import { LANES } from "./lane-ids.js";
+/**
+ * M2 runtime-data wire facts (live-proven). The submit chain, the replayToken
+ * gate, the three-layer queryCondition, and the propertyType injection are the
+ * single source for the handler, the arg schemas, and the fake.
+ */
+export const RUNTIME_DATA_WIRE = Object.freeze({
+    queryConditionShape: "List<List<List<FilterModel>>>（level 1 AND across groups, level 2 OR across and-groups, level 3 AND across leaves）",
+    dslShape: "or>and>叶子",
+    queryBodyCanon: "filters:[], queryVersion:1, queryCode=schemaCode, showTotal",
+    typeCastErrcode: 10009,
+    emptyModelErrcode: 301005,
+    absenceErrcode: 304001,
+    formTypeNoWorkflow: "2",
+    formTypeWorkflow: "1",
+    replayTokenEndpoint: "/api/api/runtime/form/getReplayToken",
+    replayTokenErrcode: 100005,
+    approvalNpeErrcode: 50000,
+    workflowStartDuplicateErrcode: 40000,
+    submitChain: "submit 自持久化（ticket 18 源码证据）：form/submit 持久化 bizObject.data——formType=2 submitBizSheet→saveBizObject（置 COMPLETED，mergeObject 合并）；formType=1 workItem→SubmitDataChangeHandlerImpl.updateBizObject；payload {id,schemaCode,sheetCode,ownerId?,data}+actionCode:\"submit\"，owner 服务端以库内行回填，data 剥 engine 键（sequenceStatus/sequenceNo）",
+    submitInPlace: "无流程且 bizObjectId 有值时先 form/load 预检（缺席 304001 拒绝），再以预检行+formData 合成最小对象直提 runtime/form/submit（submit 自持久化，无预 save/构建 load）；submit 返回 objectId 必须仍是目标 id，否则拒绝；仅无 workflowCode/workItemId/workflowInstanceId 的无 id 便捷链先 form/save 建稿再直提（新建记录）；带 workItemId 或 workflowInstanceId 而缺 bizObjectId 时 fail-closed 拒绝（submit-biz-object-id-required）；workflowCode + 既有无实例 bizObjectId 在 8.6.26 无 REST 就地面（见 workflowStartCreateOnly），持续拒绝并指向 workflowDraftSave 两段式",
+    workflowDraftSave: "门户暂存形状（ticket 13）：POST runtime/form/save 顶层带 workflowCode（无 workflowInstanceId/workItemId）→ FormRuntimeController.saveWorkflow→startWorkflow(finishStart=FALSE)：同 id 建 DRAFT 行 + DRAFT 流程实例 + 发起 workItem，FormSaveVO 返回 {objectId,workflowInstanceId,workItem:{id}}；必须先 GET getReplayToken（isStartWf 分支 verifyReplay，否则 100005），且 data 显式 sequenceStatus:\"DRAFT\"（createAndGetBizObject 空缺省按 PROCESSING 建实例）；提交该草稿 = form/submit formType=1 + workItemId + workflowInstanceId + bizObject.id（submitWorkflowByInstanceIdAndItemId），同 id 就地 PROCESSING，绝不走 workflowCode 分支",
+    workflowStartCreateOnly: "form/submit formType=1 + workflowCode（无 workItemId）→ submitWorkflowByWorkflowCode→startWorkflowInstance(create)→BizObjectFacadeImpl.createAndGetBizObject 纯 INSERT（BizObjectInsertModel 无存在性检查）→ 既有 id 必 40000 Duplicate entry（TID 771f64ee 全栈：ExecutorBase INSERT→BizObjectServiceImplCompanion:275→40000）；8.6.26 唯一 load+update 型就地发起是 WorkflowInstanceFacade 5 参重载（908 行，facade 层供二开扩展消费），无 REST 面",
+    sheetResolution: "explicit caller arg > default-form sheetCode from bizsheet/get > schemaCode fallback",
+    updateBranch: "POST runtime/form/save 更新既有记录：目标 id 必须放进 bizObject.data[\"id\"]（平台 BizObjectModel.getId() 读 data 的 id 键；顶层 bizObject.id 会被忽略并退化为新建）；命中既有记录时 FormRuntimeController.saveBizSheet→BizObjectFacadeImpl.updateBizObject，未命中则 createBizObject 插入",
+    updateStatusRule: "既有记录的 DRAFT/COMPLETED 状态在未显式传 sequenceStatus 时原样保留（saveBizSheet 分支），COMPLETED 记录可直接 update，无需流程",
+    updateMergeRule: "updateBizObject.mergeObject 以库内旧值打底、以本次 data 覆盖 → 部分字段（patch）更新，未传字段保持不变",
+    childRowStatusNote: "子表行（CHILD_TABLE(8)）在 form-save 路径按每行 `rowStatus` 分派（BizObjectUpdateModel.convertBizObjectOpItem）：Added=插入 / Modified=更新 / Deleted=删除；**缺失或其它值=immutable（静默忽略）**。门户前端会为改动行标 `rowStatus:\"Modified\"`；手拼载荷漏了它，子表改动不落库、但写仍返回 errcode 0（真机 2026-10-08：data.update 改子表行无 rowStatus，process_name/计划时间读回全不变）。OMC 自动补：带自身 id 的行→\"Modified\"，无 id 的行→\"Added\"，显式 rowStatus 原样保留。",
+    updateAbsentGuard: "平台对\"带 id 但库内不存在\"不报错而是静默插入（createBizObject），故 data.update 先 form/load 预检，命中缺席则以 304001 拒绝，绝不静默转新增",
+    projectionHint: "所选列在默认视图未配置（值可能存在但列表投影为 null）；先用 listview.configure 配置列，或用 data.load 读单条权威值",
+    formulaFieldNote: "计算字段（FORMULA / 表单「计算」控件、子表计算规则）**不在服务端 API 路径回填/重算**：门户是**前端**算好再提交，API save/update/submit 都不会替它算（真机 2026-09-25：子表计算规则字段落库仍 null；纯主表表达式会算）。OMC 的定位是「字段配好即默认它在前台会算」——**写测试数据时应在 formData 里显式带上预算好的计算值**（让数据与预期自洽），**不要指望平台在 API 保存时替它算，也不要用 API 回读值去断言公式/计算是否正确**。**这类纯前台行为最终由人工在前台（配表单→填表）确认。** 另：带**子表计算字段**的模型，API data.save/data.update 可能因服务端重算（CalculateHandler→FormulaProcessor）NPE 而 50000（真机 2026-10-07，前台路径正常）——此类模型请改用门户录入或避开该字段，别据此判定配置错误。",
+});
+function encodeScalar(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (value instanceof Date)
+        return value.toISOString();
+    return JSON.stringify(value);
+}
+function encodeList(value) {
+    if (Array.isArray(value))
+        return value.map(encodeScalar).join(";");
+    if (typeof value === "string")
+        return value;
+    return encodeScalar(value);
+}
+const numeric = (value) => Number(value);
+function betweenBounds(expected) {
+    const [low, high] = expected.split(";").map(Number);
+    return [low ?? 0, high ?? 0];
+}
+export const RUNTIME_QUERY_OPERATORS = Object.freeze({
+    Eq: { encode: encodeScalar, matches: (actual, expected) => String(actual ?? "") === expected },
+    NotEq: { encode: encodeScalar, matches: (actual, expected) => String(actual ?? "") !== expected },
+    Gt: { encode: encodeScalar, matches: (actual, expected) => numeric(actual) > numeric(expected) },
+    Lt: { encode: encodeScalar, matches: (actual, expected) => numeric(actual) < numeric(expected) },
+    Gte: { encode: encodeScalar, matches: (actual, expected) => numeric(actual) >= numeric(expected) },
+    Lte: { encode: encodeScalar, matches: (actual, expected) => numeric(actual) <= numeric(expected) },
+    Like: { encode: encodeScalar, matches: (actual, expected) => String(actual ?? "").includes(expected) },
+    NotLike: { encode: encodeScalar, matches: (actual, expected) => !String(actual ?? "").includes(expected) },
+    In: { encode: encodeList, matches: (actual, expected) => expected.split(";").includes(String(actual ?? "")) },
+    NotIn: { encode: encodeList, matches: (actual, expected) => !expected.split(";").includes(String(actual ?? "")) },
+    Between: { encode: encodeList, matches: (actual, expected) => { const [low, high] = betweenBounds(expected); return numeric(actual) >= low && numeric(actual) <= high; } },
+    NotBetween: { encode: encodeList, matches: (actual, expected) => { const [low, high] = betweenBounds(expected); return !(numeric(actual) >= low && numeric(actual) <= high); } },
+    IsNull: { encode: () => "", matches: (actual) => actual === null || actual === undefined },
+    IsNotNull: { encode: () => "", matches: (actual) => actual !== null && actual !== undefined },
+});
+export const ENGINE_OWNED_KEYS = Object.freeze(["sequenceStatus", "2147483647_sequenceNo"]);
+export const SUBMIT_STATUS_TRANSITIONS = Object.freeze({
+    /** Start submit / start-item finish moves the row DRAFT -> PROCESSING. */
+    workflowStart: "PROCESSING",
+    /** Approval submit with agree!==false completes the row. */
+    approvalAgree: "COMPLETED",
+    /** Approval submit with agree===false cancels the row. */
+    approvalReject: "CANCELED",
+    /** formType=2 submitBizSheet -> saveBizObject completes in place. */
+    inPlaceSubmit: "COMPLETED",
+});
+export function dataListDescription() {
+    const wire = RUNTIME_DATA_WIRE;
+    return `按简化过滤 DSL 查询业务对象（runtime/query/list）；DSL 在 CLI 内翻译为平台 queryCondition（${wire.dslShape}），并按发布字段元数据为每个条件注入 propertyType（未知过滤字段将被拒绝，可用 rawCondition 逃生）；响应仅返回选定 fields 与分页元数据；空模型返回空列表；未配列的自定义字段投影为 null——这是显示面缺列配置、不是数据缺失（data.load 有值），显式选列在结果中全为 null 而发布字段元数据显示其存在时，readback 追加 projectionHint（先用 listview.configure 配置该模型的默认视图列，或用 data.load 读单条权威值）。`;
+}
+export function dataUpdateDescription() {
+    const wire = RUNTIME_DATA_WIRE;
+    return describeTool("M2 runtime data UPDATE (runtime/form/save with data.id, bizObjectId arg).", [
+        `编辑既有业务对象：${wire.updateBranch}。`,
+        `状态语义 ${wire.updateStatusRule}。`,
+        `${wire.updateMergeRule}。`,
+        `缺席保护：${wire.updateAbsentGuard}。`,
+        `子表行：${wire.childRowStatusNote}`,
+        `计算字段：${wire.formulaFieldNote}`,
+        "成功后以 form/load 权威读回变更字段；审批门/生产拒绝/租约与其他 M2 写一致（governedWrite）。",
+    ]);
+}
+export function dataSaveDescription() {
+    const wire = RUNTIME_DATA_WIRE;
+    return describeTool("M2 runtime data write (runtime/form/save) — returns bizObjectId for authoritative readback via data.load.", [
+        `带可选 workflowCode 时按门户暂存形状创建流程草稿：${wire.workflowDraftSave}。`,
+        "formData 禁止携带 id（带 id 的就地发起在 8.6.26 无 REST 面，会被拒绝；既有无实例草稿请改用两段式或 data.submit 的 workItemId 审批链）。",
+        "关联值形状（live 2026-09-24）：**单选关联（propertyType 9）传 id 字符串或 { id }；传数组会 50000**；多选关联（11）才用数组。**人员/组织（50/51/60/61）传选择对象数组 `[{\"id\":\"<id>\",\"type\":3,\"name\":\"<名>\"}]`——`type` 必填**（BizField.parseFromClient 把 `type` 强转 Integer 并 intValue()，缺 `type` 稳定 50000）；`type` 取 UnitType 索引：用户=3、部门=1。字段 `mappings` 由表单运行时在用户选择时套用，**服务端 data.save 不会自动回填映射目标字段**——API 侧调用需自行写入被映射字段，否则读回为空（不要误判为映射配置失败）。",
+        `不带 workflowCode 走纯表单保存（新行 DRAFT）；formType 语义与 replayToken 门见 data.submit 契约（${wire.replayTokenErrcode}）。`,
+        "根因提示（环境相关，ticket 78 观测）：**某些环境**里模型所在应用未发布时运行时写稳定 50000（同调用在已发布应用成功），工具会反推并拒 app-not-published。注意该根因并非普遍规律——2026-09-19 实测另有一类环境未发布应用也能写运行时数据（详见 docs/issues/omc-cli-findings-2026-09-19.md B17）。遇 50000 时先用只读数据核对，不要仅凭“应用未发布”就放弃运行时验证。",
+        `子表行：${wire.childRowStatusNote}`,
+        `计算字段：${wire.formulaFieldNote}`,
+        "Pass `sheetCode` explicitly when the model has multiple sheets; when omitted, the model's default-form sheetCode is resolved from bizsheet/get.",
+    ]);
+}
+export function dataSubmitDescription() {
+    const wire = RUNTIME_DATA_WIRE;
+    return describeTool(`M2 runtime data SUBMIT (runtime/form/submit, WorkItemSubmitVO).`, [
+        "Distinct from data.save: data.save persists as DRAFT; data.submit advances the record to COMPLETED (no workflow) or drives the workflow instance.",
+        "**审批提交（workItemId+agree）时 `formData` 也必填，且其值会写回业务对象——勿把期望结果（如审批级别）预写进 formData，否则规则回写的真伪无法区分（2026-09-22 实测返工案例）**；只传身份参数会被拒 formData: Required。",
+        `就地语义：${wire.submitInPlace}；无流程 readback 必须确认 objectId 与传入 bizObjectId 相同；无 bizObjectId 的 workflowCode 新建单 → PROCESSING + workflowInstanceId，无流程 → 该行 COMPLETED。`,
+        `既有草稿发起流程的唯一支持形状是两段式：先 data.save 带 workflowCode 暂存（${wire.workflowDraftSave}），再以返回的 workItemId 提交。`,
+        `仅无 workflowCode/workItemId/workflowInstanceId 且无 bizObjectId 时保留 save→submit 便捷链（新建记录）；只要存在 workItemId 或 workflowInstanceId 就 fail-closed 拒绝（blocker submit-biz-object-id-required），零 runtime/form/submit wire。`,
+        `formType 自动判定：无任何 workflowCode/workItemId/workflowInstanceId 时**先按模型自动判定**——GET workflow/isworkflow?schemaCode=true 则用 workflow/getWorkflow 解析已发布流程码并**发起流程**（formType="${wire.formTypeWorkflow}"，自动先 GET getReplayToken 注入 replayToken，否则 ${wire.replayTokenErrcode} 频繁重复提交）；模型无流程 → "${wire.formTypeNoWorkflow}"（无流程提交，走 live 已证链 ${wire.submitChain}；单发新建对象会 ${wire.typeCastErrcode}，bizObject 勿带字符串 status）或 workItemId+workflowInstanceId（审批待办，agree 通过/驳回，**必须带 bizObjectId 指向在途单据**，否则引擎 NPE ${wire.approvalNpeErrcode}）→ "${wire.formTypeWorkflow}"。即「无流程直接提交、有流程发起流程」，不再把有流程模型的新建数据落成游离 sheet 行。`,
+        "根因提示（环境相关，ticket 78 观测）：**某些环境**里模型所在应用未发布时运行时提交稳定 50000，工具会反推并拒 app-not-published。该根因非普遍规律（见 data.save 的同条提示与 docs/issues/omc-cli-findings-2026-09-19.md B17）——遇 50000 先只读核对再判断。",
+        "Pass `sheetCode` explicitly when the model has multiple sheets; otherwise the default-form sheetCode is resolved from bizsheet/get.",
+        `计算字段：${wire.formulaFieldNote}`,
+    ]);
+}
+/** Runtime business-object data keyed by field code. */
+export const runtimeFormDataArg = z
+    .record(z.string(), z.unknown())
+    .describe('business-object data keyed by field code, e.g. { name:"...", omc_x_amount:123, omc_x_rel:"<target objectId>" }. Relation value SHAPE depends on the field type (live 2026-09-24): a SINGLE relation (WORK_SHEET, propertyType 9) takes the target object id string or an object { id, name? } — an ARRAY here makes runtime/form/save answer 50000; a MULTI relation (propertyType 11) takes an array. STAFF/ORG fields (propertyType 50/51/60/61) take an array of selection objects `[{ id, type, name }]` where `type` is MANDATORY (BizField.parseFromClient casts `type` to Integer and calls intValue(); omitting it answers 50000) — `type` is the UnitType index: USER=3, DEPARTMENT=1. When unsure, prefer "id" or { id }. Field `mappings` are applied by the form RUNTIME when a user picks a value — a server-side data.save does NOT copy source→target, so API callers must set the mapped fields themselves.');
+export const RUNTIME_DATA_LANE_CONTRACT = Object.freeze({
+    lane: LANES.runtimeData,
+    family: CONTRACT_FAMILY,
+    referenceVersion: CONTRACT_REFERENCE_VERSION,
+    endpoints: Object.freeze({
+        queryList: "runtimeQueryList",
+        formSave: "runtimeFormSave",
+        formLoad: "runtimeFormLoad",
+        formDelete: "runtimeFormDelete",
+        formSubmit: "runtimeFormSubmit",
+        replayToken: "runtimeFormReplayToken",
+        sheetGet: "sheetGet",
+        fieldList: "fieldList",
+    }),
+    wire: Object.freeze({
+        queryConditionShape: RUNTIME_DATA_WIRE.queryConditionShape,
+        dslShape: RUNTIME_DATA_WIRE.dslShape,
+        queryBodyCanon: RUNTIME_DATA_WIRE.queryBodyCanon,
+        typeCastErrcode: RUNTIME_DATA_WIRE.typeCastErrcode,
+        emptyModelErrcode: RUNTIME_DATA_WIRE.emptyModelErrcode,
+        absenceErrcode: RUNTIME_DATA_WIRE.absenceErrcode,
+        replayTokenErrcode: RUNTIME_DATA_WIRE.replayTokenErrcode,
+        approvalNpeErrcode: RUNTIME_DATA_WIRE.approvalNpeErrcode,
+        submitChain: RUNTIME_DATA_WIRE.submitChain,
+        submitInPlace: RUNTIME_DATA_WIRE.submitInPlace,
+        workflowDraftSave: RUNTIME_DATA_WIRE.workflowDraftSave,
+        workflowStartCreateOnly: RUNTIME_DATA_WIRE.workflowStartCreateOnly,
+        sheetResolution: RUNTIME_DATA_WIRE.sheetResolution,
+        updateBranch: RUNTIME_DATA_WIRE.updateBranch,
+        updateStatusRule: RUNTIME_DATA_WIRE.updateStatusRule,
+        updateMergeRule: RUNTIME_DATA_WIRE.updateMergeRule,
+        updateAbsentGuard: RUNTIME_DATA_WIRE.updateAbsentGuard,
+        childRowStatusNote: RUNTIME_DATA_WIRE.childRowStatusNote,
+        projectionHint: RUNTIME_DATA_WIRE.projectionHint,
+    }),
+    wireBindings: Object.freeze({
+        queryConditionShape: Object.freeze([emitterBinding("data-list-filter.toQueryCondition", assertRuntimeDataContract)]),
+        dslShape: Object.freeze([emitterBinding("data-list-filter.SIMPLE_OP_MAP", assertRuntimeDataContract)]),
+        queryBodyCanon: Object.freeze([behaviorBinding("test/data-list.test.ts#data.list translates simplified filters", assertRuntimeDataContract)]),
+        typeCastErrcode: Object.freeze([emitterBinding("data-list-filter.injectPropertyTypes", assertRuntimeDataContract)]),
+        emptyModelErrcode: Object.freeze([emitterBinding("lanes/runtime-data-contract.RUNTIME_DATA_WIRE", assertRuntimeDataContract)]),
+        absenceErrcode: Object.freeze([emitterBinding("lanes/runtime-data-contract.RUNTIME_DATA_WIRE", assertRuntimeDataContract)]),
+        replayTokenErrcode: Object.freeze([emitterBinding("lanes/runtime-data-contract.RUNTIME_DATA_WIRE", assertRuntimeDataContract)]),
+        approvalNpeErrcode: Object.freeze([emitterBinding("lanes/runtime-data-contract.RUNTIME_DATA_WIRE", assertRuntimeDataContract)]),
+        submitChain: Object.freeze([behaviorBinding("test/issue-13-data-submit.test.ts#data.submit with formType=2 issues a WorkItemSubmitVO", assertRuntimeDataContract)]),
+        submitInPlace: Object.freeze([behaviorBinding("test/issue-13-data-submit.test.ts#data.submit with bizObjectId submits an existing no-workflow record in place", assertRuntimeDataContract)]),
+        workflowDraftSave: Object.freeze([behaviorBinding("test/issue-13-data-submit.test.ts#data.save with workflowCode creates a DRAFT row", assertRuntimeDataContract)]),
+        workflowStartCreateOnly: Object.freeze([behaviorBinding("test/issue-13-data-submit.test.ts#data.submit refuses existing-id workflow starts", assertRuntimeDataContract)]),
+        sheetResolution: Object.freeze([behaviorBinding("test/issue-13-data-submit.test.ts#data.submit forwards an explicit sheetCode", assertRuntimeDataContract)]),
+        updateBranch: Object.freeze([behaviorBinding("test/data-update.test.ts#data.update edits an existing record in place", assertRuntimeDataContract)]),
+        updateStatusRule: Object.freeze([behaviorBinding("test/data-update.test.ts#data.update updates a COMPLETED record directly", assertRuntimeDataContract)]),
+        updateMergeRule: Object.freeze([behaviorBinding("test/data-update.test.ts#data.update edits an existing record in place", assertRuntimeDataContract)]),
+        updateAbsentGuard: Object.freeze([behaviorBinding("test/data-update.test.ts#data.update does NOT silently insert", assertRuntimeDataContract)]),
+        childRowStatusNote: Object.freeze([behaviorBinding("test/data-update.test.ts#data.update stamps rowStatus on child-table rows", assertRuntimeDataContract)]),
+        projectionHint: Object.freeze([behaviorBinding("test/data-list.test.ts#data.list appends projectionHint", assertRuntimeDataContract)]),
+    }),
+    evidence: Object.freeze([
+        "ticket 01 B (2026-09-11): queryCondition must be List<List<List<FilterModel>>>; a 2-level array answers 10009 类型转换异常",
+        "BizObjectFacadeImpl.getFiltersByQueryParam / buildFilter: level1 AND groups, level2 OR and-groups, level3 AND leaves",
+        "each leaf requires propertyType injected from bizproperty/list isPublish=true field metadata (cpdocs filter-condition contract)",
+        "ticket 02/03 (2026-09-11): submit chain save(DRAFT)→load→submit; workflow start requires getReplayToken or 100005; workItem approval requires bizObjectId or the engine NPEs 50000",
+        "ticket 07 (2026-09-11): a model's unconfigured default list view projects business columns as null though values exist; data.list appends projectionHint when explicit columns are all-null and published metadata lists them",
+        "ticket 13 (2026-09-12): FormRuntimeController.saveWorkflow finishStart=FALSE creates DRAFT instance + start workItem (portal 暂存 shape); WorkflowInstanceFacadeImpl:908 5-arg overload is load+update in-place start but has no REST surface; TID 771f64ee pins create-path INSERT duplicate (40000)",
+        "ticket 18 (2026-09-12): AbstractFormRuntimeController.submitBizSheet sets COMPLETED then saveBizObject (submit persists data itself); SubmitDataChangeHandlerImpl.updateBizObject persists the workItem submit's bizObject; BizObjectHelper.initSubmitBizObject.setOwner re-reads the STORED row's owner — the pre-submit form/save + form/load round-trip is redundant wire",
+    ]),
+    tools: Object.freeze({
+        "data.list": Object.freeze({ scope: "filtered list field projection", description: dataListDescription() }),
+        "data.load": Object.freeze({ scope: "authoritative readback form load", description: "M2 authoritative readback: form/load one business object by id. **返回形状：业务字段值在 `result.data`（非 readback.authoritative）；大结果 stdout 只回 detailArtifactId + fetch 提示，用 `omc artifact get <id>` 取回；`fields:[...]` 可投影只取所需键**。" }),
+        "data.save": Object.freeze({
+            scope: "write authoritative readback form save",
+            description: dataSaveDescription(),
+        }),
+        "data.update": Object.freeze({
+            scope: "write authoritative readback form save",
+            description: dataUpdateDescription(),
+        }),
+        "data.delete": Object.freeze({
+            scope: "write authoritative readback form save",
+            description: desc("M2 runtime data delete (runtime/form/delete) with absence readback."),
+        }),
+        "data.submit": Object.freeze({ scope: "write authoritative readback form save", description: dataSubmitDescription() }),
+    }),
+});
+function desc(lead) {
+    return `${lead} Pass \`sheetCode\` explicitly when the model has multiple sheets; when omitted, the model's default-form sheetCode is resolved from bizsheet/get.`;
+}
+export function assertRuntimeDataContract() {
+    assertLaneContract(RUNTIME_DATA_LANE_CONTRACT);
+    assertDescriptionCarries(RUNTIME_DATA_LANE_CONTRACT, "data.list", ["queryCondition", "propertyType", "rawCondition", "projectionHint", "listview.configure", "data.load"]);
+    assertDescriptionCarries(RUNTIME_DATA_LANE_CONTRACT, "data.save", ["bizObjectId", "sheetCode", "bizsheet/get", "workflowCode", "sequenceStatus", "workItem", "propertyType 9", "50000", "mappings", "rowStatus"]);
+    assertDescriptionCarries(RUNTIME_DATA_LANE_CONTRACT, "data.update", ["runtime/form/save", "bizObjectId", "COMPLETED", "304001", "form/load", "rowStatus"]);
+    assertDescriptionCarries(RUNTIME_DATA_LANE_CONTRACT, "data.delete", ["absence", "sheetCode"]);
+    assertDescriptionCarries(RUNTIME_DATA_LANE_CONTRACT, "data.submit", ["getReplayToken", "replayToken", "bizObjectId", "objectId", "DRAFT", "COMPLETED", "10009", "100005", "NPE", "两段式", "finishStart=FALSE"]);
+    if (!RUNTIME_DATA_WIRE.workflowDraftSave.includes("finishStart=FALSE"))
+        throw new Error("runtime-data contract must pin the portal draft-save chain (finishStart=FALSE)");
+    if (!RUNTIME_DATA_WIRE.workflowStartCreateOnly.includes("40000"))
+        throw new Error("runtime-data contract must pin the create-only workflow start duplicate failure");
+    if (RUNTIME_DATA_WIRE.typeCastErrcode !== 10009)
+        throw new Error("runtime-data contract pins the type-cast errcode to 10009");
+    if (RUNTIME_DATA_WIRE.approvalNpeErrcode !== 50000)
+        throw new Error("runtime-data contract pins the approval NPE errcode to 50000");
+    if (RUNTIME_DATA_WIRE.workflowStartDuplicateErrcode !== 40000)
+        throw new Error("runtime-data contract pins the create-only workflow start duplicate errcode to 40000");
+    if (!RUNTIME_DATA_WIRE.queryConditionShape.includes("level 3 AND across leaves"))
+        throw new Error("runtime-data contract must pin the three-layer queryCondition shape");
+    if (!RUNTIME_DATA_WIRE.dslShape.includes("or>and"))
+        throw new Error("runtime-data contract must pin the or>and>leaf DSL shape");
+    if (!RUNTIME_DATA_WIRE.queryBodyCanon.includes("queryVersion:1") || !RUNTIME_DATA_WIRE.queryBodyCanon.includes("queryCode=schemaCode"))
+        throw new Error("runtime-data contract must pin the query body canon (queryVersion:1, queryCode=schemaCode)");
+    if (RUNTIME_DATA_WIRE.emptyModelErrcode !== 301005)
+        throw new Error("runtime-data contract pins the empty-model errcode to 301005");
+    if (RUNTIME_DATA_WIRE.absenceErrcode !== 304001)
+        throw new Error("runtime-data contract pins the absent-object errcode to 304001");
+    if (RUNTIME_DATA_WIRE.replayTokenErrcode !== 100005)
+        throw new Error("runtime-data contract pins the replay-token errcode to 100005");
+    if (!RUNTIME_DATA_WIRE.submitChain.includes("formType=2") || !RUNTIME_DATA_WIRE.submitChain.includes("formType=1"))
+        throw new Error("runtime-data contract must pin the submit chain formType branches");
+    if (!RUNTIME_DATA_WIRE.submitInPlace.includes("submit-biz-object-id-required"))
+        throw new Error("runtime-data contract must pin the workItem in-place fail-closed blocker");
+    if (!RUNTIME_DATA_WIRE.sheetResolution.includes("bizsheet/get"))
+        throw new Error("runtime-data contract must pin the default-form sheet resolution");
+    if (!RUNTIME_DATA_WIRE.updateBranch.includes('bizObject.data["id"]'))
+        throw new Error("runtime-data contract must pin the update-branch id placement");
+    if (!RUNTIME_DATA_WIRE.updateStatusRule.includes("sequenceStatus"))
+        throw new Error("runtime-data contract must pin the update sequenceStatus preservation");
+    if (!RUNTIME_DATA_WIRE.updateMergeRule.includes("mergeObject"))
+        throw new Error("runtime-data contract must pin the update merge semantics");
+    if (!RUNTIME_DATA_WIRE.childRowStatusNote.includes("rowStatus") || !RUNTIME_DATA_WIRE.childRowStatusNote.includes("immutable"))
+        throw new Error("runtime-data contract must pin the child-row rowStatus dispatch semantics");
+    if (!RUNTIME_DATA_WIRE.projectionHint.includes("listview.configure"))
+        throw new Error("runtime-data contract must pin the projectionHint remediation");
+    if (!RUNTIME_DATA_WIRE.updateAbsentGuard.includes(String(RUNTIME_DATA_WIRE.absenceErrcode)))
+        throw new Error("runtime-data contract must pin the update absent-target guard to the absence errcode");
+}
+//# sourceMappingURL=runtime-data-contract.js.map

package/dist/lanes/runtime-data-coverage.js

@@ -0,0 +1,25 @@
+import { claim, declareLaneCoverage } from "./coverage-declaration.js";
+import { RUNTIME_DATA_LANE_CONTRACT } from "./runtime-data-contract.js";
+const T = RUNTIME_DATA_LANE_CONTRACT.tools;
+export const RUNTIME_DATA_COVERAGE = declareLaneCoverage(RUNTIME_DATA_LANE_CONTRACT.lane, [
+    {
+        capability: "M2 runtime data write and authoritative readback (form/save + form/load)",
+        evidence: [
+            ".scratch/omc-route-wayfinder/leg2-closeout.md",
+            ".scratch/omc-route-wayfinder/research/m2-null-rootcause.md",
+        ],
+        tools: [
+            claim("data.load", T["data.load"].scope),
+            claim("data.save", T["data.save"].scope),
+            claim("data.update", T["data.update"].scope),
+            claim("data.delete", T["data.delete"].scope),
+            claim("data.submit", T["data.submit"].scope),
+        ],
+    },
+    {
+        capability: "data.list filtered business-object listing",
+        evidence: ["packages/omc-cli/src/tools.ts", "packages/omc-cli/test/data-list.test.ts"],
+        tools: [claim("data.list", T["data.list"].scope)],
+    },
+]);
+//# sourceMappingURL=runtime-data-coverage.js.map