@stalfh233/omc-cli 0.6.17 → 0.6.19

package/dist/lanes/programming.js

@@ -7,6 +7,7 @@ import { writeTool } from "../write.js";
 import { defineTool, ToolRefusalError } from "../tool-types.js";
 import { wireCall, WireError } from "../wire.js";
 import { PROGRAMMING_LANE_CONTRACT, PROGRAMMING_WIRE } from "./programming-contract.js";
+import { readModelRecord } from "../model-record.js";
 const LANE = PROGRAMMING_LANE_CONTRACT.lane;
 const TOOLS = PROGRAMMING_LANE_CONTRACT.tools;
 /** metadata.app.CodeType is the NUMERIC index on the wire (8.6.26 source). */
@@ -60,7 +61,8 @@ async function readSource(session, args) {
         const model = asRecord(response.data);
         if (model === null)
             return { present: false, provisioned: false, model: null };
-        return { present: true, provisioned: typeof model.version === "number", model };
+        // get_source can return a generated template without a persisted source row.
+        return { present: typeof model.version === "number", provisioned: typeof model.version === "number", model };
     }
     catch (error) {
         if (error instanceof WireError && error.kind === "business" && /PROGRAMMING_SOURCE_NONEXISTENT|源码不存在|source.*nonexistent/i.test(error.message))
@@ -102,6 +104,13 @@ function assertTemplateShape(content, code) {
         });
     }
 }
+function assertProgrammingName(name) {
+    if (name === undefined)
+        return;
+    if (typeof name !== "string" || !/^[A-Za-z][A-Za-z0-9_ -]{0,127}$/.test(name)) {
+        throw new ToolRefusalError({ status: "refused", blocker: "programming-name-invalid", message: "businessRuleName 只能以字母开头，并只含字母、数字、下划线、空格或连字符（最多 128 字符）。" });
+    }
+}
 async function listRules(session, schemaCode) {
     const response = await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode } });
     return rowsOf(response.data);
@@ -223,6 +232,17 @@ function sourceRollback() {
         },
     };
 }
+function publishRollback() {
+    return {
+        target: (args) => `programming.publish:${String(args.schemaCode ?? "")}/${String(args.businessRuleCode ?? "")}`,
+        // A published version has no authoritative read face and cannot be
+        // restored by replaying the draft. Deliberately fail before-capture so the
+        // shared journal records rollbackable:false rather than implying a draft
+        // restore would undo the runtime version.
+        read: async () => { throw new Error("published version has no rollbackable read face"); },
+        inverse: () => ({ kind: "irreversible", reason: "无图形化回退端点；删除规则才会连源码一起删" }),
+    };
+}
 export function registerProgrammingLane(tools) {
     tools.push(defineTool({
         name: "programming.schemas",
@@ -310,12 +330,14 @@ export function registerProgrammingLane(tools) {
         },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
             const read = await readSource(session, args);
+            const model = await readModelRecord(session, args.schemaCode);
             const content = typeof read.model?.content === "string" ? read.model.content : null;
             return {
                 schemaCode: args.schemaCode,
                 businessRuleCode: args.businessRuleCode,
                 code: String(read.model?.code ?? args.code ?? businessRuleSourceCode(args.schemaCode, args.businessRuleCode)),
                 present: read.present,
+                modelExists: model !== null,
                 provisioned: read.provisioned,
                 className: read.model?.className ?? null,
                 codeType: read.model?.codeType ?? null,
@@ -326,13 +348,15 @@ export function registerProgrammingLane(tools) {
                 contentBytes: content === null ? null : Buffer.byteLength(content, "utf8"),
                 // r28j F7: --search "bizObject" 被写危害文档淹没；API 骨架入口钉在这里。
                 apiHint: 'BizObject 读写骨架：omc help omc-backend-online-coding --section "5. 典型 handler 骨架"',
-                ...(read.provisioned
-                    ? {
-                        // Draft face always reports published:false after publish too —
-                        // do not let callers treat this boolean as the publish verdict (F11).
-                        publishedNote: "本面 published 来自 version=0 草稿行；发布是否生效请看 programming.publish 的 readback.runtimeEffective / developmentMode+enabled，不要看本字段。",
-                    }
-                    : { hint: "未落库草稿：content 是平台按规则类型生成的模板骨架（version:null）。改完后 programming.save 落库，programming.publish 生效。" }),
+                ...(model === null
+                    ? { hint: `模型 ${args.schemaCode} 不存在；get_source 返回的只是平台模板骨架，不代表源码或模型存在。先用 model.list 核对 schemaCode。` }
+                    : read.provisioned
+                        ? {
+                            // Draft face always reports published:false after publish too —
+                            // do not let callers treat this boolean as the publish verdict (F11).
+                            publishedNote: "本面 published 来自 version=0 草稿行；发布是否生效请看 programming.publish 的 readback.runtimeEffective / developmentMode+enabled，不要看本字段。",
+                        }
+                        : { hint: "未落库草稿：content 是平台按规则类型生成的模板骨架（version:null）。改完后 programming.save 落库，programming.publish 生效。" }),
             };
         }, {
             target: `programming.get:${args.schemaCode}/${args.businessRuleCode}`,
@@ -442,10 +466,20 @@ export function registerProgrammingLane(tools) {
         },
         preflight: (args) => {
             const code = args.code ?? businessRuleSourceCode(args.schemaCode, args.businessRuleCode);
+            assertProgrammingName(args.businessRuleName);
             assertTemplateShape(args.content, code);
         },
-        dryRunPayload: async (_session, args) => {
+        dryRunPayload: async (session, args) => {
             const code = args.code ?? businessRuleSourceCode(args.schemaCode, args.businessRuleCode);
+            const rule = await ruleOf(session, args.schemaCode, args.businessRuleCode);
+            if (!rule) {
+                throw new ToolRefusalError({
+                    status: "refused",
+                    blocker: "programming-rule-absent",
+                    message: `业务规则 ${args.schemaCode}/${args.businessRuleCode} 不存在；save 不会凭空创建规则行。先用 rule.save（或 rule.list）确认/创建规则，再保存源码。`,
+                    nextCommand: `omc call rule.save --env local --args '{"schemaCode":"${args.schemaCode}","ruleCode":"${args.businessRuleCode}"}'`,
+                });
+            }
             return {
                 code,
                 contentSha256: sha256(args.content),
@@ -538,6 +572,8 @@ export function registerProgrammingLane(tools) {
             const publishStatusRaw = readbackRule?.publishStatus;
             return {
                 performed: { errcode: 0, code, contentSha256: sha256(content), contentBytes: Buffer.byteLength(content, "utf8"), compiled: true },
+                rollbackReceipt: { supported: false, reason: "无图形化回退端点；rollback plan 亦标 irreversible" },
+                runtimeVerification: { note: "自定义规则无调用响应体读面；验证须写副作用后用 data.load 读取" },
                 readback: {
                     present: readbackSource.present,
                     contentMatches: readbackContent === content,
@@ -554,19 +590,36 @@ export function registerProgrammingLane(tools) {
                     // so it cannot contradict runtimeEffective:"published".
                     ...(readbackSource.model?.published === true ? { publishedFlag: true } : { publishedFlagNote: "get_source.published 读的是 version=0 草稿行，发布后仍常为 false；不是发布成败判据（published 内容无 wire 读端点）" }),
                     note: "运行时执行的是 published 最新版；published 内容无 wire 读取端点，回滚靠本地 git + 重新 publish。判发布是否生效：authoritative=developmentMode+enabled（1/CODING + true）。",
+                    rollback: { supported: false, reason: "无图形化回退端点；删除规则才会连源码一起删" },
+                    runtimeVerification: { note: "自定义规则无调用响应体读面；须写副作用（如字段赋值）后 data.load 验证" },
                 },
             };
         },
         preflight: (args) => {
             const code = args.code ?? businessRuleSourceCode(args.schemaCode, args.businessRuleCode);
+            assertProgrammingName(args.businessRuleName);
             if (args.content !== undefined)
                 assertTemplateShape(args.content, code);
         },
-        dryRunPayload: async (_session, args) => ({
-            code: args.code ?? businessRuleSourceCode(args.schemaCode, args.businessRuleCode),
-            contentSha256: args.content === undefined ? null : sha256(args.content),
-            note: "dry-run 已执行模板校验；真写会 compile→publish（插新 published 版本行并把规则切 CODING+enable）。",
-        }),
+        dryRunPayload: async (session, args) => {
+            const code = args.code ?? businessRuleSourceCode(args.schemaCode, args.businessRuleCode);
+            const rule = await ruleOf(session, args.schemaCode, args.businessRuleCode);
+            if (!rule)
+                throw new ToolRefusalError({ status: "refused", blocker: "programming-rule-absent", message: `业务规则 ${args.schemaCode}/${args.businessRuleCode} 不存在：publish 必须携带 businessRule 整模型。` });
+            let content = args.content;
+            if (content === undefined) {
+                const read = await readSource(session, { schemaCode: args.schemaCode, businessRuleCode: args.businessRuleCode });
+                content = typeof read.model?.content === "string" ? read.model.content : undefined;
+            }
+            if (content === undefined || content.trim() === "")
+                throw new ToolRefusalError({ status: "refused", blocker: "programming-content-required", message: "没有可发布的源码：传 content，或先 programming.save 落库草稿。" });
+            assertTemplateShape(content, code);
+            const compiled = await compileSource(session, code, content);
+            if (!compiled.success)
+                throw new ToolRefusalError({ status: "refused", blocker: "programming-compile-failed", message: "编译失败，拒绝 dry-run（真写也会拒绝发布）。", errors: compiled.presented.errors ?? compiled.errors, userErrors: compiled.presented.userErrors, platformErrors: compiled.presented.platformErrors });
+            return { code, contentSha256: sha256(content), contentBytes: Buffer.byteLength(content, "utf8"), note: "dry-run 与真写执行相同的规则存在、模板形状、编译 preflight；不会写入或切 CODING。" };
+        },
+        rollback: publishRollback(),
     });
 }
 export { PROGRAMMING_WIRE };

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?"],