@stalfh233/omc-cli 0.6.12 → 0.6.14

package/dist/goal-routes.js

@@ -16,11 +16,56 @@ const READ_CUES = ["查看", "读回", "盘点", "现状", "列出", "有哪些"
 const BUILD_CUES = ["新建", "创建", "搭建", "从零", "从无到有", "做", "建", "加", "实现", "生成", "新增", "保存", "启用", "录入", "添加", "造", "填报", "打卡", "录"];
 /** Whole-application asks — a single-model atom is the wrong shape for these. */
 const WHOLE_APP_CUES = ["应用", "系统", "整套", "从零", "从无到有", "端到端", "一条龙", "一整套", "业务应用", "平台"];
+/** From-scratch cues — firstAnswer must not point at a schema that does not exist yet. */
+const GREENFIELD_CUES = ["从零", "从无到有", "做一个", "做一套", "新建应用", "搭建应用", "端到端", "一条龙"];
 function looksWholePackage(goal, capabilityCount) {
     if (capabilityCount >= 4)
         return true;
     return WHOLE_APP_CUES.some((cue) => goal.includes(cue));
 }
+function looksGreenfield(goal) {
+    return GREENFIELD_CUES.some((cue) => goal.includes(cue));
+}
+/**
+ * r31c F1: multi-face asks must NOT be stolen by the first matching composer.
+ * Conservative: only when ≥2 capability faces score AND the ask is whole-package
+ * shaped (WHOLE_APP cue or ≥4 faces). Single-face composer goals (G1/G2/G5) stay
+ * single-point answers.
+ */
+function shouldPreferMultiFace(mode, goal, scoredCapabilityIds) {
+    if (mode !== "build" && mode !== "modify")
+        return false;
+    if (scoredCapabilityIds.length < 2)
+        return false;
+    return looksWholePackage(goal, scoredCapabilityIds.length);
+}
+/** Short why-line for a capability step in a multi-face ladder (r31c F1). */
+function capabilityWhy(capabilityId, goal) {
+    const cues = CAPABILITY_CUES[capabilityId] ?? [];
+    const hits = cues.filter((cue) => goal.includes(cue)).slice(0, 3);
+    if (hits.length > 0)
+        return hits.join(" + ");
+    switch (capabilityId) {
+        case "model":
+            return "建模";
+        case "field":
+            return "字段 / 子表";
+        case "form":
+            return "表单";
+        case "listview":
+            return "列表 / 按钮";
+        case "datarule":
+            return "字段计算 / 校验";
+        case "businessrule":
+            return "业务规则 / 按钮";
+        case "workflow":
+            return "审批流程";
+        case "onlinejs":
+            return "在线 JS";
+        default:
+            return capabilityId;
+    }
+}
 function detectMode(goal) {
     if (SCOUT_CUES.some((cue) => goal.includes(cue)))
         return "scout";
@@ -419,7 +464,8 @@ const COMPOSER_ROUTES = Object.freeze([
         command: "omc approval-flow --schema <模型code> --steps '<节点名>@role:<角色code>' --apply",
         usage: "omc approval-flow --help",
         // F1（r27）：边界前置——非发起人审批无法在单会话 CLI 内推进，别等 submit 失败才说。
-        summary: "线性审批流一条命令：建流程 → 模板+字段只读权限 → 发布（多级用重复 --steps）。边界：非发起人身份的审批无法在单会话 CLI 内推进（单 token）；若要验跨账号审批，用第二账号另建环境，或把参与人设为 {Originator}",
+        // r31c F5：明说线性-only；条件分支退回 workflow.update；行级可见范围不支持。
+        summary: "线性审批流一条命令：建流程 → 模板+字段只读权限 → 发布（多级用重复 --steps）。⚠️ 只做线性流程，无 --condition；条件分支用 omc describe workflow.update --example workflow-conditional-branch。边界：非发起人身份的审批无法在单会话 CLI 内推进（单 token）；若要验跨账号审批，用第二账号另建环境，或把参与人设为 {Originator}。workflow.permissions 不是行级数据权限（申请人只看自己的单据当前工具面不支持）",
         groups: [["审批", "流程"], ["建", "创建", "新建", "配置", "加", "搭"]],
         // Branching / countersign shapes are NOT this composer's business.
         avoid: ["条件分支", "分支", "会签", "并行", "或签", "网关", "子流程", "动态审批人", "清理", "删除", "移除", "purge", "teardown"],
@@ -502,17 +548,30 @@ function matchComposer(goal, mode) {
 function isWholePackageWrite(mode, goal, capabilityCount) {
     return (mode === "build" || mode === "modify") && looksWholePackage(goal, capabilityCount);
 }
-function wholePackageRoute(registry, goal, index) {
+function wholePackageRoute(registry, goal, index, hitCapabilities) {
     const routeById = new Map(index.routes.map((route) => [route.id, route]));
-    const ordered = orderedCapabilities([...WHOLE_PACKAGE_CAPABILITIES], index).filter((id) => routeById.has(id));
+    // r31c F1: prefer the faces the ask actually named; fall back to the full
+    // package set when the ask only said "做应用" without naming faces.
+    const seed = hitCapabilities !== undefined && hitCapabilities.length >= 2
+        ? [...new Set([...hitCapabilities, "model", "field"])]
+        : [...WHOLE_PACKAGE_CAPABILITIES];
+    const ordered = orderedCapabilities(seed, index).filter((id) => routeById.has(id));
     // Round 16b (dogfood R1): the supplement used to repeat every capability's
     // full tool map (model.create/delete/…, field.create/…), ~60% of a 2.8KB
     // response the caller never used — intent already covers these. Keep it a
     // POINTER (capability + lane + one command), not a second ladder.
-    const ladder = ordered.map((id) => {
-        const capability = routeById.get(id);
-        return { capability: id, lane: capability.lane, firstCommand: `omc commands --json --compact --lane ${capability.lane}` };
-    });
+    // r31c F1: multi-face asks must SEE every face they named (not just the first
+    // composer hit). But this must not be called `ladder` — round16 settled that
+    // whole-package has ONE primary path (intent) and `route.ladder` is the
+    // atomic execution ladder, which for whole-package is deliberately absent
+    // (bench40: two co-equal paths made agents wander). So the face list rides
+    // `route.faces`: same information, no second execution path.
+    const faces = ordered.map((id, indexInFaces) => ({
+        step: indexInFaces + 1,
+        capability: id,
+        why: capabilityWhy(id, goal),
+    }));
+    const greenfield = looksGreenfield(goal);
     return {
         status: "ok",
         goal,
@@ -521,21 +580,34 @@ function wholePackageRoute(registry, goal, index) {
         match: { kind: "whole-package", ref: ordered.join("→"), capabilities: ordered },
         route: {
             primary: "intent",
-            atomicSupplement: { note: "intent 已覆盖下列能力的创建；这些原子工具只用于 intent 未覆盖面（删除/生命周期/运行数据/精确 patch）：", ladder },
-            ...routeReads(sectionPointersFor(ordered)),
+            faceCount: faces.length,
+            atomicSupplement: {
+                note: "intent 已覆盖下列能力的创建；原子工具只用于 intent 未覆盖面（删除/生命周期/运行数据/精确 patch）",
+                capabilities: ordered,
+                // round16b: 这是**指针**（capability + why），不是第二套执行阶梯——
+                // 每步都不带 tools，否则就等于把 atomic ladder 又内联一遍。
+                ladder: faces,
+            },
+            ...routeReads(sectionPointersFor(ordered.slice(0, 3))),
             // r19 ticket 04: readiness (discover_environment) left firstCommands —
             // the probe executed it 0 times in 184 calls; it rides its own field now.
             readiness: DISCOVERY_AUTHORITY.readiness,
-            firstCommands: ["omc intent schema"],
+            firstCommands: ["omc intent schema", "omc help omc-playbook --section 采购申请"],
             write: true,
         },
         write: true,
         intent: intentGuidance(),
-        firstAnswer: {
-            state: "ready",
-            action: "omc intent schema",
-            why: "整包需求走声明式意图：先看 intent YAML 的键位与可运行示例，再按 starter 写文件（validate → plan → apply）",
-        },
+        firstAnswer: greenfield
+            ? {
+                state: "ready",
+                action: "omc intent schema",
+                why: "从零整包：模型还不存在——先看 intent 键位/示例，再按 starter 写 YAML（validate → plan → apply）；不要先问已有 schemaCode",
+            }
+            : {
+                state: "ready",
+                action: "omc intent schema",
+                why: "整包需求走声明式意图：先看 intent YAML 的键位与可运行示例，再按 starter 写文件（validate → plan → apply）",
+            },
     };
 }
 /** A configuration read-back ask that names no capability ("给我一份现状说明"). */
@@ -571,8 +643,17 @@ export function goalRoute(registry, goal) {
     // matched to a nearby capability and handed the write ladder — that is the
     // "invent a capability for a blocked face" anti-pattern. Return a boundary
     // result pointing at capability-scouting + the (read-only) coverage proof.
+    //
+    // r31c F27 exception: a WHOLE-PACKAGE ask that merely MENTIONS an unsupported
+    // face (e.g. 「申请人只看自己」 inside an 8-clause purchase ask) must not
+    // steal the entire multi-face route. Soft-attach the boundary note and keep
+    // routing; pure boundary asks (only that face) stay blocked.
     const boundary = boundaryOf(goal);
-    if (boundary) {
+    const earlyScores = capabilityScores(registry, goal);
+    const earlyScoredIds = [...earlyScores.entries()].filter((entry) => entry[1] >= 2).map((entry) => entry[0]);
+    const multiFaceMentionsBoundary = boundary !== undefined
+        && shouldPreferMultiFace(mode, goal, earlyScoredIds);
+    if (boundary && !multiFaceMentionsBoundary) {
         return {
             status: "ok",
             goal,
@@ -728,9 +809,41 @@ export function goalRoute(registry, goal) {
             };
         }
     }
+    // Score capabilities BEFORE composer capture so a multi-face ask (r31c F1)
+    // is not stolen by the first matching composer (e.g. 「合计」→ compute).
+    const scoreMap = capabilityScores(registry, goal);
+    const scores = [...scoreMap.entries()].sort((left, right) => right[1] - left[1]);
+    const scoredCapabilityIds = scores.filter((entry) => entry[1] >= 2).map((entry) => entry[0]);
     const composer = matchComposer(goal, mode);
+    if (composer && shouldPreferMultiFace(mode, goal, scoredCapabilityIds)) {
+        // Multi-face + whole-package shaped → surface the ordered ladder, not a
+        // single composer. Intent remains the primary path. Soft-attach any
+        // mentioned unsupported face (r31c F27) so the gap is named without
+        // blocking the rest of the package.
+        const routed = wholePackageRoute(registry, goal, index, scoredCapabilityIds);
+        if (boundary) {
+            return {
+                ...routed,
+                boundary: {
+                    id: boundary.id,
+                    status: boundary.status,
+                    note: boundary.note,
+                    soft: true,
+                    verify: "omc help omc-capabilities --section \"边界\"",
+                },
+            };
+        }
+        return routed;
+    }
     if (composer) {
         const topics = (composer.topics ?? []).filter((topic) => availableTopics.has(topic));
+        // r31c F3: if the ask is greenfield, do not point firstAnswer at a schema
+        // that does not exist yet — rewrite the clarifying question to create-first.
+        const baseQuestion = COMPOSER_QUESTIONS[composer.id] ?? "补齐命令里的尖括号占位符后运行（形状见 pendingCommand）";
+        const greenfield = looksGreenfield(goal);
+        const question = greenfield
+            ? `模型还不存在：先创建模型（omc call model.create --args '{"code":"<模型code>","name":"<名称>","applicationCode":"<应用>"}' 或 omc model-scaffold …），再回答：${baseQuestion}`
+            : baseQuestion;
         return {
             status: "ok",
             goal,
@@ -753,15 +866,17 @@ export function goalRoute(registry, goal) {
             ...(topics.length > 0 ? { topics } : {}),
             firstAnswer: {
                 state: "needs-input",
-                question: COMPOSER_QUESTIONS[composer.id] ?? "补齐命令里的尖括号占位符后运行（形状见 pendingCommand）",
-                pendingCommand: composer.command,
-                ...(composer.id === "model-purge" || composer.id === "compute" ? { action: LIST_MODELS_ACTION } : {}),
-                why: composer.summary,
+                question,
+                pendingCommand: greenfield && composer.id !== "model-scaffold" && composer.id !== "model-purge"
+                    ? `omc call model.create --args '{"code":"<模型code>","name":"<名称>","applicationCode":"<应用>"}'`
+                    : composer.command,
+                ...(composer.id === "model-purge" || composer.id === "compute" || greenfield ? { action: LIST_MODELS_ACTION } : {}),
+                why: greenfield
+                    ? `从零需求：先确认/创建模型，再跑 ${composer.id}（${composer.summary}）`
+                    : composer.summary,
             },
         };
     }
-    const scoreMap = capabilityScores(registry, goal);
-    const scores = [...scoreMap.entries()].sort((left, right) => right[1] - left[1]);
     const fallback = {
         status: "ok",
         goal,

package/dist/identity.js

@@ -1,18 +1,70 @@
 import { ENDPOINTS } from "./endpoints.js";
 import { wireCall, wireRows } from "./wire.js";
+import { wireString } from "./workflow-support.js";
+export const PLATFORM_ADMIN_START_BYPASS = "platform-admin bypasses start-permission whitelist";
 /**
- * Identity seam (round 10, ergonomics).
- *
- * One object carries several names across tools: a model is `schemaCode`, a
- * field is `code`/`propertyCode`, a business-rule row's wire key is `id` while
- * its business key is `(schemaCode, ruleCode)`, a workflow is `workflowCode`
- * while the caller only knows the model's `schemaCode`. Today that forces a
- * `list → get` dance and per-lane key memorisation.
- *
- * These resolvers let a tool accept the BUSINESS key and resolve the wire
- * identity internally. They are read-only and return `null` for a genuine miss,
- * so the caller can fail closed with a precise message.
+ * Resolve who is operating this session. Best-effort: never throws.
+ * `isAdmin` comes from login().administrator (info_login permissions contains
+ * ADMIN/SYS_MNG) — that is the platform start-permission bypass, not the
+ * login API's isAdmin boolean.
  */
+export async function resolvePermissionActor(session, options = {}) {
+    let userId = null;
+    let name = null;
+    let isAdmin = false;
+    try {
+        const login = await session.login();
+        isAdmin = login.administrator === true;
+        const identity = login.accountIdentity;
+        if (identity !== undefined && identity.length > 0) {
+            const searchData = (await wireCall(session, {
+                path: ENDPOINTS.organizationUserSearch,
+                method: "POST",
+                body: { wd: identity, page: 0, size: 20 },
+            })).data;
+            const found = Array.isArray(searchData?.content)
+                ? searchData.content
+                : (() => {
+                    try {
+                        return wireRows(searchData);
+                    }
+                    catch {
+                        return [];
+                    }
+                })();
+            const exact = found.find((row) => [row.username, row.userId, row.name].some((value) => String(value ?? "") === identity)) ??
+                found[0];
+            if (exact) {
+                userId = wireString(exact.id) ?? wireString(exact.userId);
+                name = wireString(exact.name) ?? identity;
+                if (userId) {
+                    try {
+                        const info = (await wireCall(session, { path: ENDPOINTS.organizationUserInfo, query: { id: userId } })).data;
+                        if (info) {
+                            userId = wireString(info.id) ?? userId;
+                            name = wireString(info.name) ?? name;
+                        }
+                    }
+                    catch {
+                        // keep search hit
+                    }
+                }
+            }
+            else {
+                name = identity;
+            }
+        }
+    }
+    catch {
+        // best-effort actor — never poison the calling receipt
+    }
+    return {
+        userId,
+        name,
+        isAdmin,
+        ...(options.bypassReason ? { bypassReason: options.bypassReason } : {}),
+    };
+}
 /** Resolve a rule ROW id from `(schemaCode, ruleCode)`. Reuses the list face. */
 export async function resolveRuleRowId(session, schemaCode, ruleCode) {
     const rows = wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode } })).data);

package/dist/lanes/app-contract.js

@@ -56,15 +56,15 @@ export const APP_LANE_CONTRACT = Object.freeze({
     tools: Object.freeze({
         "app.list": Object.freeze({
             scope: "app package list",
-            description: "列出应用（apppackage/list）及其所属分组；用于跨应用解析，以及 app.create/app.delete 前后的读回。",
+            description: "列出应用（apppackage/list）及分组；回执含 applicationsCount/omitted。用于跨应用解析与 app.create/delete 前后读回。",
         }),
         "app.create": Object.freeze({
             scope: "app package create",
-            description: "创建一个设计时应用包（apppackage/create，不是应用内目录）。groupId 可选，缺省解析配置应用所在分组（操作者必然可见）；配置应用不存在时回退租户第一个具名非兜底分组（auto-first-group，warning:resolved-to-first-group）。落到兜底分组 code=all 时读回带 warning:resolved-to-fallback-group; portalHidden:true。创建后以 apppackage/list 读回存在性；平台会自动生成默认分组（readback.defaultFolder，isDefault:true）。应用发布属边界外：建成后需人工在设计器发布并核对该分组，否则门户不可见。",
+            description: "创建设计时应用包（apppackage/create，非目录）。groupId 可选：缺省用配置应用所在分组；否则首个具名非兜底分组（auto-first-group / resolved-to-first-group）。落到 code=all → resolved-to-fallback-group; portalHidden:true。读回 apppackage/list；平台自动建默认分组（defaultFolder.isDefault）。发布属边界外，需设计器人工发布。",
         }),
         "app.update": Object.freeze({
             scope: "app package update",
-            description: "更新一个应用（apppackage/update，管理员面；8.6.26 源码证据：AppPackageController.update → AppIntegrationFacadeImpl.updateAppPackage，按记录 id 整体提交，显式 groupId 生效，缺省 groupId 会被强制回默认分组，enabled 非 true 会清 workflow 收藏——故本工具读回记录后仅改 groupId 并原样保留 enabled）。当前仅支持改 `groupId`（应用迁移分组的补救路径），不隐式补写 i18nMessage，name 等其他字段以读回值原样回传。以 apppackage/list 读回分组变更。",
+            description: "更新应用（apppackage/update，管理员面；源码证据 AppPackageController.update → AppIntegrationFacadeImpl.updateAppPackage）：按记录 id 整体提交；显式 groupId 生效，缺省会强制回默认分组，enabled≠true 清 workflow 收藏——故只改 groupId 并原样保留 enabled。不补 i18nMessage；其它字段读回原样回传。读回 apppackage/list。",
         }),
         "app.delete": Object.freeze({
             scope: "app package delete absence",
@@ -76,7 +76,7 @@ export function assertAppContract() {
     assertLaneContract(APP_LANE_CONTRACT);
     if (!APP_WIRE.defaultGroupResolution.includes("resolved-to-first-group"))
         throw new Error("app contract pins the first-group fallback warning token");
-    assertDescriptionCarries(APP_LANE_CONTRACT, "app.list", ["apppackage/list", "跨应用"]);
+    assertDescriptionCarries(APP_LANE_CONTRACT, "app.list", ["apppackage/list", "跨应用", "applicationsCount"]);
     assertDescriptionCarries(APP_LANE_CONTRACT, "app.create", ["apppackage/create", "resolved-to-first-group", "边界外", "defaultFolder"]);
     if (!APP_WIRE.createReadiness.includes("zero"))
         throw new Error("app contract must pin the zero-wire prerequisite refusal");

package/dist/lanes/app.js

@@ -53,7 +53,25 @@ export function registerAppLane(tools) {
                 name: row.appName ?? row.name,
                 groupId: row.groupId,
             }));
-            return { applications };
+            // r29f F2：与 discover_environment 同构——一眼判断「内联是否全集」。
+            // 应用通常个位数，默认内联 + omitted:false；大租户由 governedRead 外置时
+            // 仍保留 applicationsCount，并由 diet 路径标 omitted。
+            return {
+                applications,
+                applicationsCount: applications.length,
+                omitted: false,
+            };
+        }, {
+            target: "app.list",
+            compact: (result) => {
+                const apps = Array.isArray(result.applications) ? result.applications : [];
+                return {
+                    applicationsCount: apps.length,
+                    omitted: true,
+                    applications: apps.slice(0, 20),
+                    tablesHint: "applications 已截断内联前 20 条（omitted:true）；全集在 detailArtifactId，用 --jq applications[].code 或 artifact get 取回。",
+                };
+            },
         }),
     }));
     writeTool({
@@ -62,7 +80,7 @@ export function registerAppLane(tools) {
         lane: APP_LANE,
         scope: APP_TOOLS["app.create"].scope,
         description: APP_TOOLS["app.create"].description,
-        inputSchema: { code: z.string().min(1), name: z.string().min(1), groupId: z.string().optional() },
+        inputSchema: { code: z.string().min(1), name: z.string().min(1), groupId: z.string().describe("省略时使用环境配置的默认应用分组（回执 resolvedFrom=auto-configured-app-group），不需要先查 groupId").optional() },
         execute: async (session, args) => {
             const existing = wireRows((await wireCall(session, { path: ENDPOINTS.applicationList, query: {} })).data).find((row) => (row.appCode ?? row.code) === args.code);
             if (existing)

package/dist/lanes/dictionary-contract.js

@@ -50,12 +50,22 @@ export const DICTIONARY_LANE_CONTRACT = Object.freeze({
     ]),
     tools: Object.freeze({
         "dictionary.list": Object.freeze({ scope: "dictionary list", description: "分页读取数据字典（data_dictionary/searchDictionary），返回字典元数据。" }),
-        "dictionary.get": Object.freeze({ scope: "dictionary read", description: "按 id 或 code 读取数据字典及其元数据。" }),
-        "dictionary.records": Object.freeze({ scope: "dictionary records read", description: "读取字典记录；支持按 id/code、启用状态和 parentId 读取，保留树形 children。" }),
+        "dictionary.get": Object.freeze({ scope: "dictionary read", description: "按 id 或 code 读取数据字典头；附 recordsCount（明细仍走 dictionary.records）。" }),
+        "dictionary.records": Object.freeze({
+            scope: "dictionary records read",
+            description: "读取字典记录（id/code/enabledOnly/parentId，保留 children）。回执恒 {records:{totalElements,content[]}, total}。",
+        }),
         "dictionary.save": Object.freeze({ scope: "dictionary save", description: "创建或更新数据字典及记录（data_dictionary/saveDictionary）；KEY_VALUE=0，TREE=1，写入前需审批。records 是增量 upsert：传 [] 不会清空已有记录，平台也没有字典/记录删除端点——停用请用 dictionary.status，清理需维护者数据库操作。" }),
         "dictionary.status": Object.freeze({ scope: "dictionary status", description: "启用或停用字典或字典记录；停用字典时运行时不会返回选项。" }),
         "dictionary.class": Object.freeze({ scope: "dictionary classification", description: "读取、新建、删除字典分类并维护分类关联字典。" }),
-        "dictionary.usage": Object.freeze({ scope: "dictionary record usage", description: "批量设置字典记录 initialUsed 使用状态；记录新增/更新仍随 dictionary.save.records。" }),
+        "dictionary.usage": Object.freeze({
+            scope: "dictionary record usage",
+            description: "写：批量设置字典记录 initialUsed 使用标记（不是引用查询）。查谁引用了字典请用 dictionary.references。",
+        }),
+        "dictionary.references": Object.freeze({
+            scope: "dictionary refs",
+            description: "只读：谁引用了该字典（上限50+truncated）。",
+        }),
         "dictionary.type": Object.freeze({ scope: "dictionary type read", description: "按 dictionaryType 读取字典。" }),
         "dictionary.names": Object.freeze({ scope: "dictionary names read", description: "读取字典 id/name 摘要。" }),
         "dictionary.parent": Object.freeze({ scope: "dictionary parent records read", description: "读取树型字典指定父节点的直接子记录。" }),
@@ -67,9 +77,10 @@ export const DICTIONARY_LANE_CONTRACT = Object.freeze({
 export function assertDictionaryContract() {
     assertLaneContract(DICTIONARY_LANE_CONTRACT);
     assertDescriptionCarries(DICTIONARY_LANE_CONTRACT, "dictionary.save", ["saveDictionary", "KEY_VALUE=0", "TREE=1"]);
-    assertDescriptionCarries(DICTIONARY_LANE_CONTRACT, "dictionary.records", ["children"]);
+    assertDescriptionCarries(DICTIONARY_LANE_CONTRACT, "dictionary.records", ["children", "totalElements"]);
     assertDescriptionCarries(DICTIONARY_LANE_CONTRACT, "dictionary.class", ["分类"]);
-    assertDescriptionCarries(DICTIONARY_LANE_CONTRACT, "dictionary.usage", ["initialUsed"]);
+    assertDescriptionCarries(DICTIONARY_LANE_CONTRACT, "dictionary.usage", ["initialUsed", "不是引用查询"]);
+    assertDescriptionCarries(DICTIONARY_LANE_CONTRACT, "dictionary.references", ["truncated"]);
     if (!String(DICTIONARY_LANE_CONTRACT.wire.selectionDictionary).includes("checkedDictionary"))
         throw new Error("dictionary contract must pin dictionary option keys");
     if (!String(DICTIONARY_LANE_CONTRACT.wire.selectionBusinessModel).includes("sheetDataItem"))

package/dist/lanes/dictionary-coverage.js

@@ -15,6 +15,7 @@ export const DICTIONARY_COVERAGE = declareLaneCoverage(DICTIONARY_LANE_CONTRACT.
             claim("dictionary.save", T["dictionary.save"].scope),
             claim("dictionary.status", T["dictionary.status"].scope),
             claim("dictionary.usage", T["dictionary.usage"].scope),
+            claim("dictionary.references", T["dictionary.references"].scope),
             claim("dictionary.classes", T["dictionary.classes"].scope),
             claim("dictionary.class.save", T["dictionary.class.save"].scope),
             claim("dictionary.class.delete", T["dictionary.class.delete"].scope),