@stalfh233/omc-cli 0.6.17 → 0.6.18

package/dist/lanes/runtime-data.js

@@ -14,6 +14,7 @@ import { getReplayToken, listInstanceActivities, searchWorkItems, wireString } f
 import { PLATFORM_ADMIN_START_BYPASS, resolvePermissionActor } from "../identity.js";
 import { ENGINE_OWNED_KEYS, RUNTIME_DATA_LANE_CONTRACT, RUNTIME_DATA_WIRE, runtimeFormDataArg, } from "./runtime-data-contract.js";
 import { SYSTEM_FIELD_CODES } from "../field-families.js";
+import { applicationResolutionOf, resolveApplicationScope } from "../support.js";
 /** r29b F8: keep ids/itemsPreview through governedRead's compact diet. */
 const DATA_LIST_PREVIEW_LIMIT = 20;
 function dataListItemPreview(items) {
@@ -371,6 +372,106 @@ function readbackWarningFor(emptyFields, toolName) {
         return undefined;
     return `${toolName} 已 DELIVERED，但即时读回里这些本次提交的字段为空/缺省：${emptyFields.join("、")}。平台 form/load 在写事务后可能先回系统字段、业务字段滞后（真机 1.1.25，r14 见过只回 modifiedTime 的一笔）。**先 omc call data.load 核对，不要重写**；若 data.load 仍为空，才按投影/字段 code 排查。`;
 }
+function parseOptions(value) {
+    if (typeof value === "string") {
+        try {
+            const parsed = JSON.parse(value);
+            return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function choiceCodesFromFieldOptions(field, options) {
+    const asCodes = (value) => {
+        if (!Array.isArray(value))
+            return [];
+        return value
+            .map((entry) => {
+            if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+                const row = entry;
+                return String(row.code ?? row.value ?? row.key ?? "");
+            }
+            return String(entry ?? "");
+        })
+            .filter((code) => code.length > 0);
+    };
+    const direct = asCodes(field.choices);
+    if (direct.length > 0)
+        return direct;
+    for (const candidate of [options.choices, options.items]) {
+        const codes = asCodes(candidate);
+        if (codes.length > 0)
+            return codes;
+    }
+    const set = options.optionsSet;
+    if (!set || typeof set !== "object" || Array.isArray(set))
+        return [];
+    const optionSet = set;
+    for (const candidate of [optionSet.custom, optionSet.choices, optionSet.items, optionSet.useDictionariesData]) {
+        const codes = asCodes(candidate);
+        if (codes.length > 0)
+            return codes;
+    }
+    const dictionary = optionSet.dictionary;
+    if (dictionary && typeof dictionary === "object" && !Array.isArray(dictionary)) {
+        const codes = asCodes(dictionary.useDictionariesData);
+        if (codes.length > 0)
+            return codes;
+    }
+    return [];
+}
+/**
+ * Runtime/form/save deliberately remains permissive: the platform stores the
+ * row even when the portal would reject it.  These are advisory findings only.
+ * In particular, never manufacture a warning for a field which is absent from
+ * the published field face (the old `code/required` ghost warning did exactly
+ * that).
+ */
+async function runtimeDataWarnings(session, schemaCode, sheetCode, formData, row = 1) {
+    const warnings = [];
+    let fields = [];
+    try {
+        fields = wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode, isPublish: "true" } })).data);
+    }
+    catch {
+        return warnings;
+    }
+    const byCode = new Map(fields.map((field) => [String(field.code ?? field.propertyCode ?? ""), field]));
+    let required = new Set();
+    try {
+        const sheet = ((await wireCall(session, { path: ENDPOINTS.sheetGet, query: { schemaCode, sheetCode } })).data ?? {});
+        const face = typeof sheet.publishedAttributesJson === "string" ? sheet.publishedAttributesJson : typeof sheet.draftAttributesJson === "string" ? sheet.draftAttributesJson : undefined;
+        if (face) {
+            const controls = JSON.parse(face);
+            required = new Set(Object.entries(controls).filter(([, control]) => control?.options?.required === true || typeof control?.options?.requiredFormula === "string").map(([code]) => code));
+        }
+    }
+    catch {
+        // Advisory diagnostics must never affect the write.
+    }
+    for (const [field, value] of Object.entries(formData)) {
+        const meta = byCode.get(field);
+        if (!meta)
+            continue;
+        if ((required.has(field) || parseOptions(meta.options).required === true) && (value === null || value === undefined || (typeof value === "string" && value.trim() === ""))) {
+            warnings.push({ code: "required-empty", row, fieldCode: field, message: `字段 ${field} 声明必填但本行为空；平台照存，OMC 仅提示` });
+        }
+        const options = parseOptions(meta.options);
+        const optionSet = options.optionsSet && typeof options.optionsSet === "object" ? options.optionsSet : {};
+        const choiceCodes = choiceCodesFromFieldOptions(meta, options);
+        if (choiceCodes.length > 0 && value !== null && value !== undefined && value !== "") {
+            const allowed = new Set(choiceCodes);
+            const values = Array.isArray(value) ? value : [value];
+            const invalid = values.filter((entry) => !allowed.has(String(entry)));
+            if (invalid.length > 0)
+                warnings.push({ code: "choice-out-of-range", row, fieldCode: field, value: invalid.map(String), allowed: choiceCodes, message: `字段 ${field} 含未声明选项（实际值：${invalid.map(String).join("、")}；合法集：${choiceCodes.join("、")}）；平台照存，OMC 仅提示` });
+        }
+    }
+    return warnings;
+}
 function projectApprovalReadback(record, submittedKeys) {
     if (record === null || typeof record !== "object" || Array.isArray(record))
         return {};
@@ -979,6 +1080,8 @@ export function registerRuntimeDataLane(tools) {
                 throw error;
             }
             return governedRead(ctx, self, args, async (session) => {
+                const applicationScope = await resolveApplicationScope(session);
+                const application = { applicationCode: applicationScope.code, applicationResolution: applicationResolutionOf(applicationScope) };
                 // A2：DSL 过滤命中的单选/字典字段（total:0 时给值写法提示）
                 let choiceFilterFields = [];
                 // Published field metadata is the sole source for filter propertyType
@@ -1103,7 +1206,7 @@ export function registerRuntimeDataLane(tools) {
                     const firstPage = extractBizObjectPage(first.data);
                     const total = Number(firstPage.total ?? 0);
                     if (total === 0 || firstPage.content.length === 0)
-                        return { schemaCode: args.schemaCode, total: 0, page: "all", size: 0, pagesFetched: 0, items: [], itemsCount: 0, itemsReturned: 0, resultTruncated: false, itemsExternalized: false, ...(choiceFilterFields.length > 0 ? { filterValueHint: choiceFilterValueHint(choiceFilterFields) } : {}) };
+                        return { schemaCode: args.schemaCode, ...application, total: 0, page: "all", size: 0, pagesFetched: 0, items: [], itemsCount: 0, itemsReturned: 0, resultTruncated: false, itemsExternalized: false, ...(choiceFilterFields.length > 0 ? { filterValueHint: choiceFilterValueHint(choiceFilterFields) } : {}) };
                     const rows = [...firstPage.content];
                     const target = Math.min(total, CAP);
                     let pageIndex = 1;
@@ -1148,6 +1251,7 @@ export function registerRuntimeDataLane(tools) {
                     const preview = dataListItemPreview(items);
                     return {
                         schemaCode: args.schemaCode,
+                        ...application,
                         total,
                         page: "all",
                         size: collected.length,
@@ -1155,7 +1259,11 @@ export function registerRuntimeDataLane(tools) {
                         // 与普通读同一个口径（r28b 真机）：草稿策略必须**从结果集实际统计**，
                         // 不能按"有没有查询条件"静态声明——静态声明会与 items 自相矛盾。
                         filter: (() => {
-                            const draftRows = items.filter((item) => String(item.fields.sequenceStatus ?? "") === "DRAFT").length;
+                            const draftRows = collected.filter((row) => {
+                                const record = row;
+                                const data = record.data && typeof record.data === "object" ? record.data : record;
+                                return String(data.sequenceStatus ?? record.sequenceStatus ?? "") === "DRAFT";
+                            }).length;
                             return draftRows > 0
                                 ? { draftPolicy: "included", draftRows, hint: `本次结果含 ${draftRows} 条 DRAFT 行——total 含草稿，不要当"已提交数据量"；判定状态读 data.load 的 sequenceStatus` }
                                 : { draftPolicy: "unspecified", hint: "本次结果无 DRAFT 行；判定状态以 data.load 的 sequenceStatus 为准" };
@@ -1187,7 +1295,26 @@ export function registerRuntimeDataLane(tools) {
                 }
                 catch (error) {
                     if (error instanceof WireError && error.kind === "business" && error.errcode === RUNTIME_DATA_WIRE.emptyModelErrcode) {
-                        return { schemaCode: args.schemaCode, total: 0, totalPages: 0, page: args.page ?? 0, size: args.size ?? 10, items: [], ...(choiceFilterFields.length > 0 ? { filterValueHint: choiceFilterValueHint(choiceFilterFields) } : {}) };
+                        return { schemaCode: args.schemaCode, ...application, total: 0, totalPages: 0, page: args.page ?? 0, size: args.size ?? 10, items: [], ...(choiceFilterFields.length > 0 ? { filterValueHint: choiceFilterValueHint(choiceFilterFields) } : {}) };
+                    }
+                    if (error instanceof WireError && error.kind === "business" && error.errcode === 303001) {
+                        let available = [];
+                        try {
+                            const rows = wireRows((await wireCall(session, { path: ENDPOINTS.listQueryList, query: { schemaCode: args.schemaCode, clientType: "PC" } })).data);
+                            available = rows.map((row) => ({ code: row.code ?? null, name: row.name ?? null }));
+                        }
+                        catch {
+                            available = [];
+                        }
+                        return {
+                            status: "refused",
+                            blocker: "query-view-not-found",
+                            errcode: 303001,
+                            schemaCode: args.schemaCode,
+                            queryCode: args.queryCode ?? args.schemaCode,
+                            available,
+                            message: available.length > 0 ? `列表视图不存在：${String(args.queryCode ?? args.schemaCode)}；可用视图见 available` : `列表视图不存在：${String(args.queryCode ?? args.schemaCode)}；该模型无列表视图`,
+                        };
                     }
                     // r30: a MISSING model answers this face with a generic 50000
                     // 服务异常 — indistinguishable from a real outage. One field-face
@@ -1266,8 +1393,13 @@ export function registerRuntimeDataLane(tools) {
                 else if (totalPages > 0 && requestedPage >= totalPages) {
                     pageOutOfRange = true;
                 }
+                const draftRows = page.content.filter((row) => {
+                    const data = row.data && typeof row.data === "object" ? row.data : row;
+                    return String(data.sequenceStatus ?? row.sequenceStatus ?? "") === "DRAFT";
+                }).length;
                 const readback = {
                     schemaCode: args.schemaCode,
+                    ...application,
                     ...(projectionEmpty ? { projectionWarning: { reason: "business-columns-null", hint: "模型可能未配置列表视图：data.list 只投影列表列，业务列会全为 null；核对写入结果请用 data.load（或先建列表视图）" } } : {}),
                     ...(args.queryCode !== undefined ? { queryCode: args.queryCode } : {}),
                     total,
@@ -1282,7 +1414,6 @@ export function registerRuntimeDataLane(tools) {
                     // 统一一个枚举键 `draftPolicy`（included | excluded | unspecified），
                     // 不再用两个不同键名表达同一件事（那要调用方写两套分支）。
                     ...(() => {
-                        const draftRows = items.filter((item) => String(item.fields.sequenceStatus ?? "") === "DRAFT").length;
                         const policy = draftRows > 0
                             ? {
                                 draftPolicy: "included",
@@ -1456,6 +1587,8 @@ export function registerRuntimeDataLane(tools) {
             ...readbackProjectionArgs,
         },
         execute: async (session, args) => {
+            const applicationScope = await resolveApplicationScope(session);
+            const application = { applicationCode: applicationScope.code, applicationResolution: applicationResolutionOf(applicationScope) };
             // F-A (self-audit): the combo used to be silently ignored (the workflow
             // draft branch returns without honoring submit). Refuse before any wire.
             if (args.submit === true && typeof args.workflowCode === "string" && args.workflowCode.trim())
@@ -1570,8 +1703,8 @@ export function registerRuntimeDataLane(tools) {
                 readbackData = (await wireCall(session, { path: ENDPOINTS.runtimeFormLoad, query: { schemaCode: args.schemaCode, sheetCode, objectId: returnedId } })).data;
                 sequenceStatus = extractSequenceStatus((readbackData ?? {}));
                 return {
-                    performed: { errcode: performed.errcode, bizObjectId: returnedId, workflowInstanceId, workItemId, workItemSource, sheetCode, resolvedFrom, formType: "save-draft-workflow" },
-                    readback: { authoritative: projectReadbackRecord(normalizeLoadedRecord((readbackData ?? {})), args), sequenceStatus, expectedSequenceStatus: "DRAFT" },
+                    performed: { errcode: performed.errcode, ...application, bizObjectId: returnedId, workflowInstanceId, workItemId, workItemSource, sheetCode, resolvedFrom, formType: "save-draft-workflow" },
+                    readback: { ...application, authoritative: projectReadbackRecord(normalizeLoadedRecord((readbackData ?? {})), args), sequenceStatus, expectedSequenceStatus: "DRAFT" },
                 };
             }
             let performed;
@@ -1599,9 +1732,12 @@ export function registerRuntimeDataLane(tools) {
             // "rule didn't fire" misdiagnosis.
             const savedRecord = normalizeLoadedRecord((readbackData ?? {}));
             const savedEmptyFields = readbackEmptyFields(formData, savedRecord);
+            const dataWarnings = await runtimeDataWarnings(session, args.schemaCode, sheetCode, formData, 1);
             const plainReadback = {
+                ...application,
                 authoritative: projectReadbackRecord(savedRecord, args),
                 ...(savedEmptyFields.length > 0 ? { readbackWarning: readbackWarningFor(savedEmptyFields, "data.save") } : {}),
+                ...(dataWarnings.length > 0 ? { warnings: dataWarnings } : {}),
                 draftRuleHint: "草稿态（DRAFT）保存不触发业务规则——DRAFT 行跳过 Create/Update 分发（DomainServiceImpl.java:240-248）；要一调完成态本调用加 submit:true；已存草稿直提形状：data.submit {schemaCode, bizObjectId: 本读回的 bizObjectId, formData}（submit 自持久化）",
             };
             // r18 retro (G3): one-call COMPLETED creation — the agent goal is usually
@@ -1650,7 +1786,7 @@ export function registerRuntimeDataLane(tools) {
                 };
             }
             return {
-                performed: { errcode: performed.errcode, bizObjectId, sheetCode, resolvedFrom },
+                performed: { errcode: performed.errcode, ...application, bizObjectId, sheetCode, resolvedFrom },
                 readback: plainReadback,
             };
         },
@@ -1731,9 +1867,9 @@ export function registerRuntimeDataLane(tools) {
      * gone, not that the model is clean — a submit can leave a separate draft row
      * behind. After a delete, read the model's residue so "cleaned up" is a
      * model-level fact (`total:0`). Best-effort: a query failure never fails the
-     * delete, but it IS surfaced as `modelResidueError`.
+     * delete, but it IS surfaced under `preExistingRows.error`.
      */
-    async function modelResidue(session, schemaCode, sheetCode) {
+    async function preExistingRows(session, schemaCode, sheetCode) {
         try {
             const result = await wireCall(session, {
                 path: ENDPOINTS.runtimeQueryList,
@@ -1741,12 +1877,12 @@ export function registerRuntimeDataLane(tools) {
                 body: { schemaCode, queryCode: schemaCode, filters: [], mobile: false, page: 0, size: 1, queryVersion: 1, showTotal: true },
             });
             const page = extractBizObjectPage(result.data);
-            return { modelResidue: { total: page.total, clean: page.total === 0, sheetCode } };
+            return { preExistingRows: { total: page.total, clean: page.total === 0, sheetCode, note: "含历史既有数据，非本次创建" } };
         }
         catch (error) {
             if (error instanceof WireError && error.kind === "business" && error.errcode === RUNTIME_DATA_WIRE.emptyModelErrcode)
-                return { modelResidue: { total: 0, clean: true, sheetCode } };
-            return { modelResidue: { total: null, clean: null, sheetCode, modelResidueError: error instanceof Error ? error.message : String(error) } };
+                return { preExistingRows: { total: 0, clean: true, sheetCode, note: "含历史既有数据，非本次创建" } };
+            return { preExistingRows: { total: null, clean: null, sheetCode, note: "含历史既有数据，非本次创建", error: error instanceof Error ? error.message : String(error) } };
         }
     }
     writeTool({
@@ -1843,14 +1979,15 @@ export function registerRuntimeDataLane(tools) {
                             absent: true,
                             deleted: false,
                             noop: true,
-                            recoveryHint: "若另一进程刚刚删除，这是正常并发结果（already-absent），不是 id 拿错。否则：真实 id 必须取自 data.list 的 items[].id；工作流中心/门户页面回显的 id 会脱敏。若 modelResidue.total>0，用 items[].id 重删。",
-                            ...(await modelResidue(session, args.schemaCode, sheetCode)),
+                            recoveryHint: "若另一进程刚刚删除，这是正常并发结果（already-absent），不是 id 拿错。否则：真实 id 必须取自 data.list 的 items[].id；工作流中心/门户页面回显的 id 会脱敏。",
+                            thisRow: { absent: true, deleted: false },
+                            ...(await preExistingRows(session, args.schemaCode, sheetCode)),
                         },
                     };
                 }
                 return {
                     performed: { errcode: one.errcode, deleted: one.deleted === true, noop: false, sheetCode, resolvedFrom },
-                    readback: { absent: one.absent, deleted: one.deleted === true, ...(await modelResidue(session, args.schemaCode, sheetCode)) },
+                    readback: { absent: one.absent, deleted: one.deleted === true, thisRow: { absent: one.absent, deleted: one.deleted === true }, ...(await preExistingRows(session, args.schemaCode, sheetCode)) },
                 };
             }
             const deleted = [];
@@ -1858,7 +1995,7 @@ export function registerRuntimeDataLane(tools) {
                 deleted.push(await deleteOne(id));
             // `deleted`/`count` ride `readback` — the write envelope surfaces only
             // performed/readback inline (extra top-level keys are artifact-only).
-            return { performed: { sheetCode, resolvedFrom }, readback: { absent: true, count: deleted.length, deleted, ...(await modelResidue(session, args.schemaCode, sheetCode)) } };
+            return { performed: { sheetCode, resolvedFrom }, readback: { absent: true, count: deleted.length, deleted, ...(await preExistingRows(session, args.schemaCode, sheetCode)) } };
         },
     });
     writeTool({

package/dist/mcp-graph.js

@@ -58,24 +58,27 @@ const EXPLORE_TOOL = {
     name: "omc_graph_explore",
     description: [
         "一次查全一个目标的引用与影响面（本地索引，毫秒级）。",
-        "输入 query=字段/模型/服务的 code（或规则检索词）；kind 可选 field|model|service，不给则三种都查。",
+        "输入 query 可为业务名（实体 name+code 子串）或规则 code+name 词首；也可直接给字段/模型/服务 code。kind 可选 field|model|service，不给则三种都查。",
         "返回 {index(freshness), references:{kind:[{schemaCode,ruleCode,nodeCode,nodeType,via}]}, impact:{kind:totals}, search:{matches:{model,field,service},rules}}。",
+        "references/impact 支持 offset+limit 分页；truncated 时按返回的 nextOffset 继续调用。",
         "改/删/重命名任何字段、模型、服务之前必查；找\"关于 X 的规则\"拿 code 也走这里。",
         "索引不含规则条件叶子与流程绑定；freshness=partial 时命中可能不完整（答案里有 gapWarning）。",
     ].join(" "),
     inputSchema: {
         type: "object",
         properties: {
-            query: { type: "string", description: "字段/模型/服务的 code，或规则检索词（code+name 词首匹配）" },
+            query: { type: "string", description: "业务名（实体 name+code 子串）、字段/模型/服务 code，或规则检索词（规则 code+name 词首匹配）" },
             kind: { type: "string", enum: [...KINDS], description: "限定一种引用种类；省略则 field/model/service 全查" },
             env: { type: "string", description: "期望的环境名；与索引所属环境不一致时会拒绝（防跨环境误答）" },
+            offset: { type: "integer", minimum: 0, description: "引用/实体结果起始偏移；truncated 时使用 nextOffset" },
+            limit: { type: "integer", minimum: 1, maximum: MATCH_CAP, description: "每类结果最多返回多少条（默认 50）" },
         },
         required: ["query"],
     },
 };
 const STATUS_TOOL = {
     name: "omc_graph_status",
-    description: "索引完整性与新鲜度：environmentName、freshness(complete|partial)、模型/规则计数、pulledAtIso、gaps。回答前先看一眼，索引缺失会给出 pull 指引。",
+    description: "索引完整性与新鲜度：environmentName、freshness(complete|partial)、模型/规则计数、pulledAtIso、ageMinutes、staleAfterMinutes、dbPath、coverage.applicationCodes、gaps。超过阈值会给 warning；回答前先看一眼，索引缺失会给出 pull 指引。",
     inputSchema: { type: "object", properties: {} },
 };
 export function graphToolDefinitions() {
@@ -87,8 +90,9 @@ function toolResult(payload, isError = false) {
 function toolError(message) {
     return toolResult({ status: "error", message }, true);
 }
-function cap(rows) {
-    return { rows: rows.slice(0, MATCH_CAP), truncated: rows.length > MATCH_CAP };
+function cap(rows, offset = 0, limit = MATCH_CAP) {
+    const page = rows.slice(offset, offset + limit);
+    return { rows: page, truncated: offset + page.length < rows.length, offset, limit, ...(offset + page.length < rows.length ? { nextOffset: offset + page.length } : {}), total: rows.length };
 }
 /** Shared handler core — exported so tests drive it without a stdio pair. */
 export async function executeGraphTool(name, rawArgs) {
@@ -111,17 +115,22 @@ export async function executeGraphTool(name, rawArgs) {
                 return toolError(`索引属于环境「${index.environmentName}」；要查「${args.env.trim()}」请先 omc graph pull --env ${args.env.trim()} 重建索引`);
             }
             const kinds = kind === undefined ? [...KINDS] : [kind];
+            const offset = typeof args.offset === "number" && Number.isSafeInteger(args.offset) && args.offset >= 0 ? args.offset : 0;
+            const limit = typeof args.limit === "number" && Number.isSafeInteger(args.limit) && args.limit > 0 && args.limit <= MATCH_CAP ? args.limit : MATCH_CAP;
             const references = {};
             const impact = {};
             for (const one of kinds) {
                 const ref = queryGraphReferences(one, query);
-                const capped = cap(ref.matches);
+                const capped = cap(ref.matches, offset, limit);
                 // r35a-F4c（真机 2026-11-06）：**MCP 面是第三个消费者**——CLI 的 references
                 // 与 impact 都带 coverage 了，这里若不显式透传，MCP 用户看到的仍是
                 // 「matches:[] + 一句旧 note」，照样会把「表单没扫」误读成「没人引用」。
                 references[one] = {
                     count: ref.matches.length,
-                    ...capped,
+                    rows: capped.rows,
+                    offset: capped.offset,
+                    limit: capped.limit,
+                    ...(capped.truncated ? { truncated: true, nextOffset: capped.nextOffset, note: `共 ${capped.total} 条，已给 ${capped.rows.length} 条，offset=${capped.offset} 取下一段（调用时传 offset=${capped.nextOffset}、limit=${capped.limit}）` } : {}),
                     ...(ref.coverage ? { coverage: ref.coverage } : {}),
                     ...(ref.gapWarning ? { gapWarning: ref.gapWarning } : {}),
                 };
@@ -129,26 +138,36 @@ export async function executeGraphTool(name, rawArgs) {
                     const imp = impactGraph(one, query);
                     impact[one] = {
                         totals: imp.totals,
-                        rules: cap(imp.rules),
-                        datarules: cap(imp.datarules),
-                        listviews: cap(imp.listviews),
+                        rules: cap(imp.rules, offset, limit),
+                        datarules: cap(imp.datarules, offset, limit),
+                        listviews: cap(imp.listviews, offset, limit),
                         ...(imp.coverage ? { coverage: imp.coverage } : {}),
                     };
                 }
             }
-            const search = searchGraphRules(query);
+            const search = searchGraphRules(query, limit, offset);
+            const resolvedEntity = search.matches.model.items[0] ? { kind: "model", schemaCode: search.matches.model.items[0].schemaCode, code: search.matches.model.items[0].schemaCode } :
+                search.matches.field.items[0] ? { kind: "field", schemaCode: search.matches.field.items[0].schemaCode, code: search.matches.field.items[0].code } :
+                    search.matches.service.items[0] ? { kind: "service", schemaCode: "", code: search.matches.service.items[0].code } :
+                        search.rules[0] ? { kind: "rule", schemaCode: search.rules[0].schemaCode, code: search.rules[0].ruleCode } : undefined;
+            const searchNote = "实体检索：业务名/实体 name+code 使用子串匹配。\n规则检索：规则 code+name 使用词首匹配（中文子串不命中）。";
+            const entityTruncated = Object.values(search.matches).some((match) => match.truncated === true);
+            const paginationNote = entityTruncated ? `\n结果已截断：共 N 条时请使用对应 match 的 nextOffset，并在下一次调用传 offset=nextOffset、limit=${limit} 取下一段。` : "";
             return toolResult({
                 status: "ok",
                 query,
+                found: resolvedEntity !== undefined,
+                ...(resolvedEntity ? { resolved: resolvedEntity } : {}),
                 ...(kind !== undefined ? { kind } : {}),
                 index,
                 references,
                 impact,
                 search: { count: search.rules.length, rules: search.rules, matches: search.matches, coverage: search.coverage },
-                ...(search.note ? { searchNote: search.note } : {}),
+                searchNote: `${searchNote}${paginationNote}`,
+                ...(search.note ? { searchNote: `${searchNote}\n${search.note}` } : {}),
                 // 旧句「索引不含规则条件叶子与流程绑定」漏了表单与流程权限（r35a-F4 实证
                 // 探针据此差点误删被表单引用的字段）。改为指向结构化 coverage，不再靠散文。
-                note: "零命中只代表 references[].coverage.scanned 面没有命中；notScanned 面（尤其 form 与 workflow.permissions）未扫描，不可据此判定可安全删除或无影响",
+                note: `零命中只代表 references[].coverage.scanned 面没有命中；本索引覆盖应用：${index.coverage.applicationCodes.join("、") || "（未知）"}，不代表其他应用没有结果；notScanned 面（尤其 form 与 workflow.permissions）未扫描，不可据此判定可安全删除或无影响`,
             });
         }
         return toolError(`未知工具：${name}`);

package/dist/programming-workflow.js

@@ -17,6 +17,7 @@ import { wireCall, WireError, wireRows } from "./wire.js";
  * endpoint — see .scratch/backend-online-coding/recon.md §8).
  *
  * Commands:
+ *   ⚠ test  会 publish 并切编码模式（不可逆）
  *   pull    remote → tree + manifest (environment-stamped)
  *   status  local edits vs manifest, plus optional remote drift (--deep)
  *   apply   changed files → programming.save (→ --publish)
@@ -801,18 +802,30 @@ export async function cmdProgrammingTest(options) {
         const targetSchema = String(dataSpec.schema ?? schemaCode);
         const filter = (dataSpec.filter ?? {});
         const expect = (dataSpec.expect ?? {});
+        // data.list is only a locator here. Its projection is intentionally not
+        // used as evidence: omitted columns are returned as null and used to turn
+        // a correct rule into a false failure (F11).
         const listed = await callTool("data.list", {
             environment: session.environmentName,
             schemaCode: targetSchema,
             ...filterOf(filter),
-            displayFields: Object.keys(expect),
+            displayFields: ["bizObjectId", "id"],
         }, context);
         const rows = (listed.rows ?? listed.items ?? []);
-        const matched = rows.filter((row) => matchExpectation(row, expect).ok);
+        const loadedRows = [];
+        for (const row of rows) {
+            const id = String(row.bizObjectId ?? row.id ?? "");
+            if (!id)
+                continue;
+            const loaded = await callTool("data.load", { environment: session.environmentName, schemaCode: targetSchema, bizObjectId: id, full: true }, context);
+            if (loaded.exists === true && loaded.data && typeof loaded.data === "object")
+                loadedRows.push(loaded.data);
+        }
+        const matched = loadedRows.filter((row) => matchExpectation(row, expect).ok);
         const ok = matched.length > 0;
         if (!ok)
             assertsFailed += 1;
-        assertReports.push({ schema: targetSchema, filter, expect, rows: rows.length, ok, ...(ok ? {} : { sample: rows.slice(0, 3) }) });
+        assertReports.push({ schema: targetSchema, filter, expect, rows: loadedRows.length, ok, ...(ok ? {} : { sample: loadedRows.slice(0, 3) }) });
     }
     report.asserts = assertReports;
     // 5. Cleanup — only rows the fixture names (seed filter), never a blanket key.

package/dist/read-shapes.js

@@ -71,7 +71,7 @@ const READ_SHAPES = {
         keys: ["bizObjectId", "exists", "data:{...}"],
     },
     "app.list": {
-        keys: ["applications:array<{code,name,groupId?}>", "applicationsCount", "omitted"],
+        keys: ["applications:array<{code,name,groupId?,modelCount}>", "applicationsCount", "omitted"],
         notes: ["applicationsCount + omitted 与 discover 同构；omitted:false 表示内联即全集"],
     },
     "model.list": {
@@ -85,8 +85,8 @@ const READ_SHAPES = {
     },
     "model.inspect": {
         // Slim/compact face (window diet): field inventory is `fieldCodes`, not fields[].
-        keys: ["schemaCode", "fieldCodes", "form", "listview", "ruleCodes", "datarules", "workflow", "hint"],
-        notes: ["slim 面键是 fieldCodes（不是 fields[].code）"],
+        keys: ["schemaCode", "applicationCode", "fieldCodes", "form", "listview", "ruleCodes", "datarules", "workflow", "hint"],
+        notes: ["slim 面键是 fieldCodes（不是 fields[].code）；all:true 时 fields/artifact 行含 options"],
     },
     "field.list": {
         keys: ["fields:array<{code,name,type,...}>", "modelPresent?"],

package/dist/rollback.js

@@ -8,6 +8,7 @@ import { readJournal, resolveJournalEntry, laterWritesOnTarget } from "./journal
 import { canonicalForVerify, deepDiff, pruneNullish } from "./rollback-spec.js";
 import { sha256 } from "./support.js";
 import { emitTransportResult } from "./command-transport.js";
+import { acquireWriteLock } from "./write-lock.js";
 /** Pure runtime assembly: an injected context (tests) or the default one. */
 function runtime(context) {
     return context ?? makeToolContext({ sessions: new SessionManager(new ConfigStore(defaultPaths())) });
@@ -191,25 +192,53 @@ export async function applyRollback(ref, options, context) {
         };
     }
     const results = [];
-    for (const [index, call] of plan.inverse.calls.entries()) {
-        const { exitCode, result } = await runToolCall(call.tool, {
-            args: { ...call.args, environment: entry.environment, ...(options.confirmProduction ? { confirmProduction: true } : {}) },
-            requestId: `omc-rollback-${entry.seq}-${index + 1}`,
-            context: ctx,
-            print: () => undefined,
-        });
-        results.push({
-            tool: call.tool,
-            exitCode,
-            status: result.status,
-            ...(result.deliveryState ? { deliveryState: result.deliveryState } : {}),
-            ...(result.summary ? { summary: result.summary } : {}),
-            // r55: exit-code-only results hid the reason a restore call failed
-            // (input-invalid showed as a bare "status=error"). Surface the shape.
-            ...(exitCode === 0 ? {} : { blocker: result.blocker ?? null, message: result.message ?? null, ...(result.issues !== undefined ? { issues: result.issues } : {}), ...(result.diagnostic !== undefined ? { diagnostic: result.diagnostic } : {}) }),
-        });
-        if (exitCode !== 0)
-            return { status: "stopped", rollbackOf: { seq: entry.seq, tool: entry.tool }, step: index + 1, results, message: `恢复调用 ${call.tool} 未成功（status=${result.status}）；已执行的调用已各自记 journal，可对已完成步骤再 plan` };
+    // The inverse plan is intentionally kept as the seam for future inverse
+    // extensions (for example onlinejs.compose remove:true): all new restore
+    // shapes still become governed calls here, without changing the evidence
+    // or lock protocol.
+    const waitMs = options.waitMs ?? 0;
+    const deadline = Date.now() + waitMs;
+    let lock;
+    for (;;) {
+        lock = await acquireWriteLock(entry.environment);
+        if (lock.held)
+            break;
+        if (Date.now() >= deadline) {
+            return {
+                status: "refused",
+                blocker: "write-lock-held",
+                rollbackOf: { seq: entry.seq, tool: entry.tool },
+                waitMs,
+                lockOwner: lock.owner ?? null,
+                message: `回滚写锁被占用；已等待 ${waitMs}ms。可用 --wait <ms> 有界排队后重试`,
+            };
+        }
+        await new Promise((resolve) => setTimeout(resolve, Math.min(200, Math.max(0, deadline - Date.now()))));
+    }
+    try {
+        for (const [index, call] of plan.inverse.calls.entries()) {
+            const { exitCode, result } = await runToolCall(call.tool, {
+                args: { ...call.args, environment: entry.environment, ...(options.confirmProduction ? { confirmProduction: true } : {}) },
+                requestId: `omc-rollback-${entry.seq}-${index + 1}`,
+                context: ctx,
+                print: () => undefined,
+            });
+            results.push({
+                tool: call.tool,
+                exitCode,
+                status: result.status,
+                ...(result.deliveryState ? { deliveryState: result.deliveryState } : {}),
+                ...(result.summary ? { summary: result.summary } : {}),
+                // r55: exit-code-only results hid the reason a restore call failed
+                // (input-invalid showed as a bare "status=error"). Surface the shape.
+                ...(exitCode === 0 ? {} : { blocker: result.blocker ?? null, message: result.message ?? null, ...(result.issues !== undefined ? { issues: result.issues } : {}), ...(result.diagnostic !== undefined ? { diagnostic: result.diagnostic } : {}) }),
+            });
+            if (exitCode !== 0)
+                return { status: "stopped", rollbackOf: { seq: entry.seq, tool: entry.tool }, step: index + 1, results, message: `恢复调用 ${call.tool} 未成功（status=${result.status}）；已执行的调用已各自记 journal，可对已完成步骤再 plan` };
+        }
+    }
+    finally {
+        await lock.release();
     }
     // Authoritative verify: re-read the target and compare against the
     // canonicalized before. "restored" tolerates the write pipeline
@@ -232,6 +261,12 @@ export async function applyRollback(ref, options, context) {
         rollbackOf: { seq: entry.seq, tool: entry.tool, target: entry.target },
         calls: results,
         verify,
+        // Stable evidence is present on both the restored and mismatch paths.
+        // `recoveredTo` deliberately identifies the original journal target; the
+        // replay writes are separately journaled and can be rolled back again.
+        restoredSha256: restoredSha,
+        matchesBefore: verify === "restored",
+        recoveredTo: { seq: entry.seq, ts: entry.ts },
         ...(verify === "mismatch" ? { beforeSha, restoredSha, message: "恢复调用已完成但读回与 before 存在值冲突（非默认显式化）：立即人工核对目标现态（omc rollback plan <seq> 的 diff 可复看差异）" } : {}),
         hint: "本次恢复的每次调用都走了完整写闸门并已记 journal；恢复本身可再回滚（rollback plan <新 seq>）",
     };

package/dist/write.js

@@ -143,7 +143,7 @@ async function governedWrite(ctx, tool, args, execute, dryRunPayload, readOnlyEs
             const artifactRef = writeArtifact(ctx, `${tool.name}-${randomUUID().slice(0, 8)}.json`, artifact);
             return { status: executed.status, steps: executed.steps, failedStep: executed.failedStep, ...executed.envelope, ...(args.requestId ? { requestId: args.requestId } : {}), artifactFingerprint: artifactRef.detailSha256 };
         }
-        const { performed, readback, steps, halfSuccess, irreversible } = executed;
+        const { performed, readback, steps, halfSuccess, irreversible, rollbackReceipt, runtimeVerification } = executed;
         // Readback gate (live 2026-10-17): a tool that reports `readback.present:false`
         // has NOT proven its own write — the platform accepted the request but the
         // object is absent from the authoritative face. "Called without error" must
@@ -204,17 +204,21 @@ async function governedWrite(ctx, tool, args, execute, dryRunPayload, readOnlyEs
         return {
             status: "ok",
             deliveryState,
+            ...((typeof performed.applicationCode === "string" ? { applicationCode: performed.applicationCode } : typeof readback.applicationCode === "string" ? { applicationCode: readback.applicationCode } : {})),
             ...(readOnlyEscapeNote !== undefined ? { readOnlyEscape: readOnlyEscapeNote } : {}),
             performed,
             readback,
             ...(readbackWarning ? { readbackWarning } : {}),
             ...(steps !== undefined ? { steps } : {}),
             ...(halfSuccess !== undefined ? { halfSuccess } : {}),
+            ...(runtimeVerification !== undefined ? { runtimeVerification } : {}),
             ...(typeof irreversible === "string" ? { irreversible } : {}),
             // r30a F1: first write → replay:"none"; duplicate only on true replay.
             ...(args.requestId ? { requestId: args.requestId, idempotency: idempotencyDeclaration(tool.name, "none") } : {}),
             ...(productionConfirmed ? { productionConfirmed: true } : {}),
-            ...(rollbackRef ? { rollback: rollbackRef } : {}),
+            ...(rollbackRef
+                ? { rollback: { ...(rollbackReceipt ?? {}), seq: rollbackRef.seq, ...(rollbackReceipt ? {} : { hint: rollbackRef.hint }) } }
+                : {}),
             summary: writeSummary(tool.name, args, { performed, readback }, "done"),
             detailFile: artifactRef.detailFile,
             detailSha256: artifactRef.detailSha256,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stalfh233/omc-cli",
-  "version": "0.6.17",
+  "version": "0.6.18",
   "description": "CloudPivot 8.6 configuration capability CLI — governed, fail-closed, coverage-manifest bounded.",
   "type": "module",
   "bin": {
@@ -55,7 +55,7 @@
   },
   "dependencies": {
     "commander": "14.0.3",
-    "omc-core": "0.6.17",
+    "omc-core": "0.6.18",
     "proper-lockfile": "4.1.2",
     "write-file-atomic": "6.0.0",
     "zod": "^3.23.8",
@@ -73,6 +73,6 @@
     "directory": "packages/omc-cli"
   },
   "optionalDependencies": {
-    "@stalfh233/omc-fake-platform": "0.6.17"
+    "@stalfh233/omc-fake-platform": "0.6.18"
   }
 }