@stalfh233/omc-cli 0.6.12 → 0.6.13

package/dist/lanes/dictionary.js

@@ -4,7 +4,8 @@ import { capabilityArg, environmentArg } from "../args.js";
 import { governedRead } from "../read.js";
 import { writeTool } from "../write.js";
 import { defineTool, ToolRefusalError } from "../tool-types.js";
-import { wireCall, WireError } from "../wire.js";
+import { wireCall, wireRows, WireError } from "../wire.js";
+import { mapBounded } from "../support.js";
 import { DICTIONARY_LANE_CONTRACT } from "./dictionary-contract.js";
 const LANE = DICTIONARY_LANE_CONTRACT.lane;
 const TOOLS = DICTIONARY_LANE_CONTRACT.tools;
@@ -244,7 +245,20 @@ export function registerDictionaryLane(tools) {
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
             requireExactlyOne(args.id, args.code);
             const data = await wireCall(session, { path: args.id ? ENDPOINTS.dictionaryGet : ENDPOINTS.dictionaryGetByCode, query: args.id ? { id: args.id } : { code: args.code } });
-            return { dictionary: dictionaryView(data.data, { full: args.full }) };
+            const dictionary = dictionaryView(data.data, { full: args.full });
+            // r29e F5/F7：头读面以前不含 records；给一个低字节 recordsCount，明细仍走 dictionary.records。
+            let recordsCount;
+            try {
+                const code = String(data.data?.code ?? args.code ?? "");
+                if (code) {
+                    const all = (await wireCall(session, { path: ENDPOINTS.dictionaryRecordsByCode, query: { code, searchWord: "", page: "1", size: "1" } })).data;
+                    recordsCount = Number(all?.totalElements ?? 0);
+                }
+            }
+            catch {
+                recordsCount = undefined;
+            }
+            return { dictionary, ...(recordsCount !== undefined ? { recordsCount } : {}) };
         }, { full: args.full }),
     }));
     tools.push(defineTool({
@@ -257,11 +271,17 @@ export function registerDictionaryLane(tools) {
         inputSchema: { environment: environmentArg, capability: capabilityArg, id: z.string().optional(), code: z.string().optional(), parentId: z.string().optional(), searchWord: z.string().optional(), enabledOnly: z.boolean().default(false), page: z.number().int().min(1).default(1), size: z.number().int().min(1).max(200).default(200), full: z.boolean().default(false) },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
             requireExactlyOne(args.id, args.code);
-            const projectRows = (rows) => sortRecordsBySortKey(rows).map((row) => recordView(row, { full: args.full }));
+            // r29e F9：enabledOnly / parentId 以前回裸数组，默认面回分页壳——同一键
+            // 形状翻转让 `--jq records[].code` 在非 enabledOnly 时直接炸。统一恒为
+            // `{records:{totalElements,content[]}, total}`；enabledOnly 只过滤 content。
+            const asPage = (rows) => {
+                const content = sortRecordsBySortKey(rows).map((row) => recordView(row, { full: args.full }));
+                return { totalElements: content.length, totalPages: 1, content };
+            };
             if (args.parentId) {
                 const data = await wireCall(session, { path: ENDPOINTS.dictionaryParentRecords, query: { parentId: args.parentId } });
-                const records = Array.isArray(data.data) ? projectRows(data.data) : [];
-                return { parentId: args.parentId, records, total: records.length, orderNote: RECORDS_ORDER_NOTE };
+                const page = asPage(Array.isArray(data.data) ? data.data : []);
+                return { parentId: args.parentId, records: page, total: Number(page.totalElements ?? 0), orderNote: RECORDS_ORDER_NOTE };
             }
             if (args.enabledOnly) {
                 const dictionary = args.id ? { id: args.id } : (await wireCall(session, { path: ENDPOINTS.dictionaryGetByCode, query: { code: args.code } })).data;
@@ -269,8 +289,8 @@ export function registerDictionaryLane(tools) {
                 if (!id)
                     throw new WireError("business", "dictionary code not found", 301001);
                 const data = await wireCall(session, { path: ENDPOINTS.dictionaryEnabledRecords, query: { dicId: id } });
-                const records = Array.isArray(data.data) ? projectRows(data.data) : [];
-                return { dictionaryId: id, enabledOnly: true, records, total: records.length, orderNote: RECORDS_ORDER_NOTE };
+                const page = asPage(Array.isArray(data.data) ? data.data : []);
+                return { dictionaryId: id, enabledOnly: true, records: page, total: Number(page.totalElements ?? 0), orderNote: RECORDS_ORDER_NOTE };
             }
             const path = args.code ? ENDPOINTS.dictionaryRecordsByCode : ENDPOINTS.dictionaryRecords;
             const query = args.code
@@ -330,7 +350,14 @@ export function registerDictionaryLane(tools) {
                 readback.intentUnmet = true;
                 readback.intentUnmetReason = "records:[] 不会删除既有记录（平台无字典/记录删除端点，save 是增量 upsert）；请用 dictionary.status 逐条停用。";
             }
-            return { performed: { errcode: performed.errcode }, readback };
+            return {
+                performed: { errcode: performed.errcode },
+                readback,
+                // r30a F23: say it on the success receipt (budget-tight; not in describe prose).
+                irreversible: args.id
+                    ? "平台无字典删除端点；更新可再 dictionary.save，删除只能 dictionary.status 停用"
+                    : "平台无字典删除端点，只能停用（dictionary.status target=dictionary status=false）",
+            };
         },
         rollback: dictionaryRollbackSpec("dictionary.save"),
     });
@@ -363,6 +390,171 @@ export function registerDictionaryLane(tools) {
             return { performed: { errcode: performed.errcode, ids: args.ids }, readback: { ids: args.ids, initialUsed: true } };
         },
     });
+    // r29e F5：12 个 dictionary 工具以前没有「谁引用了这个字典」读面。
+    // 扫描默认应用模型的草稿字段；上限 50 + truncated，避免 O(租户) 不可裁剪。
+    const REFERENCES_LIMIT = 50;
+    const REFERENCES_MODEL_CAP = 40;
+    tools.push(defineTool({
+        name: "dictionary.references",
+        layer: "low",
+        kind: "read",
+        lane: LANE,
+        scope: TOOLS["dictionary.references"].scope,
+        description: TOOLS["dictionary.references"].description,
+        inputSchema: {
+            environment: environmentArg,
+            capability: capabilityArg,
+            id: z.string().optional().describe("字典 id（与 code 二选一）"),
+            code: z.string().optional().describe("字典 code（与 id 二选一）"),
+            schemaCode: z.string().min(1).optional().describe("只扫这一个模型的字段（大租户下比全扫快得多，也避免「没扫到」的歧义）"),
+            limit: z.number().int().min(1).max(REFERENCES_LIMIT).default(REFERENCES_LIMIT).describe(`最多返回多少引用（默认 ${REFERENCES_LIMIT}；超出 truncated:true）`),
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            requireExactlyOne(args.id, args.code);
+            let dictionaryId = args.id ?? "";
+            let dictionaryCode = args.code ?? "";
+            if (args.code) {
+                const header = (await wireCall(session, { path: ENDPOINTS.dictionaryGetByCode, query: { code: args.code } })).data;
+                // 「字典不存在」与「没人引用它」必须分得开：前者是调用错误（拼错 code），
+                // 后者才是答案。旧实现直接拿 args.code 兜底，拼错会回 count:0。
+                if (header === null || String(header.id ?? "") === "")
+                    throw new ToolRefusalError({
+                        status: "refused",
+                        blocker: "dictionary-not-found",
+                        code: args.code,
+                        message: `字典 ${args.code} 不存在（dictionary/get_by_code 回空）——拼写错误会与「没有引用」混为一谈；先用 omc call dictionary.list 核对 code`,
+                        nextCommand: `omc call dictionary.list --args '${JSON.stringify({})}'`,
+                    });
+                dictionaryId = String(header.id ?? "");
+                dictionaryCode = String(header.code ?? args.code);
+            }
+            else if (args.id) {
+                const header = (await wireCall(session, { path: ENDPOINTS.dictionaryGet, query: { id: args.id } })).data;
+                dictionaryId = String(header?.id ?? args.id);
+                dictionaryCode = String(header?.code ?? "");
+            }
+            if (!dictionaryId && !dictionaryCode) {
+                throw new ToolRefusalError({ status: "refused", blocker: "dictionary-target-required", message: "dictionary.references：字典不存在或 id/code 无效" });
+            }
+            const models = (args.schemaCode !== undefined
+                ? [{ code: args.schemaCode }]
+                : wireRows((await wireCall(session, { path: ENDPOINTS.modelList, query: {} })).data)
+                    .filter((row) => row.type === "BizModel" && typeof row.code === "string" && String(row.code).length > 0)
+                    .slice(0, REFERENCES_MODEL_CAP));
+            const limit = args.limit ?? REFERENCES_LIMIT;
+            const refs = [];
+            let truncated = false;
+            // 4 路并发读字段面：40 个模型串行要 40 次往返，大租户下会直接超时。
+            const perModel = await mapBounded(models, 4, async (model) => {
+                const schemaCode = String(model.code);
+                let fields = [];
+                try {
+                    fields = wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode, isPublish: "false" } })).data);
+                }
+                catch {
+                    return { schemaCode, hits: [] };
+                }
+                const hits = [];
+                for (const field of fields) {
+                    if (refs.length >= limit) {
+                        truncated = true;
+                        break;
+                    }
+                    const optionsRaw = field.options;
+                    let options;
+                    if (typeof optionsRaw === "string" && optionsRaw.trim()) {
+                        try {
+                            options = JSON.parse(optionsRaw);
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                    else if (optionsRaw && typeof optionsRaw === "object" && !Array.isArray(optionsRaw)) {
+                        options = optionsRaw;
+                    }
+                    else
+                        continue;
+                    // 字典引用在平台上**有两种存储形状**，少认一种就会把「有引用」报成 0：
+                    //   ① 设计器形状：options.optionsSet = {optionsType:"dictionary", dictionary:{checkedDictionary,checkedDictionaryCode}}
+                    //   ② OMC 形状（field.create 传 options.checkedDictionary，也是既有环境里最常见的）：
+                    //      options.checkedDictionary = {code}
+                    // 2026-11-05 真机：只认 ① 时，刚用 OMC 建好的 v24.lv 引用 v_lvl 查不到 → count:0。
+                    const optionsSet = options.optionsSet;
+                    let checkedId = "";
+                    let checkedCode = "";
+                    if (optionsSet && optionsSet.optionsType === "dictionary") {
+                        const dictionary = (optionsSet.dictionary ?? {});
+                        checkedId = String(dictionary.checkedDictionary ?? "");
+                        checkedCode = String(dictionary.checkedDictionaryCode ?? dictionary.dictionaryCode ?? "");
+                    }
+                    const flat = options.checkedDictionary;
+                    if (!checkedId && !checkedCode && flat !== undefined && flat !== null) {
+                        const record = typeof flat === "string" ? { code: flat } : flat;
+                        checkedCode = String(record.code ?? record.checkedDictionaryCode ?? "");
+                        checkedId = String(record.id ?? record.checkedDictionary ?? "");
+                        // 设计器存 code，OMC 存 {code}: 两种都要能命中
+                        if (!checkedId && dictionaryCode !== "" && checkedCode === "")
+                            checkedId = dictionaryCode;
+                    }
+                    if (!checkedId && !checkedCode)
+                        continue;
+                    const hit = (dictionaryId !== "" && checkedId === dictionaryId) ||
+                        (dictionaryCode !== "" && (checkedCode === dictionaryCode || checkedId === dictionaryCode));
+                    if (!hit)
+                        continue;
+                    hits.push({
+                        schemaCode,
+                        fieldCode: String(field.code ?? field.propertyCode ?? ""),
+                        fieldName: String(field.name ?? ""),
+                        propertyType: field.typeName ?? field.type ?? field.propertyType ?? "",
+                    });
+                }
+                return { schemaCode, hits };
+            });
+            let modelsScanned = 0;
+            for (const entry of perModel) {
+                modelsScanned += 1;
+                for (const hit of entry.hits) {
+                    if (refs.length >= limit) {
+                        truncated = true;
+                        break;
+                    }
+                    refs.push(hit);
+                }
+                if (truncated)
+                    break;
+            }
+            if (models.length >= REFERENCES_MODEL_CAP && !truncated)
+                truncated = true;
+            // count:0 + truncated:true 是**最危险的组合**：读起来像「没有引用」，实际是
+            // 「还没扫到」。2026-11-05 真机（本租户 31 个模型、v24 排在 23 位）就撞上：
+            // 明明刚建了引用，却回 count:0。没有结论时必须明说「不知道」，不能给 0。
+            const answer = truncated
+                ? refs.length > 0
+                    ? "partial"
+                    : "undetermined"
+                : "complete";
+            return {
+                dictionary: { id: dictionaryId || null, code: dictionaryCode || null },
+                references: refs,
+                count: refs.length,
+                answer,
+                truncated,
+                modelsScanned,
+                modelCap: REFERENCES_MODEL_CAP,
+                ...(answer === "undetermined"
+                    ? {
+                        warning: `未扫完就到达上限（模型≤${REFERENCES_MODEL_CAP}），count:0 **不代表没有引用**。用 schemaCode 直接反查更快：`
+                            + `omc call field.list --args '{"schemaCode":"<模型>","full":true}' 看 options.checkedDictionary / options.optionsSet.dictionary`,
+                    }
+                    : {}),
+                note: answer === "complete"
+                    ? "引用扫描完成（草稿字段；匹配 options.checkedDictionary 与 options.optionsSet.dictionary 两种形状）"
+                    : `扫描有上限（模型≤${REFERENCES_MODEL_CAP}、引用≤${limit}）；结果可能不完整。`,
+            };
+        }),
+    }));
     tools.push(defineTool({
         name: "dictionary.parent",
         layer: "low",

package/dist/lanes/environment-contract.js

@@ -8,9 +8,10 @@ import { LANES } from "./lane-ids.js";
 export const ENVIRONMENT_WIRE = Object.freeze({
     discoveryReads: "applicationList + applicationGroupList + applicationTree(appCode) + modelList(parentId='')",
     readiness: "readiness {ready, blockers, preconditions, warnings, recovery, facts} derives from the same application/group/profile/version reads; no capability fan-out",
-    applicationScope: "lists every application the tenant exposes; applicationCode selects one and returns its folders/models",
+    applicationScope: "lists every application the tenant exposes; applicationCode selects one and returns its folders/models; modelsCount is selected-application scope (not tenant-wide) — tenantModelsCount sums per-app trees",
     portalVisibility: "group membership decides portal visibility: the portal renders NAMED groups; an app in the fallback group (code === 'all', case-insensitive) or with an unresolvable groupId is flagged portalHidden:true; move it with app.update {code, groupId}",
-    fingerprint: "canonical environment fingerprint (environment, origin, application, enterprise) from the authenticated session",
+    fingerprint: "canonical environment fingerprint (environment, origin, application, enterprise) from the authenticated session; also returns version evidence (detectedVersion/inAnchorFamily/versionSource) shared with discover_environment and doctor",
+    versionEvidence: "detectedVersion + inAnchorFamily + versionSource(=system-config) + versionFamily/anchorVersion [+ versionNotice outside the anchor family]; same face on discover_environment, environment.fingerprint, and doctor",
 });
 export const ENVIRONMENT_LANE_CONTRACT = Object.freeze({
     lane: LANES.environment,
@@ -28,6 +29,7 @@ export const ENVIRONMENT_LANE_CONTRACT = Object.freeze({
         applicationScope: ENVIRONMENT_WIRE.applicationScope,
         portalVisibility: ENVIRONMENT_WIRE.portalVisibility,
         fingerprint: ENVIRONMENT_WIRE.fingerprint,
+        versionEvidence: ENVIRONMENT_WIRE.versionEvidence,
     }),
     wireBindings: Object.freeze({
         discoveryReads: Object.freeze([behaviorBinding("test/discovery-group-visibility.test.ts#discover_environment exposes group membership and flags fallback-group apps", assertEnvironmentContract)]),
@@ -35,6 +37,7 @@ export const ENVIRONMENT_LANE_CONTRACT = Object.freeze({
         applicationScope: Object.freeze([behaviorBinding("test/discovery-group-visibility.test.ts#discover_environment with applicationCode returns that app's models", assertEnvironmentContract)]),
         portalVisibility: Object.freeze([behaviorBinding("test/discovery-group-visibility.test.ts#discover_environment fails closed: an unresolvable groupId is portalHidden", assertEnvironmentContract)]),
         fingerprint: Object.freeze([behaviorBinding("test/lane-contracts.test.ts#environment lane contract pins the discovery/fingerprint wire", assertEnvironmentContract)]),
+        versionEvidence: Object.freeze([behaviorBinding("test/friction-r30f-version-evidence.test.ts#discover_environment and environment.fingerprint return shared version evidence", assertEnvironmentContract)]),
     }),
     evidence: Object.freeze([
         "src/dbsweep.ts",
@@ -44,20 +47,25 @@ export const ENVIRONMENT_LANE_CONTRACT = Object.freeze({
     tools: Object.freeze({
         discover_environment: Object.freeze({
             scope: "discovery fingerprint",
-            description: "发现应用、模型、字段与默认表单（只读）。默认列出全部应用及其门户分组归属；传入 applicationCode 时进入该应用并返回其下的模型。每个应用带 groupId/groupCode/groupName 与 portalHidden：落在兜底分组「全部」(code=all) 或分组解析不到的应用标 portalHidden:true——门户按具名分组渲染，这些应用在门户不可见，须用 app.update {code,groupId} 迁入具名分组。",
+            description: "发现应用/模型（只读）。默列全部应用及门户分组；给 applicationCode 则进该应用。" +
+                "每应用带 groupId/groupCode/groupName/portalHidden（code=all 或分组未解析 → portalHidden:true，需 app.update 迁入具名分组）。" +
+                "`modelsCount`=选中应用内（同 model.list）；租户求和见 tenantModelsCount/modelsPerApplication。" +
+                "回 detectedVersion/inAnchorFamily/versionSource（同源 doctor）。",
         }),
         "environment.fingerprint": Object.freeze({
             scope: "fingerprint",
-            description: "Canonical environment fingerprint (environment, origin, application, enterprise).",
+            description: "environment fingerprint（env/origin/application/enterprise）+ detectedVersion/inAnchorFamily/versionSource。fingerprint 标识「哪套部署」，不是资源清单：模型增删后它不变，基线核对请比 resourceFingerprint。",
         }),
     }),
 });
 export function assertEnvironmentContract() {
     assertLaneContract(ENVIRONMENT_LANE_CONTRACT);
-    assertDescriptionCarries(ENVIRONMENT_LANE_CONTRACT, "discover_environment", ["只读", "applicationCode", "模型", "分组", "portalHidden"]);
+    assertDescriptionCarries(ENVIRONMENT_LANE_CONTRACT, "discover_environment", ["只读", "applicationCode", "模型", "分组", "portalHidden", "modelsCount", "tenantModelsCount", "detectedVersion"]);
+    if (!ENVIRONMENT_WIRE.applicationScope.includes("tenantModelsCount"))
+        throw new Error("environment contract must pin modelsCount selected-app scope vs tenantModelsCount");
     if (!ENVIRONMENT_WIRE.readiness.includes("no capability fan-out"))
         throw new Error("environment contract must pin readiness as a bounded projection");
-    assertDescriptionCarries(ENVIRONMENT_LANE_CONTRACT, "environment.fingerprint", ["fingerprint", "environment"]);
+    assertDescriptionCarries(ENVIRONMENT_LANE_CONTRACT, "environment.fingerprint", ["fingerprint", "environment", "detectedVersion"]);
     if (!ENVIRONMENT_WIRE.discoveryReads.includes("applicationList"))
         throw new Error("environment contract must pin the discovery reads");
     if (!ENVIRONMENT_WIRE.applicationScope.includes("applicationCode"))
@@ -66,5 +74,9 @@ export function assertEnvironmentContract() {
         throw new Error("environment contract must pin the portal-visibility flag");
     if (!ENVIRONMENT_WIRE.fingerprint.includes("environment"))
         throw new Error("environment contract must pin the fingerprint fields");
+    if (!ENVIRONMENT_WIRE.versionEvidence.includes("detectedVersion"))
+        throw new Error("environment contract must pin shared version evidence");
+    if (!ENVIRONMENT_WIRE.fingerprint.includes("detectedVersion"))
+        throw new Error("environment fingerprint contract must mention version evidence");
 }
 //# sourceMappingURL=environment-contract.js.map

package/dist/lanes/environment.js

@@ -2,7 +2,8 @@ import { z } from "zod";
 import { ENDPOINTS } from "../endpoints.js";
 import { capabilityArg, environmentArg } from "../args.js";
 import { governedRead } from "../read.js";
-import { environmentWritable, requiresProductionConfirmation } from "../environment-policy.js";
+import { environmentWritable, requiresProductionConfirmation, versionEvidenceOf } from "../environment-policy.js";
+import { versionFamilyNotice } from "../coverage.js";
 import { flattenTreeRows } from "../support.js";
 import { defineTool } from "../tool-types.js";
 import { wireCall, wireRows } from "../wire.js";
@@ -10,6 +11,17 @@ import { ENVIRONMENT_LANE_CONTRACT } from "./environment-contract.js";
 import { readProjectCard, writeProjectCard } from "../project-card.js";
 const ENVIRONMENT_LANE = ENVIRONMENT_LANE_CONTRACT.lane;
 const ENVIRONMENT_TOOLS = ENVIRONMENT_LANE_CONTRACT.tools;
+/** r30f F2 — doctor / discover / fingerprint share one version-evidence face. */
+function versionEvidenceFor(ctx, session) {
+    const detected = session.detectedVersion();
+    const notice = detected ? versionFamilyNotice(ctx.manifest, detected) : undefined;
+    return versionEvidenceOf({
+        detectedVersion: detected,
+        versionFamily: ctx.manifest.version_family,
+        anchorVersion: ctx.manifest.anchor_version,
+        ...(notice ? { versionNotice: notice } : {}),
+    });
+}
 export function registerEnvironmentLane(tools) {
     tools.push(defineTool({
         name: "discover_environment",
@@ -32,16 +44,63 @@ export function registerEnvironmentLane(tools) {
             if (args.refresh !== true && args.applicationCode === undefined && args.modelCode === undefined && args.full !== true) {
                 const cached = readProjectCard(ctx.artifactsDir, String(args.environment ?? session.environmentName ?? ""));
                 if (cached !== undefined) {
-                    // r28b F16（真机 2026-11-05，本轮复现）：实时读回给 `modelsCount`，
-                    // 缓存命中给 `modelCount`——同一个键换条路径就换名字，脚本 `r["modelsCount"]`
-                    // 直接 KeyError，基线对比也说不清是模型变了还是口径变了。
-                    // 缓存是加速，不是第二套契约：键名与实时读对齐，旧键保留不破既有调用方。
-                    const { modelCount, ...rest } = cached;
+                    // r28b F16 / r29f F10：缓存是加速，不是第二套契约。键集必须与冷路径
+                    // compact 同形；generatedAt / fromCacheHint 只做额外键。
+                    const cachedExtra = cached;
+                    const apps = Array.isArray(cached.applications) ? cached.applications : [];
+                    const groups = Array.isArray(cached.groups) ? cached.groups : [];
+                    const models = Array.isArray(cached.models)
+                        ? cached.models.map((row) => ({ schemaCode: row.code, name: row.name }))
+                        : [];
+                    const modelCount = typeof cached.modelCount === "number" ? cached.modelCount : models.length;
+                    const tenantCached = cachedExtra.tenantModelsCount;
+                    const perAppCached = cachedExtra.modelsPerApplication;
+                    const resolution = cached.applicationResolution;
+                    const versionEvidence = versionEvidenceFor(ctx, session);
                     return {
-                        ...rest,
-                        ...(typeof modelCount === "number" ? { modelsCount: modelCount, modelCount } : {}),
                         status: "ok",
+                        applications: apps,
+                        applicationsCount: apps.length,
+                        groups,
+                        groupsCount: groups.length,
+                        applicationCode: cached.applicationCode,
+                        applicationResolution: resolution
+                            ? { status: "resolved", code: resolution.code, source: resolution.source, requested: resolution.code }
+                            : { status: "resolved", source: "configured", requested: cached.applicationCode },
+                        applicationGroups: cached.applicationGroups ?? { status: "resolved" },
+                        readiness: {
+                            ready: true,
+                            blockers: [],
+                            preconditions: [],
+                            warnings: [],
+                            recovery: [],
+                            facts: { fromCache: true, versionEvidence: versionEvidence.detectedVersion !== null },
+                        },
+                        foldersAndModels: null,
+                        foldersAndModelsCount: 0,
+                        foldersAndModelsOmitted: true,
+                        models: null,
+                        modelsCount: modelCount,
+                        modelsOmitted: true,
+                        modelsCountScope: "selected-application",
+                        modelsCountNote: "modelsCount = 当前选中应用（applicationCode）内的模型数，不是租户全集；租户求和见 tenantModelsCount（各应用树相加，同 code 跨应用各计一次）。",
+                        ...(typeof tenantCached === "number" ? { tenantModelsCount: tenantCached } : {}),
+                        ...(perAppCached !== undefined ? { modelsPerApplication: perAppCached } : {}),
+                        tablesHint: "foldersAndModels/models 已外置（*Omitted:true，不是空表）；用 detailArtifactId 的 `omc artifact get <id> --jq <key>` 或同次 call 加 --jq/--extract 取回。" +
+                            "applications/groups 已内联。modelsCount=选中应用内；租户求和见 tenantModelsCount。",
+                        fingerprintHint: FINGERPRINT_HINT,
+                        ...(typeof cached.environmentFingerprint === "string" ? { environmentFingerprint: cached.environmentFingerprint } : {}),
+                        // r30f F2：缓存命中也回版本证据（与 doctor / fingerprint 同源）。
+                        detectedVersion: versionEvidence.detectedVersion,
+                        inAnchorFamily: versionEvidence.inAnchorFamily,
+                        versionSource: versionEvidence.versionSource,
+                        versionFamily: versionEvidence.versionFamily,
+                        anchorVersion: versionEvidence.anchorVersion,
+                        ...(versionEvidence.versionNotice ? { versionNotice: versionEvidence.versionNotice } : {}),
+                        // 额外键：不替代冷路径键，只标注缓存来源。
+                        generatedAt: cached.generatedAt,
                         fromCache: true,
+                        fromCacheHint: cached.fromCacheHint,
                     };
                 }
             }
@@ -124,6 +183,24 @@ export function registerEnvironmentLane(tools) {
             };
             let foldersAndModels = [];
             let models = [];
+            // r29a F13：modelsCount 只覆盖「当前选中应用」的树，不是租户求和。
+            // 额外扫一遍各应用树给 tenantModelsCount，并标注口径，避免 32 vs 71 误判。
+            let tenantModelsCount = 0;
+            const modelsPerApplication = [];
+            for (const app of apps) {
+                const appCode = String(app.code ?? "");
+                if (!appCode)
+                    continue;
+                try {
+                    const appTree = flattenTreeRows(wireRows((await wireCall(session, { path: ENDPOINTS.applicationTree, query: { appCode } })).data));
+                    const count = appTree.filter((row) => String(row.type ?? "").toLowerCase() === "bizmodel").length;
+                    modelsPerApplication.push({ applicationCode: appCode, count });
+                    tenantModelsCount += count;
+                }
+                catch {
+                    modelsPerApplication.push({ applicationCode: appCode, count: -1 });
+                }
+            }
             if (selectedApp) {
                 // Live (2026-09-17) the app tree is NESTED (Folder -> BizModel
                 // children); the previous top-level map dropped every model, so
@@ -149,6 +226,12 @@ export function registerEnvironmentLane(tools) {
                 readiness,
                 foldersAndModels,
                 models,
+                // r29a F13：口径标注。modelsCount = 选中应用内模型数（与 model.list 单应用一致）；
+                // tenantModelsCount = 各应用 model.list 求和（同 schemaCode 跨应用各计一次）。
+                modelsCountScope: "selected-application",
+                modelsCountNote: "modelsCount = 当前选中应用（applicationCode）内的模型数，不是租户全集；租户求和见 tenantModelsCount（各应用树相加，同 code 跨应用各计一次）。",
+                tenantModelsCount,
+                modelsPerApplication,
             };
             // 项目卡写入（软失败）：默认形态（无收窄参数）时缓存模型清单，下次会话一次本地读。
             if (args.applicationCode === undefined && args.modelCode === undefined && args.full !== true) {
@@ -166,15 +249,26 @@ export function registerEnvironmentLane(tools) {
                         models: discovered.models.slice(0, 300).map((row) => ({ code: String(row.schemaCode), name: String(row.name ?? "") })),
                         modelCount: discovered.models.length,
                         generatedAt: new Date().toISOString(),
+                        // ProjectCard 未声明扩展键；JSON 落盘后由上方 cache 归一读回。
+                        tenantModelsCount,
+                        modelsPerApplication,
                     });
                 }
             }
+            const versionEvidence = versionEvidenceFor(ctx, session);
             return {
                 ...discovered,
                 // r28k F3：裸 hex 不解自用。指纹是 (env, origin, application, enterprise)
                 // 的规范 sha256——绑定写计划 / intent plan 漂移门 / draft 写前复核 /
                 // 读回缓存键；它不是审批令牌。
                 fingerprintHint: FINGERPRINT_HINT,
+                // r30f F2：与 doctor / fingerprint 同源的版本证据（冷路径）。
+                detectedVersion: versionEvidence.detectedVersion,
+                inAnchorFamily: versionEvidence.inAnchorFamily,
+                versionSource: versionEvidence.versionSource,
+                versionFamily: versionEvidence.versionFamily,
+                anchorVersion: versionEvidence.anchorVersion,
+                ...(versionEvidence.versionNotice ? { versionNotice: versionEvidence.versionNotice } : {}),
             };
         }, {
             full: args.full === true,
@@ -199,13 +293,22 @@ export function registerEnvironmentLane(tools) {
                     if (!Array.isArray(value))
                         continue;
                     compact[`${key}Count`] = value.length;
-                    // 保留 key 但置 null + *Omitted，形状上区别于真实空数组 []；
-                    // key 仍在 payload 里，read.ts 不会再补空占位。
+                    // 2026-11-05（r31a F12 复核 / 全量门抓到）：**小结果必须内联**。
+                    // 旧实现只要走到 compact 就无条件置 null，于是 3 个模型也变成
+                    // `models:null` + `modelsOmitted:true`——调用方拿不到任何 schemaCode，
+                    // 而 read.ts 的数组键保形上限是 40 对（同口径）。
+                    // 规则：≤40 条内联；更多才置 null + *Omitted（形状上区别于真实空数组）。
+                    const INLINE_LIMIT = 40;
+                    if (value.length <= INLINE_LIMIT)
+                        continue;
                     compact[key] = null;
                     compact[`${key}Omitted`] = true;
                 }
+                // modelsPerApplication 个位数，内联；口径字段始终保留。
                 if (compact.foldersAndModelsOmitted === true || compact.modelsOmitted === true) {
-                    compact.tablesHint = "foldersAndModels/models 已外置（*Omitted:true，不是空表）；用 detailArtifactId 的 `omc artifact get <id> --jq <key>` 或同次 call 加 --jq/--extract 取回。applications/groups 已内联。";
+                    compact.tablesHint =
+                        "foldersAndModels/models 已外置（*Omitted:true，不是空表）；用 detailArtifactId 的 `omc artifact get <id> --jq <key>` 或同次 call 加 --jq/--extract 取回。" +
+                            "applications/groups 已内联。modelsCount=选中应用内；租户求和见 tenantModelsCount。";
                 }
                 if (typeof compact.environmentFingerprint === "string" && compact.fingerprintHint === undefined) {
                     compact.fingerprintHint = FINGERPRINT_HINT;
@@ -223,11 +326,21 @@ export function registerEnvironmentLane(tools) {
         // r28k F3：用途放首句，避免 summary 在第一个英文句号处截断。
         description: `${FINGERPRINT_HINT} ${ENVIRONMENT_TOOLS["environment.fingerprint"].description}`,
         inputSchema: { environment: environmentArg, capability: capabilityArg },
-        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => ({
-            environment: session.environmentName,
-            fingerprint: session.environmentFingerprint(),
-            fingerprintHint: FINGERPRINT_HINT,
-        })),
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            const versionEvidence = versionEvidenceFor(ctx, session);
+            return {
+                environment: session.environmentName,
+                fingerprint: session.environmentFingerprint(),
+                fingerprintHint: FINGERPRINT_HINT,
+                // r30f F2：指纹面也带回版本证据（与 discover / doctor 同源）。
+                detectedVersion: versionEvidence.detectedVersion,
+                inAnchorFamily: versionEvidence.inAnchorFamily,
+                versionSource: versionEvidence.versionSource,
+                versionFamily: versionEvidence.versionFamily,
+                anchorVersion: versionEvidence.anchorVersion,
+                ...(versionEvidence.versionNotice ? { versionNotice: versionEvidence.versionNotice } : {}),
+            };
+        }),
     }));
 }
 /** r28k F3 — 指纹用途一句话（回执 + describe 共用，避免两处漂移）。 */

package/dist/lanes/field-contract.js

@@ -180,6 +180,7 @@ export const FIELD_LANE_CONTRACT = Object.freeze({
             scope: "create publish readback",
             description: describeTool("Update an existing field (bizproperty/update) — merges `options` (and optional `choices`/`relativeCode`) onto the current draft/published record.", [
                 "**不切换 propertyType**：field.update 传 propertyType 会被静默忽略（errcode 0 但类型不变，r6 实证 2026-10-10）——已发布字段改类型只能 field.delete + field.create 重建（含关联 mappings 的同类型对齐场景：人员单选只能映射给人员单选）。choices 只对文本单选族（RADIO/DROPDOWN_BOX 等）合法，传给其它类型会被出门校验拒。",
+                "字典-backed 可用 `syncDictionary:true` 重填 useDictionariesData；readback 带 face:\"draft\"。",
                 "Use it to add relation `mappings` (source/target carry-through) or change field options. **关联填充映射的事实源是字段行 `options.mappings`**（真机 2026-10-14 中冶实证：改表单控件属性里的 mappings 会被平台按字段重算覆盖、回读不生效）。改映射的正确链：`field.update` 按完整 options 提交（只改 mappings，其余键 queryCode/displayField/schemaCode/conditions… 原值保留）→ `field.publish` → 已发布表单重派生一次：`form.draft`（**rebuild:false**，保留现有布局与已挂在线JS）重存 → `form.publish` → 回读核对。**不要用 field.update 的 cascadeRepublish 刷已带自定义布局/在线JS 的表单**——它会 rebuild 脚手架，可能动到现有自定义布局（rebuild:false 手动链才安全）。",
                 "A relation's display field is the field-row top-level `relativePropertyCode` (options.displayField is mirrored but not what the runtime reads); the tool rewrites it when you pass a new displayField.",
                 "表单条件（`options.requiredFormula`（必填）/`readonlyCondition`（只读）/`displayFormula`（显示））会**自动配对**一条 `bizdatarule` type3/4/5 行：门户**运行时**读字段 options，表单设计器**设计态** Set/Unset 读 `bizdatarule/list`——只写 options 会让设计器显示 Unset。readback.formConditionSync 报 created/updated/deleted/skipped；清空条件传空串（如 requiredFormula:\"\"）会同时删规则行；字段未发布时只写 options 并在 skipped 说明原因。",
@@ -189,7 +190,7 @@ export const FIELD_LANE_CONTRACT = Object.freeze({
         }),
         "field.publish": Object.freeze({
             scope: "create publish readback",
-            description: "Publish the model's draft fields (bizproperty/publish). **Model-scoped**: one call publishes every draft field of the schema — never call once per field. Optional `code`/`codes` verify which fields landed on the published face; the readback also lists all `publishedCodes`. 瞬态重试（ticket 79）：**异常小资源环境下**（实测该 test 环境 MySQL 限 1GB/缓冲池 128MB、I/O 被 Quartz 调度器占满，事故夜 30 个 publish 事务挂起 >30s 最长 193s）publish 走 DDL+序列化器定义同步，失败尝试 DDL 自动提交而标志回滚，留下「MySQL 有列 / 序列化器视图无列」中间态，后续 publish 报 `表单:<t>_<schema>不存在列:<col>` 并逐列自愈。常规资源环境预计不触发；工具仍对该特征自动重试至多 3 次（退避 2s/5s），预算耗尽原样浮出。若仍失败：等 ≥30s 再重发本次 publish，勿重复建字段。与字段 options 形状无关（yst/fwb 发布面 2656 行 org 族字段行无强制键）。",
+            description: "Publish the model's draft fields (bizproperty/publish). **Model-scoped**: one call publishes every draft field — never once per field. Optional `code`/`codes` verify published face; readback 回 `publishedCodes`。`codes` 短路须草稿/发布 options 一致，否则真发布。formBinding 可含 dictionaryStale / relation-mappings-empty。瞬态重试（ticket 79）：异常小资源下 DDL 中间态自动重试≤3（退避 2s/5s）；仍失败等≥30s 再发，勿重复建字段。",
         }),
         "field.delete": Object.freeze({
             scope: "create publish readback",