@stalfh233/omc-cli 0.6.13 → 0.6.14

package/dist/cli.js

@@ -883,6 +883,18 @@ function projectArtifactPath(value, path) {
         ? { missed: true, ...(fanout.at !== undefined ? { at: fanout.at } : {}), ...(fanout.available !== undefined ? { available: fanout.available } : {}) }
         : { missed: false, content: fanout.values, mapped: fanout.values.length, ...(fanout.missedEntries > 0 ? { missedEntries: fanout.missedEntries } : {}), nullEntries: fanout.nullEntries };
 }
+/** Preserve source completeness/count facts on every artifact projection. */
+function artifactProjectionMetadata(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return {};
+    const record = value;
+    const metadata = {};
+    for (const key of ["truncated", "truncatedKeys", "itemsCount", "total"]) {
+        if (Object.prototype.hasOwnProperty.call(record, key))
+            metadata[key] = record[key];
+    }
+    return metadata;
+}
 /**
  * T6（GitLab #17）：`mapped`/`nullEntries` 的读法要跟数据一起走，否则 `mapped:5`
  * 会被读成"取到 5 个值"。文案的单一真相源在 path-projection（与 `--extract`
@@ -938,15 +950,17 @@ async function cmdArtifactGet(id, transport, options = {}) {
                 // 一层 `projection:{path,content}`——`artifact get --jq` 与 `--summary --jq`
                 // 因此同形（顶层 path/content），换读面不用重新探根键。
                 return emitTransportResult(projected.missed
-                    ? { status: "ok", artifactId: id, sha256: artifact.sha256, bytes: artifact.content.length, keys, path: options.jq, content: null, pathMiss: true, missedAt: projected.at, available: projected.available, unanswered: true, hint: artifactPathMissHint(projected.at) }
+                    ? { status: "ok", artifactId: id, sha256: artifact.sha256, bytes: artifact.content.length, ...artifactProjectionMetadata(content), keys, path: options.jq, content: null, projections: [{ path: options.jq, content: null, pathMiss: true, missedAt: projected.at, available: projected.available }], pathMiss: true, missedAt: projected.at, available: projected.available, unanswered: true, hint: artifactPathMissHint(projected.at) }
                     : {
                         status: "ok",
                         artifactId: id,
                         sha256: artifact.sha256,
                         bytes: artifact.content.length,
+                        ...artifactProjectionMetadata(content),
                         keys,
                         path: options.jq,
                         content: projected.content ?? null,
+                        projections: [{ path: options.jq, content: projected.content ?? null, ...(projected.mapped !== undefined ? { mapped: projected.mapped } : {}), ...(projected.missedEntries !== undefined ? { missedEntries: projected.missedEntries } : {}), ...(projected.nullEntries !== undefined && projected.nullEntries > 0 ? { nullEntries: projected.nullEntries } : {}) }],
                         ...(projected.mapped !== undefined ? { mapped: projected.mapped } : {}),
                         ...(projected.nullEntries !== undefined && projected.nullEntries > 0 ? { nullEntries: projected.nullEntries } : {}),
                         ...(projected.missedEntries !== undefined ? { missedEntries: projected.missedEntries } : {}),
@@ -992,12 +1006,12 @@ async function cmdArtifactGet(id, transport, options = {}) {
                         ? { path, content: null, pathMiss: true, missedAt: projected.at, available: projected.available }
                         : { path, content: projected.content ?? null, ...(projected.mapped !== undefined ? { mapped: projected.mapped } : {}), ...(projected.missedEntries !== undefined ? { missedEntries: projected.missedEntries } : {}), ...(projected.nullEntries !== undefined && projected.nullEntries > 0 ? { nullEntries: projected.nullEntries } : {}), ...(artifactNullHint(projected.content, projected.nullEntries) !== undefined ? { hint: artifactNullHint(projected.content, projected.nullEntries) } : {}) };
                 });
-                return emitTransportResult({ status: "ok", artifactId: id, sha256: artifact.sha256, projections, ...(projections.some((entry) => entry.pathMiss) ? { unanswered: true, hint: partialPathMissHint() } : {}) }, transport);
+                return emitTransportResult({ status: "ok", artifactId: id, sha256: artifact.sha256, ...artifactProjectionMetadata(content), projections, ...(projections.some((entry) => entry.pathMiss) ? { unanswered: true, hint: partialPathMissHint() } : {}) }, transport);
             }
             const projected = projectArtifactPath(artifactContent, options.jq);
             return emitTransportResult(projected.missed
-                ? { status: "ok", artifactId: id, sha256: artifact.sha256, path: options.jq, content: null, pathMiss: true, missedAt: projected.at, available: projected.available, unanswered: true, hint: artifactPathMissHint(projected.at) }
-                : { status: "ok", artifactId: id, sha256: artifact.sha256, path: options.jq, content: projected.content ?? null, ...(projected.mapped !== undefined ? { mapped: projected.mapped } : {}), ...(projected.missedEntries !== undefined ? { missedEntries: projected.missedEntries } : {}), ...(projected.nullEntries !== undefined && projected.nullEntries > 0 ? { nullEntries: projected.nullEntries } : {}), ...(artifactNullHint(projected.content, projected.nullEntries) !== undefined ? { hint: artifactNullHint(projected.content, projected.nullEntries) } : {}) }, transport);
+                ? { status: "ok", artifactId: id, sha256: artifact.sha256, ...artifactProjectionMetadata(content), path: options.jq, content: null, pathMiss: true, missedAt: projected.at, available: projected.available, unanswered: true, hint: artifactPathMissHint(projected.at) }
+                : { status: "ok", artifactId: id, sha256: artifact.sha256, ...artifactProjectionMetadata(content), path: options.jq, content: projected.content ?? null, projections: [{ path: options.jq, content: projected.content ?? null, ...(projected.mapped !== undefined ? { mapped: projected.mapped } : {}), ...(projected.missedEntries !== undefined ? { missedEntries: projected.missedEntries } : {}), ...(projected.nullEntries !== undefined && projected.nullEntries > 0 ? { nullEntries: projected.nullEntries } : {}) }], ...(projected.mapped !== undefined ? { mapped: projected.mapped } : {}), ...(projected.missedEntries !== undefined ? { missedEntries: projected.missedEntries } : {}), ...(projected.nullEntries !== undefined && projected.nullEntries > 0 ? { nullEntries: projected.nullEntries } : {}), ...(artifactNullHint(projected.content, projected.nullEntries) !== undefined ? { hint: artifactNullHint(projected.content, projected.nullEntries) } : {}) }, transport);
         }
         // r6-onboarding 2026-10-21: 47 artifact fetches, 0 used a projection; the 10
         // large ones (up to 55 KB) pulled whole workflow templates just to read one
@@ -1894,7 +1908,22 @@ function cmdHelpSearch(topic, query, transport, searchMode, limit) {
     }
     if (all) {
         console.error(`omc help ${document.name} --all（${Buffer.byteLength(document.content, "utf8")} B）`);
-        return emitTransportResult({ status: "ok", topic: document }, transport);
+        // r32 F3（真机）：三种模式三种形状——默认回 sections[]、--section 回顶层 content、
+        // --all 却回 {topic:{name,description,content}}。按前两种写的解析（.content /
+        // .result.topic 当字符串）在 --all 上全部取不到，而默认模式的 hint 恰恰把 --all
+        // 指成"确需整篇"的下一步。
+        // 现在 --all 与前两者同形：topic 是 topic 名（字符串），正文在顶层 content，
+        // 并附 bytes/chars/complete。**不要再把 content 放进 topic**——那会让整篇在
+        // 信封里出现两次，撑破 64KiB 预算后被外置成 artifact（r32 实测：help-write-hazards
+        // 因此从"直接回正文"退化成"回一个每次不同的 artifactId"，golden 永久漂移）。
+        return emitTransportResult({
+            status: "ok",
+            topic: document.name,
+            content: document.content,
+            bytes: Buffer.byteLength(document.content, "utf8"),
+            chars: document.content.length,
+            complete: true,
+        }, transport);
     }
     // Shape first. Round 10 paid 35,872 B per full read of one topic, seven times
     // in a single session, to use one or two headings. The index names every

package/dist/discovery.js

@@ -485,6 +485,10 @@ export function describeTool(registry, name) {
         // High-frequency read faces: declare the RESULT keys so `--jq` does not
         // have to learn them from a pathMiss. Zero bytes when undeclared.
         ...(returnsFace(tool.name) ?? {}),
+        // r32 F1（真机）：探针并发发两条 app.create，第二条回 write-lock-held。
+        // 撞上之前没有任何发现面说过"写是环境级串行"——describe 的 params 里没有 wait
+        // （它是 omc call 的 CLI 开关，不在工具 schema），capability notes 是空的。
+        ...(tool.kind === "write" ? { writeLock: "写锁=环境级：同一环境的并发写，后到的直接回 write-lock-held（不排队）。可带 --wait <ms> 让 CLI 内部排队（CLI 开关，不是本工具参数）；不要写 shell 重试循环" } : {}),
         // Keep the cost salient at the decision point: agents reached for --full even
         // when --example/--param existed (sandbox22: 8 --full calls, one 19 KB).
         full: `omc describe ${tool.name} --full（5–20KB；先试 --example/--param）`,

package/dist/lanes/app.js

@@ -80,7 +80,7 @@ export function registerAppLane(tools) {
         lane: APP_LANE,
         scope: APP_TOOLS["app.create"].scope,
         description: APP_TOOLS["app.create"].description,
-        inputSchema: { code: z.string().min(1), name: z.string().min(1), groupId: z.string().optional() },
+        inputSchema: { code: z.string().min(1), name: z.string().min(1), groupId: z.string().describe("省略时使用环境配置的默认应用分组（回执 resolvedFrom=auto-configured-app-group），不需要先查 groupId").optional() },
         execute: async (session, args) => {
             const existing = wireRows((await wireCall(session, { path: ENDPOINTS.applicationList, query: {} })).data).find((row) => (row.appCode ?? row.code) === args.code);
             if (existing)

package/dist/lanes/field-contract.js

@@ -190,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 — 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 再发，勿重复建字段。",
+            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 再发，勿重复建字段。**部分交付口径**：有请求的 code 不在发布面时 `allRequestedPresent:false` + `verified:false` + `readback.present:false`（共享写门据此把 deliveryState 降为 WRITE_UNVERIFIED）+ `unpublishedRequested`，并区分 `nonexistentCodes`（草稿面都没有——先 field.list 核对）与 `stillDraftCodes`（模型里有、发布后仍不在发布面）——已发布的字段仍然算发布了，但不要只看 ok/DELIVERED。",
         }),
         "field.delete": Object.freeze({
             scope: "create publish readback",
@@ -219,7 +219,7 @@ export function assertFieldContract() {
         throw new Error("field contract pins the publish scope to model");
     assertDescriptionCarries(FIELD_LANE_CONTRACT, "field.create", ["bizproperty/create", "OCR/ELECTRONIC_SIGN", "`choices`", "options.optionsSet", "`relativeCode`", "searchFormula", "`options.formulaConfig`", "`options.relevanceField`", "code_reserved", "WORK_SHEET"]);
     assertDescriptionCarries(FIELD_LANE_CONTRACT, "field.update", ["bizproperty/update", "`options`", "field.publish", "cascadeRepublish", "form.draft(rebuild)", "form.publish(force)", "published fields", "non-structural", "partial"]);
-    assertDescriptionCarries(FIELD_LANE_CONTRACT, "field.publish", ["bizproperty/publish", "published", "Model-scoped", "publishedCodes"]);
+    assertDescriptionCarries(FIELD_LANE_CONTRACT, "field.publish", ["bizproperty/publish", "published", "Model-scoped", "publishedCodes", "unpublishedRequested", "nonexistentCodes", "stillDraftCodes"]);
     assertDescriptionCarries(FIELD_LANE_CONTRACT, "field.delete", ["bizproperty/force_delete", "absence"]);
 }
 //# sourceMappingURL=field-contract.js.map

package/dist/lanes/field.js

@@ -197,7 +197,7 @@ export function registerFieldLane(tools) {
         lane: FIELD_LANE,
         scope: FIELD_TOOLS["field.list"].scope,
         description: FIELD_TOOLS["field.list"].description,
-        inputSchema: { environment: environmentArg, schemaCode: z.string(), published: z.boolean().default(false), code: z.string().optional(), fields: z.array(z.string()).optional(), full: z.boolean().optional().describe("行内联完整 options/subSchema；默认清单面只有 code/name/type/typeName(+conditions 信号/shapeWarning)，验证 options 用 code/fields 选择器或 full:true"), all: z.boolean().optional().describe("默认只返业务字段（过滤 SYSTEM_FIELD_CODES 的 13 个平台字段：id/name/sequenceNo/createdTime/creater/sequenceStatus/…）；true 连系统字段一起返"), capability: capabilityArg },
+        inputSchema: { environment: environmentArg, schemaCode: z.string(), published: z.boolean().default(false), code: z.string().optional(), fields: z.array(z.string()).optional(), full: z.boolean().optional().describe("行内联完整 options/subSchema；默认清单面只有 code/name/type/typeName(+conditions 信号/shapeWarning)，验证 options 用 code/fields 选择器或 full:true；平台读面带回 propertyEmpty 时一并输出（不回则省略，不塞 false）"), all: z.boolean().optional().describe("默认只返业务字段（过滤 SYSTEM_FIELD_CODES 的 13 个平台字段：id/name/sequenceNo/createdTime/creater/sequenceStatus/…）；true 连系统字段一起返"), capability: capabilityArg },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
             const rows = wireRows((await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: args.published ? "true" : "false" } })).data);
             const mapped = rows.map((row) => {
@@ -230,6 +230,11 @@ export function registerFieldLane(tools) {
                         : {}),
                     ...(row.relativeCode ? { relativeCode: row.relativeCode } : {}),
                     ...(typeof row.relativePropertyCode === "string" && row.relativePropertyCode ? { relativePropertyCode: row.relativePropertyCode } : {}),
+                    // r32：propertyEmpty 只在平台读面**确实**带回该值时才输出——缺键不给
+                    // 每个字段塞 false（假读回 + 噪音）。真机 8.6.26 的 bizproperty/list
+                    // 不带这个键，于是不会出现；write-only 的确认走 field.update 的
+                    // readback.committed。
+                    ...(Object.prototype.hasOwnProperty.call(row, "propertyEmpty") ? { propertyEmpty: row.propertyEmpty } : {}),
                     ...(options !== undefined ? { options } : {}),
                     ...(scaleWarning !== undefined ? { shapeWarning: scaleWarning } : {}),
                 };
@@ -454,7 +459,7 @@ export function registerFieldLane(tools) {
             choices: choicesArg,
             relativeCode: relativeCodeArg,
             subFields: subFieldArg,
-            propertyEmpty: z.boolean().optional().describe("覆盖数据模型层的不可为空声明；传 false 可把历史误建的字段改回可为空（必填/只读应在表单与流程节点配置）"),
+            propertyEmpty: z.boolean().optional().describe("覆盖数据模型层的不可为空声明；传 false 可把历史误建的字段改回可为空（必填/只读应在表单与流程节点配置）。readback.committed 列出本次实际提交到线缆的键，readback.propertyEmpty 只在草稿面回读到该值时才出现（r32 真机：bizproperty/list 行不带 propertyEmpty，读不到即不编造，用 committed 确认本次提交）"),
             syncDictionary: z
                 .boolean()
                 .optional()
@@ -1042,6 +1047,21 @@ async function runFieldUpdate(session, args) {
     // confirm the write landed — the readback only named the field. Field
     // options are the form-interaction contract (ADR 0005), so read them back.
     const storedOptions = after !== undefined ? parseFieldOptionsForReadback(after.options) : undefined;
+    // r32（真机复现：field.update propertyEmpty:true 回 ok/DELIVERED，field.list --full
+    // 与 model.inspect 都看不到该值）：平台字段行读面（bizproperty/list 与
+    // bizproperty/get）都不回 propertyEmpty，这是**只写属性**。不编造读回值：
+    // - `propertyEmpty` 只在草稿行确实带该键时才输出（不与 null 比较）；否则省略；
+    // - `committed` 列出本次线缆体里实际提交的键，调用方据此确认「提交了什么」。
+    const submittedPropertyEmpty = args.propertyEmpty;
+    const hasReadBackPropertyEmpty = after !== undefined && Object.prototype.hasOwnProperty.call(after, "propertyEmpty");
+    const committedKeys = [
+        ...(args.name !== undefined ? ["name"] : []),
+        ...(args.name_i18n !== undefined ? ["name_i18n"] : []),
+        ...(effectiveOptions !== undefined || args.choices !== undefined ? ["options"] : []),
+        ...(args.relativeCode !== undefined ? ["relativeCode"] : []),
+        ...(args.propertyEmpty !== undefined ? ["propertyEmpty"] : []),
+    ];
+    const unverifiable = submittedPropertyEmpty !== undefined && !hasReadBackPropertyEmpty ? ["propertyEmpty"] : [];
     return {
         performed: { errcode: performed.errcode },
         ...(prepared.conditionCompiled !== undefined && prepared.conditionCompiled.length > 0
@@ -1053,6 +1073,14 @@ async function runFieldUpdate(session, args) {
             ...(after?.name !== undefined ? { name: after.name } : {}),
             ...(typeof after?.name_i18n === "string" ? { name_i18n: after.name_i18n } : {}),
             ...(after?.type !== undefined || after?.propertyType !== undefined ? { type: after?.type ?? after?.propertyType } : {}),
+            ...(hasReadBackPropertyEmpty ? { propertyEmpty: after?.propertyEmpty } : {}),
+            committed: committedKeys,
+            ...(unverifiable.length > 0
+                ? {
+                    unverifiable,
+                    unverifiableNote: "propertyEmpty 是只写属性：平台字段读面（bizproperty/list|get）不回该键，无法读回核对。本回执只证明它已随本次请求提交。",
+                }
+                : {}),
             ...(storedOptions !== undefined && storedOptions !== null ? { options: storedOptions } : {}),
             ...(dictionarySynced !== undefined ? { dictionarySynced } : {}),
             ...(formConditionSync !== undefined ? { formConditionSync } : {}),
@@ -1245,6 +1273,18 @@ function fieldTypeName(row) {
     const raw = row.typeName ?? fieldTypeLabel(row.type ?? row.propertyType);
     return String(raw ?? "");
 }
+/**
+ * r32: 一句话说清「哪些 code 没到位、下一步怎么核对」。不存在的 code 指向
+ * field.list（拼错/尚未创建），仍留在草稿面的 code 指向平台发布异常。
+ */
+function signPartialDelivery(missing, nonexistent, stillDraft) {
+    const parts = [];
+    if (nonexistent.length > 0)
+        parts.push(`${nonexistent.join("、")} 在模型里不存在（草稿面也没有）：先 field.list 核对 code（omc call field.list --args '{"schemaCode":"<schemaCode>"}'），或先 field.create 建字段——本次发布不会建字段`);
+    if (stillDraft.length > 0)
+        parts.push(`${stillDraft.join("、")} 模型里有但发布后仍不在发布面：按发布失败排查（查看平台日志后重试本工具，模型级发布可重复执行）`);
+    return `部分交付（unpublishedRequested: ${missing.join("、")}）：已发布的字段确实已发布，但这些请求的 code 不在发布面。${parts.join("；")}`;
+}
 export async function executeFieldPublish(session, args) {
     // bizproperty/publish is MODEL-SCOPED: one call publishes every draft
     // field of the schema. `code`/`codes` only select which fields to verify
@@ -1289,6 +1329,10 @@ export async function executeFieldPublish(session, args) {
         const mismatches = checked.filter((entry) => entry.kind === "mismatch");
         return { mode: "detail", verified: true, checked: bounded.length, ok: mismatches.length === 0, ...(mismatches.length > 0 ? { mismatches } : {}) };
     };
+    // r32: 请求里不存在的 code 不能靠「发布面缺它」推断——发布面缺也可能是这次
+    // 发布才补上的。先记录 DRAFT 面（= 模型里真实存在的字段）的 code 集合，
+    // 用来把「不存在」与「未发布」分开报。
+    const draftCodesBefore = new Set(draftSnapshot.keys());
     const preRead = await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "true" } });
     const prePublishedRows = wireRows(preRead.data);
     const prePublished = prePublishedRows.map(codeOf).filter((code) => code.length > 0);
@@ -1375,8 +1419,22 @@ export async function executeFieldPublish(session, args) {
     const publishedCodes = wireRows(readback.data).map(codeOf).filter((code) => code.length > 0);
     const requested = [...(args.code ? [args.code] : []), ...(args.codes ?? [])];
     const present = requested.filter((code) => publishedCodes.includes(code));
+    // r32（真机复现 0.6.13）：`codes:["g1","notExist"]` 回 ok + DELIVERED +
+    // allRequestedPresent:false + verification.ok:true —— 三个成功标记与「有请求的
+    // 字段不在发布面」同真。不在发布面的 code 分两类，报法不同：
+    //   nonexistentCodes —— 草稿面都没有（模型里根本不存在，多半是拼错）；
+    //   stillDraftCodes  —— 模型里有、发布后仍不在发布面（真异常）。
+    // 两者都让这次交付只算**部分成功**：已发布的字段是真发布了，所以不整单
+    // 判失败；但既有的 verified/ok、allRequestedPresent、verification.ok 都不能
+    // 再报 true（派生的 readback.present=false 会让共享写门把 deliveryState 降为
+    // 既有枚举值 WRITE_UNVERIFIED——刻意不新增枚举外的值）。
+    const missingRequested = requested.filter((code) => !present.includes(code));
+    const nonexistentCodes = missingRequested.filter((code) => !draftCodesBefore.has(code));
+    const stillDraftCodes = missingRequested.filter((code) => draftCodesBefore.has(code));
+    const allRequestedPresent = missingRequested.length === 0;
     const targets = (requested.length > 0 ? requested : [...draftSnapshot.keys()]).filter((code) => publishedCodes.includes(code));
-    const verification = await verifyFieldDetails(targets);
+    const verificationRun = await verifyFieldDetails(targets);
+    const verification = allRequestedPresent ? verificationRun : { ...verificationRun, ok: false };
     const mismatches = verification.mismatches;
     if (mismatches !== undefined)
         throw new ToolRefusalError({
@@ -1392,7 +1450,23 @@ export async function executeFieldPublish(session, args) {
             publishedCodes,
             ...(args.code ? { publishedFieldPresent: publishedCodes.includes(args.code) } : {}),
             ...(args.codes ? { publishedFieldsPresent: Object.fromEntries(args.codes.map((code) => [code, publishedCodes.includes(code)])) } : {}),
-            ...(requested.length > 0 ? { allRequestedPresent: present.length === requested.length } : {}),
+            ...(requested.length > 0
+                ? {
+                    allRequestedPresent,
+                    verified: allRequestedPresent,
+                    // 共享写门（write.ts deliveryStateFor）读 readback.present：部分成功不
+                    // 能盖 DELIVERED。全部就位时不写这个键（只增语义，不改变成功回执）。
+                    ...(allRequestedPresent ? {} : { present: false }),
+                    ...(allRequestedPresent
+                        ? {}
+                        : {
+                            unpublishedRequested: missingRequested,
+                            ...(nonexistentCodes.length > 0 ? { nonexistentCodes } : {}),
+                            ...(stillDraftCodes.length > 0 ? { stillDraftCodes } : {}),
+                            note: signPartialDelivery(missingRequested, nonexistentCodes, stillDraftCodes),
+                        }),
+                }
+                : {}),
             verification,
             // issue #24 主诉：publishedCodes 只证明「字段可用」，不等于「页面可见」。
             formBinding: await formBindingAdvisory(session, args.schemaCode, wireRows(readback.data)),

package/dist/lanes/list-view-contract.js

@@ -12,7 +12,7 @@ export const LIST_VIEW_WIRE = Object.freeze({
     configureDefault: "code omitted means the default view (code=schemaCode)",
     configureColumns: "query/get then query/update: for each fieldCodes entry, append a missing column as visible, or repair an existing column's name/propertyType/displayFormat/visible in place (never skip an already-present column), then query/get readback; propertyType comes from published field metadata; NUMERICAL displayFormat is derived from the field's 0-based `options.scale` (0=integer,1=1dp,2=2dp,3=3dp…8=8dp) through the platform parseNumber table ({0:1,1:2,2:3,3:11,4:12,23:…, percent 0..:4/5/6/13/14/27..30, currency ¥ 2dp..:7/15/16/31..34} — verified live: scale 2 → displayFormat 3 = 2 decimals) and DATE displayFormat from options.format (1=yyyy-MM-dd,2=datetime,3=minute,4=yyyy-MM); the readback columns array carries {propertyCode,propertyType,displayFormat,visible,sumType} and added/updated name the fieldCodes touched",
     configureSorts: "sorts -> querySorts [{propertyCode,propertyType,direction,sortKey,clientType}]; direction SortDirectionType numeric ASC(1)/DESC(2); omitted leaves the existing sorts untouched, provided replaces them",
-    configureConditions: "conditions -> queryConditions [{propertyCode,propertyType,displayType,filterType,defaultValue,options,startValue,endValue,shortcutFilter,choiceType,dateType,accurateSearch,showNull,includeSubData,buildTreeBy,visible}]; filterType is the comparison OPERATOR (QueryFilterType STRING enum: Eq/NotEq/Gt/Lt/Gte/Lte/Like/NotLike/IsNull/IsNotNull/In/NotIn/Between/NotBetween/Of/NotOf/…; omitted → the platform default for the propertyType; aliases operator/op); displayType INPUT(0)/RADIO(1)/CHECKBOX(2)/SELECT(3)/RANGE(4); choiceType SELECT(1)/POPUP(2)/TREE_LEFT(3); options is a JSON string (decoded on readback)",
+    configureConditions: "conditions -> queryConditions [{propertyCode,propertyType,displayType,filterType,defaultValue,options,startValue,endValue,shortcutFilter,choiceType,dateType,accurateSearch,showNull,includeSubData,buildTreeBy,visible}]; filterType is the comparison OPERATOR (QueryFilterType STRING enum: Eq/NotEq/Gt/Lt/Gte/Lte/Like/NotLike/IsNull/IsNotNull/In/NotIn/Between/NotBetween/Of/NotOf/…; omitted → the platform default for the propertyType; aliases operator/op and legacy options.op); displayType INPUT(0)/RADIO(1)/CHECKBOX(2)/SELECT(3)/RANGE(4); choiceType SELECT(1)/POPUP(2)/TREE_LEFT(3); options is a JSON string (decoded on readback); conditionReadback is equivalent only for field-by-field equality, otherwise coerced with from/to details; viewConditionsAppliedRest:false records that REST data.list --queryCode does not apply fixed conditions",
     configureConditionMap: "queryConditionMap {<schemaCode>: queryConditions[]} is read-derived (query/get with a formCode child-table filter); BizQueryDetailConfig persists queryConditions/querySorts only, so the map is not a configure input",
     configureActions: "actions -> queryActions [{actionCode,name,icon,queryActionType,systemAction,serviceCode,serviceMethod,customService,associationCode,associationType,sortKey}]; queryActionType QueryActionType numeric QUERY(1)/ADD(2)/.../BATCH_SUBMIT(23); associationType QueryActionRelativeType numeric BIZSHEET(0)/WORKFLOW(1); associationCode/associationType are the JSON names of the DTO fields relativeCode/queryActionRelativeType (@JsonProperty); omitted leaves the existing actions untouched, provided MERGES into the effective set by actionCode (live 2026-09-17: query/update replaces-then-re-adds the submitted list, so a merge keeps the platform's built-in 新增/删除/导入/导出 and updates a matching actionCode — replaceActions:true restores the authoritative full set, defaultActions:true re-seeds the platform default set); query/get auto-injects default actions (qr_code/batch_print/batch_update/import_attachment/export_attachment/batch_submit) and query/update resets sortKey to i+1",
     configurePresentation: "presentation -> queryPresentation {clientType,htmlJson,actionsJson,columnsJson,queryViewDataSource,schemaRelations,options}; htmlJson/actionsJson/columnsJson JSON strings are decoded once before render-shape validation (html element tagName+attrs, action actionCode/name/icon, column propertyCode/propertyType); invalid input refuses with listview-presentation-render-invalid before wire and is never double-encoded; clientType is forced to PC by query/update; schemaRelations is platform-derived from the queryColumns tree (resolveRelations) and overwrites your input; a non-empty htmlJson updates the environment record, which query/delete cleans up; omitted leaves the existing presentation untouched (the read-face object must be echoed, because saveBizQueryDetail removes every presentation whose clientType matches before re-adding), provided replaces it",

package/dist/lanes/list-view.js

@@ -28,6 +28,24 @@ function fieldOptions(options) {
     }
     return options && typeof options === "object" ? options : {};
 }
+function conditionOptionsWithOperator(condition) {
+    const options = condition.options;
+    if (typeof options !== "object" || options === null || Array.isArray(options))
+        return condition;
+    const optionRecord = options;
+    if (optionRecord.op === undefined)
+        return condition;
+    const aliases = { eq: "Eq", ne: "NotEq", neq: "NotEq", gt: "Gt", gte: "Gte", lt: "Lt", lte: "Lte", like: "Like" };
+    const raw = String(optionRecord.op);
+    return {
+        ...condition,
+        ...(condition.filterType === undefined && condition.operator === undefined ? { filterType: aliases[raw.toLowerCase()] ?? raw } : {}),
+        options: Object.fromEntries(Object.entries(optionRecord).filter(([key]) => key !== "op")),
+    };
+}
+function conditionValueEqual(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
 /**
  * QueryRuntimeController.parseNumber keys its formatting off displayFormat with
  * no case 0 (valid values start at 1): 1=integer, 2=1dp, 3=2dp, 11=3dp,
@@ -650,10 +668,15 @@ export function registerListViewLane(tools) {
             let requestedConditionKeys;
             let requestedConditionSpec;
             if (args.conditions !== undefined) {
-                const normalizedConditions = normalizeConditions(args.conditions, fieldRows, args.schemaCode);
+                const inputConditions = args.conditions.map(conditionOptionsWithOperator);
+                const normalizedConditions = normalizeConditions(inputConditions, fieldRows, args.schemaCode);
                 body.queryConditions = normalizedConditions;
                 requestedConditionKeys = normalizedConditions.map((row) => String(row.propertyCode ?? ""));
-                requestedConditionSpec = normalizedConditions.map((row) => ({ propertyCode: String(row.propertyCode ?? ""), filterType: row.filterType }));
+                requestedConditionSpec = inputConditions.map((requested, index) => ({
+                    propertyCode: String(normalizedConditions[index]?.propertyCode ?? requested.propertyCode ?? ""),
+                    requested,
+                    normalized: normalizedConditions[index] ?? {},
+                }));
             }
             // saveBizQueryDetail removes every action whose clientType matches the
             // update and re-adds the submitted list, so an omitted `actions` must echo
@@ -807,6 +830,8 @@ export function registerListViewLane(tools) {
             if (conditions.length > 0)
                 readback.conditionRuntimeNote =
                     "视图条件的运行时过滤语义未取证：REST `data.list --queryCode <本视图>` 实测不应用固定条件（r35：读回 Gte/5000 正确、返回未过滤 4 条）。别用 queryCode 断言过滤生效；REST 侧过滤用 `data.list` 显式 `filter`。";
+            if (conditions.length > 0)
+                readback.viewConditionsAppliedRest = false;
             // Post-write semantic readback (dogfood R2): the platform MODELS a list
             // condition as a filter CONTROL definition, so a requested condition whose
             // propertyCode does not survive the round-trip was lost. Surface that as
@@ -819,25 +844,35 @@ export function registerListViewLane(tools) {
                 // lands with the WRONG comparison is just as wrong as one that is
                 // dropped (dogfood R2 follow-up).
                 const storedByCode = new Map(conditions.map((condition) => [String(condition.propertyCode ?? ""), condition]));
-                const filterTypeMismatches = (requestedConditionSpec ?? [])
-                    .filter((spec) => storedByCode.has(spec.propertyCode))
-                    .filter((spec) => String(storedByCode.get(spec.propertyCode)?.filterType ?? "") !== String(spec.filterType ?? ""))
-                    .map((spec) => ({ propertyCode: spec.propertyCode, requested: spec.filterType ?? null, stored: storedByCode.get(spec.propertyCode)?.filterType ?? null }));
-                const equivalent = missingConditions.length === 0 && filterTypeMismatches.length === 0;
+                const coercions = (requestedConditionSpec ?? []).flatMap((spec) => {
+                    const stored = storedByCode.get(spec.propertyCode);
+                    if (!stored)
+                        return [{ propertyCode: spec.propertyCode, field: "condition", from: spec.requested, to: null }];
+                    const fields = [
+                        ["filterType", spec.requested.filterType ?? spec.requested.operator ?? spec.requested.op ?? spec.normalized.filterType, stored.filterType],
+                        ["displayType", spec.requested.displayType, stored.displayType],
+                        ["defaultValue", spec.requested.defaultValue, stored.defaultValue],
+                        ["options", spec.requested.options, stored.options],
+                        ["startValue", spec.requested.startValue, stored.startValue],
+                        ["endValue", spec.requested.endValue, stored.endValue],
+                    ];
+                    return fields.filter(([, from]) => from !== undefined).filter(([, from, to]) => !conditionValueEqual(from, to)).map(([field, from, to]) => ({ propertyCode: spec.propertyCode, field, from, to }));
+                });
+                const equivalent = missingConditions.length === 0 && coercions.length === 0;
                 readback.conditionReadback = {
-                    status: equivalent ? "equivalent" : "listview-condition-readback-mismatch",
+                    status: equivalent ? "equivalent" : "coerced",
                     requested: requestedConditionKeys,
                     stored: [...storedKeys],
                     // Operator-level summary so "operator + value" acceptance needs no
                     // `--full`/artifact fetch (dogfood R2 round17b).
                     operators: (requestedConditionSpec ?? []).map((spec) => ({
                         propertyCode: spec.propertyCode,
-                        requested: spec.filterType ?? null,
+                        requested: spec.requested.filterType ?? spec.requested.operator ?? spec.requested.op ?? spec.normalized.filterType ?? null,
                         stored: storedByCode.get(spec.propertyCode)?.filterType ?? null,
                         defaultValue: storedByCode.get(spec.propertyCode)?.defaultValue ?? null,
                     })),
                     ...(missingConditions.length > 0 ? { missing: missingConditions } : {}),
-                    ...(filterTypeMismatches.length > 0 ? { filterTypeMismatches } : {}),
+                    ...(coercions.length > 0 ? { coercions } : {}),
                 };
             }
             readback.columnsRenderCompat = columnsRenderCompat(readArray(afterModel, "queryColumns"));

package/dist/path-projection.js

@@ -330,7 +330,7 @@ function isReceiptDerivedKey(key) {
     // `detailFile` 故意**不在此列**：它是本地文件系统路径（进程内才有效），
     // 合进投影视图会让 `--keys` 把本机路径当"结果键"吐出来（2026-11-05 回归：
     // readpath-roundtrip 1.2 的 keys 断言多了 detailFile）。对外只认 artifactId。
-    return /(?:Count|Omitted)$/.test(key) || key === "detailArtifactId" || key === "detailSha256" || key === "from" || key === "truncated" || key === "truncatedKeys" || key === "fetch" || key === "tablesHint";
+    return /(?:Count|Omitted)$/.test(key) || key === "total" || key === "detailArtifactId" || key === "detailSha256" || key === "from" || key === "truncated" || key === "truncatedKeys" || key === "fetch" || key === "tablesHint";
 }
 function mergeReceiptDerivedKeys(artifactSource, result) {
     if (artifactSource === null || typeof artifactSource !== "object" || Array.isArray(artifactSource))
@@ -438,6 +438,16 @@ export function projectResultExtract(result, paths, keysOnly) {
         ...(artifactId !== undefined ? { artifactId, sha256: artifact?.sha256 } : {}),
         from: readFromArtifact ? "artifact" : "result",
     };
+    // 投影只改变取值路径，不改变源结果的完整性事实。尤其是外置 artifact
+    // 场景，调用方仍必须能判断 items 是否被折叠，以及源侧 total/itemsCount。
+    // 只透传源中实际存在的键；未截断结果不要凭空写 truncated:false。
+    const sourceRecord = source && typeof source === "object" && !Array.isArray(source)
+        ? source
+        : undefined;
+    for (const key of ["truncated", "truncatedKeys", "itemsCount", "total"]) {
+        if (sourceRecord !== undefined && Object.prototype.hasOwnProperty.call(sourceRecord, key))
+            out[key] = sourceRecord[key];
+    }
     // T6：列表投影里「未配置的列」也是 null 键——工具自己已经写了 projectionHint
     // （#15 A6），但投影层此前把它丢了，于是 `--jq items[].fields.x` 全 null 时
     // 调用方看不到任何线索。把源结果的提示原样透传（有才带，零额外体积）。
@@ -570,6 +580,9 @@ export function projectResultExtract(result, paths, keysOnly) {
             out.rowCount = rowCount;
             // Deliberately NO top-level `content` on multi-path — that was the duplicate.
         }
+        // Keep one machine-readable shape for artifact/call consumers. `content` on
+        // the single-path branch remains as a backwards-compatible convenience.
+        out.projections = extracts;
         // A projection that missed is not an answer. `status` stays `ok` (adding a
         // new status value would fall through classifyResult to error/exit 15 and
         // change the exit contract), but the envelope now says so out loud.

package/dist/recipes/b2-registration.js

@@ -54,7 +54,7 @@ const bizserviceSelfCallCorp = Object.freeze({
         environment,
         serviceCode: "<service_code>",
         methodCode: "<method_code>",
-        inputParameters: [
+        methodInputParameters: [
             { code: "X-LowCode-Corpid", name: "corpId头", required: false, codeType: 0, bizCode: "<corpId 常量值>", configJson: { position: "REQUEST_HEADER" } },
         ],
     },

package/dist/recipes/form.js

@@ -1,10 +1,10 @@
 import { environment, model, commonRecovery } from "./shared.js";
 const configureFormRecipe = Object.freeze({
     id: "publish-default-form",
-    title: "把已发布字段绑进默认表单并发布（高层编排）",
+    title: "把已发布字段绑进默认表单（发布请随后调用 form.publish）",
     status: "offline-valid",
     tool: "configure_form",
-    args: { environment, schemaCode: model, publish: true },
+    args: { environment, schemaCode: model },
     preconditions: ["字段已 field.publish"],
     conditionalRequirements: ["表单层条件必填/只读请用 field.update 的 options（form-conditional-required / form-always-readonly recipe），不是本编排器"],
     priorToolReferences: [{ tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认字段已发布" }],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stalfh233/omc-cli",
-  "version": "0.6.13",
+  "version": "0.6.14",
   "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.13",
+    "omc-core": "0.6.14",
     "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.13"
+    "@stalfh233/omc-fake-platform": "0.6.14"
   }
 }