@stalfh233/omc-cli 0.6.12 → 0.6.14

package/dist/path-projection.js

@@ -304,6 +304,98 @@ function resultLayerNote(result, path) {
         resultLayerHint: `「${head}」在 result 顶层（只是不在 artifact 副本里）。取它请不带 --jq 直接读回执，或改取 artifact 内的键（见 available）`,
     };
 }
+/** Envelope keys of the stdout wrapper — never part of the tool result. */
+const ENVELOPE_HEAD_KEYS = new Set(["ok", "status", "result", "error", "requestId"]);
+/**
+ * r29f F1：调用方按信封写 `--jq result.applications[].code` 时首段 pathMiss。
+ * 首段恰为信封键时剥掉重试一次；成功则标 `autoStripped`，失败保持原 miss。
+ */
+function stripEnvelopeHead(path) {
+    const trimmed = path.replace(/^\$\.?/, "").replace(/^[.\/]+/, "");
+    const match = /^([A-Za-z_][\w]*)/.exec(trimmed);
+    if (match === null)
+        return { path };
+    const head = match[1];
+    if (!ENVELOPE_HEAD_KEYS.has(head))
+        return { path };
+    const rest = trimmed.slice(head.length).replace(/^[.\/]+/, "");
+    return { path: rest, stripped: head };
+}
+/**
+ * r29f F5：外置后 `--jq` 在 artifact 正文上求值，回执派生键（*Count / *Omitted /
+ * detailArtifactId / from）消失。把回执派生键合进视图：artifact 同名键优先，
+ * 回执派生键补位；保留 `from:"artifact"`。
+ */
+function isReceiptDerivedKey(key) {
+    // `detailFile` 故意**不在此列**：它是本地文件系统路径（进程内才有效），
+    // 合进投影视图会让 `--keys` 把本机路径当"结果键"吐出来（2026-11-05 回归：
+    // readpath-roundtrip 1.2 的 keys 断言多了 detailFile）。对外只认 artifactId。
+    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))
+        return artifactSource;
+    const view = { ...artifactSource };
+    for (const [key, value] of Object.entries(result)) {
+        if (!isReceiptDerivedKey(key))
+            continue;
+        if (Object.prototype.hasOwnProperty.call(view, key))
+            continue;
+        view[key] = value;
+    }
+    return view;
+}
+function projectPathOnSource(source, path) {
+    const tryOnce = (candidate) => {
+        if (candidate.includes("[]"))
+            return { projected: projectJsonPathFanout(source, candidate), fanout: true };
+        return { projected: projectJsonPath(source, candidate), fanout: false };
+    };
+    const first = tryOnce(path);
+    if (!first.projected.missed)
+        return { ...first };
+    const stripped = stripEnvelopeHead(path);
+    // r30a F7/F8: stripping `status`/`ok` down to an EMPTY path used to return
+    // the whole source object (looked like a successful answer). Keep those as
+    // pathMiss. r31c F6: `--jq result` is the one intentional alias — callers
+    // habitually mean "the whole result package", so return it with a note
+    // instead of miss-then-hint.
+    if (stripped.stripped === undefined || stripped.path === path)
+        return { ...first };
+    if (stripped.path.trim() === "") {
+        if (stripped.stripped === "result") {
+            return {
+                projected: { missed: false, value: source },
+                fanout: false,
+                autoStripped: {
+                    field: "result",
+                    reason: "--jq 的路径相对 result；写 result 等于整包",
+                },
+            };
+        }
+        return {
+            projected: {
+                missed: true,
+                at: stripped.stripped,
+                available: Array.isArray(source) || source === null || typeof source !== "object"
+                    ? `「${stripped.stripped}」是信封顶层键；投影相对 result，剥掉后路径为空——不要用 --jq ${stripped.stripped} 取信封字段`
+                    : Object.keys(source).slice(0, 12),
+            },
+            fanout: false,
+        };
+    }
+    const second = tryOnce(stripped.path);
+    if (!second.projected.missed) {
+        return {
+            ...second,
+            autoStripped: {
+                field: stripped.stripped,
+                reason: `剥掉了信封前缀「${stripped.stripped}.」；投影相对 result，请直接写 --jq ${stripped.path || "<path>"}`,
+            },
+        };
+    }
+    return { ...first };
+}
 export function projectResultExtract(result, paths, keysOnly) {
     const artifactId = typeof result.detailArtifactId === "string" ? result.detailArtifactId : typeof result.artifactId === "string" ? result.artifactId : undefined;
     // Tools hand an in-process artifact as `detailFile` (a local path);
@@ -328,17 +420,34 @@ export function projectResultExtract(result, paths, keysOnly) {
             catch {
                 source = text;
             }
+            // r29f F5：外置后投影视图 = artifact 正文 ∪ 回执派生键（artifact 优先）。
+            source = mergeReceiptDerivedKeys(source, result);
         }
     }
     catch {
         // A pruned/expired artifact must not mask the real tool answer.
         return { ...result, extract: { artifactId: artifactId ?? null, error: "artifact not found", hint: "产物已过期或被清理；去掉 --extract 重新调用该工具即可重新生成" } };
     }
+    // r30a F8: when projecting against an artifact that is a write-history record
+    // (tool/requestId/performed/…), prefer the in-memory result for keys that
+    // exist on the result but would silently resolve to a wrong-shaped value on
+    // the artifact (or miss entirely). Never fall back to "parent object".
+    const projectionSource = source;
     const out = {
         status: result.status ?? "ok",
         ...(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 时
     // 调用方看不到任何线索。把源结果的提示原样透传（有才带，零额外体积）。
@@ -374,68 +483,109 @@ export function projectResultExtract(result, paths, keysOnly) {
                     hint: unsupported,
                 };
             }
-            // `items[].fields.planNo` maps over every row; a plain path stays a single
-            // value (issue 2026-10-25 §8). Both faces share one shape so a caller can
-            // switch between `--extract`/`--jq` without relearning the envelope.
-            if (path.includes("[]")) {
-                const fanout = projectJsonPathFanout(source, path);
-                if (fanout.missed) {
-                    const didYouMean = pathMissDidYouMean(fanout.at, fanout.available);
+            // Prefer in-memory result when the path resolves there and would miss
+            // on the artifact (never silently substitute a wrong-shaped parent object).
+            const onArtifact = projectPathOnSource(projectionSource, path);
+            const onResult = readFromArtifact ? projectPathOnSource(result, path) : undefined;
+            const preferResult = onResult !== undefined && !onResult.projected.missed && onArtifact.projected.missed ? onResult : undefined;
+            const { projected, fanout, autoStripped } = preferResult ?? onArtifact;
+            if (fanout) {
+                const fan = projected;
+                if (fan.missed) {
+                    const didYouMean = pathMissDidYouMean(fan.at, fan.available);
                     return {
                         path,
                         content: null,
                         pathMiss: true,
-                        missedAt: fanout.at,
-                        available: fanout.available,
-                        missedEntries: fanout.missedEntries,
+                        missedAt: fan.at,
+                        available: fan.available,
+                        missedEntries: fan.missedEntries,
                         ...(didYouMean !== undefined ? { didYouMean } : {}),
                         ...(readFromArtifact ? resultLayerNote(result, path) ?? {} : {}),
-                        hint: missHintFor(fanout.at, fanout.available),
+                        hint: missHintFor(fan.at, fan.available),
                     };
                 }
                 return {
                     path,
-                    content: fanout.values,
-                    mapped: fanout.values.length,
-                    ...(fanout.nullEntries > 0 ? { nullEntries: fanout.nullEntries } : {}),
-                    ...(fanout.nullEntries > 0 && fanout.nullEntries === fanout.values.length ? { hint: ALL_NULL_HINT } : {}),
-                    ...(fanout.missedEntries > 0 ? { missedEntries: fanout.missedEntries, hint: `有 ${fanout.missedEntries} 条记录在该路径下缺失，values 只含命中项` } : {}),
+                    content: fan.values,
+                    mapped: fan.values.length,
+                    ...(autoStripped !== undefined ? { autoStripped } : {}),
+                    ...(preferResult ? { from: "result" } : {}),
+                    ...(fan.nullEntries > 0 ? { nullEntries: fan.nullEntries } : {}),
+                    ...(fan.nullEntries > 0 && fan.nullEntries === fan.values.length ? { hint: ALL_NULL_HINT } : {}),
+                    ...(fan.missedEntries > 0 ? { missedEntries: fan.missedEntries, hint: `有 ${fan.missedEntries} 条记录在该路径下缺失，values 只含命中项` } : {}),
                 };
             }
-            const projected = projectJsonPath(source, path);
-            if (projected.missed) {
-                // projectJsonPath 也会拦 unsupportedSyntax；双保险统一出口。
-                if (projected.unsupportedSyntax === true) {
+            const single = projected;
+            if (single.missed) {
+                if (single.unsupportedSyntax === true) {
                     return {
                         path,
                         content: null,
                         pathMiss: false,
                         unsupportedSyntax: true,
                         unanswered: true,
-                        available: projected.available,
-                        hint: typeof projected.available === "string" ? projected.available : UNSUPPORTED_JQ_OBJECT_HINT,
+                        available: single.available,
+                        hint: typeof single.available === "string" ? single.available : UNSUPPORTED_JQ_OBJECT_HINT,
                     };
                 }
-                const didYouMean = pathMissDidYouMean(projected.at, projected.available);
+                const didYouMean = pathMissDidYouMean(single.at, single.available);
                 return {
                     path,
                     content: null,
                     pathMiss: true,
-                    missedAt: projected.at,
-                    available: projected.available,
+                    missedAt: single.at,
+                    available: single.available,
                     ...(didYouMean !== undefined ? { didYouMean } : {}),
                     ...(readFromArtifact ? resultLayerNote(result, path) ?? {} : {}),
-                    hint: missHintFor(projected.at, projected.available),
+                    hint: missHintFor(single.at, single.available),
                 };
             }
-            return { path, content: projected.value ?? null };
+            return {
+                path,
+                content: single.value ?? null,
+                ...(autoStripped !== undefined ? { autoStripped } : {}),
+                ...(preferResult ? { from: "result" } : {}),
+            };
         });
-        if (paths.length === 1)
-            out.content = out.extract[0]?.content ?? null;
+        // r30a F21 / r31c F7: single path keeps top-level `content`. Multi-path used
+        // to ALSO dump a path→value `content` map that duplicated `extract[]`
+        // (probe: roles[].name + roles[].code returned twice). Keep ONE shape:
+        // extract[] for per-path detail, plus `rows` that zip parallel array
+        // projections so two columns align without a second round trip.
+        const extracts = out.extract;
+        if (paths.length === 1) {
+            out.content = extracts[0]?.content ?? null;
+        }
+        else {
+            const columns = extracts.map((entry) => ({
+                path: entry.path,
+                values: entry.pathMiss === true || entry.unsupportedSyntax === true
+                    ? []
+                    : Array.isArray(entry.content)
+                        ? entry.content
+                        : entry.content === undefined
+                            ? []
+                            : [entry.content],
+            }));
+            const rowCount = Math.max(0, ...columns.map((column) => column.values.length));
+            const rows = [];
+            for (let index = 0; index < rowCount; index += 1) {
+                const row = {};
+                for (const column of columns)
+                    row[column.path] = index < column.values.length ? column.values[index] : null;
+                rows.push(row);
+            }
+            out.rows = rows;
+            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.
-        const extracts = out.extract;
         if (extracts.some((entry) => entry.pathMiss === true || entry.unsupportedSyntax === true)) {
             out.unanswered = true;
             // 多路径：语法说明给一次，不再逐条复制。不支持语法优先于 pathMiss 语法课。
@@ -443,7 +593,7 @@ export function projectResultExtract(result, paths, keysOnly) {
                 out.hint = UNSUPPORTED_JQ_OBJECT_HINT;
             }
             else if (multiPath) {
-                out.hint = `${RESULT_RELATIVE_PATH_NOTE}${JQ_PATH_SYNTAX}${JQ_PATH_HELP_POINTER}`;
+                out.hint = `${RESULT_RELATIVE_PATH_NOTE}${JQ_PATH_SYNTAX}多路径时用 extract[]（逐条）或 rows[]（列对齐）；不再重复 content 映射。${JQ_PATH_HELP_POINTER}`;
             }
         }
     }

package/dist/read-shapes.js

@@ -12,15 +12,16 @@
 const READ_SHAPES = {
     // r28k 治理面形状钉：截断≠空表；指纹有用途；doctor/get_status 分流。
     "discover_environment": {
-        keys: ["applications:array<{code,name,groupId?,portalHidden?}>", "applicationsCount", "groups", "groupsCount", "foldersAndModels?", "foldersAndModelsCount?", "foldersAndModelsOmitted?", "models?", "modelsCount?", "modelsOmitted?", "tablesHint?", "applicationCode", "applicationResolution", "readiness", "environmentFingerprint", "fingerprintHint?", "detailArtifactId?"],
+        keys: ["applications:array<{code,name,groupId?,portalHidden?}>", "applicationsCount", "groups", "groupsCount", "foldersAndModels?", "foldersAndModelsCount?", "foldersAndModelsOmitted?", "models?", "modelsCount?", "modelsOmitted?", "tablesHint?", "applicationCode", "applicationResolution", "readiness", "detectedVersion", "inAnchorFamily", "versionSource", "versionFamily", "anchorVersion", "versionNotice?", "environmentFingerprint", "fingerprintHint?", "detailArtifactId?"],
         notes: [
             "applications/groups 内联；foldersAndModels/models 外置时是 null + *Omitted:true（不是 []）",
             "environmentFingerprint 用途见 fingerprintHint（写前漂移/计划绑定/读缓存键，非审批令牌）",
+            "detectedVersion/inAnchorFamily/versionSource 与 doctor/fingerprint 同源",
         ],
     },
     "environment.fingerprint": {
-        keys: ["environment", "fingerprint", "fingerprintHint"],
-        notes: ["fingerprint 随 env/origin/application/enterprise 变；写前漂移检测 + 计划/审计绑定"],
+        keys: ["environment", "fingerprint", "fingerprintHint", "detectedVersion", "inAnchorFamily", "versionSource", "versionFamily", "anchorVersion", "versionNotice?"],
+        notes: ["fingerprint 随 env/origin/application/enterprise 变；写前漂移/计划绑定", "版本证据与 discover/doctor 同源"],
     },
     "get_status": {
         keys: ["environment", "session", "coverage", "environmentScope", "unsupportedCapabilities?", "writeLease"],
@@ -31,8 +32,8 @@ const READ_SHAPES = {
         notes: ["unsupportedCapabilities.coverageClaimMeaning：只列已知缺口；未列 ≠ 已验证可用"],
     },
     "coverage.manifest": {
-        keys: ["manifest:{version_family,anchor_version,items[],counts?,filter?,hint?}"],
-        notes: ["按 lane 索引（同 lane 可多行）；答能力能不能用 → omc capability <id>"],
+        keys: ["manifest:{version_family,anchor_version,items[],counts?{total,totalScope,totalBeforeFilter?,byStatus},filter?,hint?}"],
+        notes: ["按 lane 索引（同 lane 可多行）；capability 参数可传能力描述名或 lane id（如 W1-list-view）；答能力能不能用 → omc capability listview"],
     },
     "apply_changes": {
         keys: ["status", "steps?", "failedStep?", "progressFile?", "deliveryState?"],
@@ -42,7 +43,21 @@ const READ_SHAPES = {
         // items are {id, fields:{<code>: value}} — business columns live under fields.
         keys: ["items:array<{id,fields:{<code>:value}}>", "total", "totalPages", "page", "size"],
         // r28i F4: agents try rows[] / items[].sku first; pin the real shape here too.
-        notes: ["业务列在 items[].fields.<code>，不在 item 顶层，也不是 rows[]（--jq items[].sku / rows[].sku 会 miss；正确：items[].fields.sku）"],
+        notes: [
+            "业务列在 items[].fields.<code>，不在 item 顶层，也不是 rows[]（--jq items[].sku / rows[].sku 会 miss；正确：items[].fields.sku）",
+            "字典字段回记录 code；显示名需 dictionary.records 映射（伴生 *_key 常为 null，勿当显示名）",
+        ],
+    },
+    "dictionary.records": {
+        keys: ["records:{totalElements,content[]}", "total", "orderNote", "enabledOnly?", "dictionaryId?", "parentId?"],
+        notes: ["enabledOnly/parentId 也走同一分页壳，不再回裸数组"],
+    },
+    "dictionary.get": {
+        keys: ["dictionary:{id,code,name,...}", "recordsCount?"],
+        notes: ["头读面不含 records 明细；条数看 recordsCount，明细走 dictionary.records"],
+    },
+    "dictionary.references": {
+        keys: ["dictionary", "references:array<{schemaCode,fieldCode,fieldName,propertyType}>", "count", "truncated", "modelsScanned"],
     },
     "folder.tree": {
         keys: ["applicationCode", "applicationExists", "nodeCount", "folderCount", "modelCount", "nodes[]", "note"],
@@ -55,12 +70,17 @@ const READ_SHAPES = {
     "data.load": {
         keys: ["bizObjectId", "exists", "data:{...}"],
     },
+    "app.list": {
+        keys: ["applications:array<{code,name,groupId?}>", "applicationsCount", "omitted"],
+        notes: ["applicationsCount + omitted 与 discover 同构；omitted:false 表示内联即全集"],
+    },
     "model.list": {
         // Compact diet may rewrite models to "code｜name" pairs and add modelsCount.
-        keys: ["models:array<code｜name>", "count", "modelsCount", "scopeHint"],
+        keys: ["models:array<{code,schemaCode,name}>", "count", "modelsCount", "applicationCode", "applicationResolution", "scopeHint"],
         notes: [
-            "下游工具的 schemaCode = 本面 models 的 code（内联 diet 后是「code｜name」里的 code）",
-            "modelsCount 是内联 result 键；若 --jq 走 artifact 副本可能 pathMiss——用 --jq count 或先看内联 result",
+            "下游工具的 schemaCode = 本面 models 的 code",
+            "applicationCode 不在 app.list → app-not-found（applicationResolution.status=unresolved）",
+            "modelsCount 等派生键外置后也可 --jq（投影层会合进 artifact 视图）",
         ],
     },
     "model.inspect": {
@@ -135,8 +155,8 @@ const READ_SHAPES = {
         notes: ["roleId 与 roleCode 二者其一；members[].id 是用户 recId"],
     },
     "org.role.userScope": {
-        keys: ["roleId", "userId", "count", "scopes:array<{id,name,type,deptPath}>"],
-        notes: ["不是枚举档位：scopes 是部门节点列表；roleId 与 roleCode 二者其一"],
+        keys: ["roleId", "userId", "count", "scopes:array<{id,deptId,name,type,deptPath,includeChildren,source}>", "actor?", "readback"],
+        notes: ["不是枚举档位：scopes 是部门节点列表；roleId 与 roleCode 二者其一；includeChildren 平台不返回（unknown）；source:configured；空结果是合法空集"],
     },
 };
 /** Lookup the authored return shape for a tool, if any. */

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/field.js

@@ -148,6 +148,20 @@ const dictionarySelection = Object.freeze({
     requiresEnvironmentDerivedIds: true,
     prerequisiteData: { source: "dictionary.names → dictionary.records(enabledOnly:true)", fields: ["dictionary.code", "record.code", "record.id"] },
 });
+const dictionaryMultiSelection = Object.freeze({
+    id: "dictionary-backed-multi-select",
+    title: "字典多选",
+    status: "requires-prior-readback",
+    tool: "field.create",
+    args: { environment, schemaCode: model, code: "tags", name: "标签", propertyType: "DROPDOWN_MULTI_BOX", options: { optionsSet: { optionsType: "dictionary", dictionary: { checkedDictionary: "<id>", checkedDictionaryCode: "<code>", useDictionariesData: [{ code: "<c>", id: "<id>" }] } } } },
+    preconditions: ["模型/字典可用"],
+    conditionalRequirements: ["optionsSet同单选；值=分号串"],
+    priorToolReferences: [],
+    dryRun: { supported: true, command: `omc call field.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "" },
+    expectedReadback: { next: ["field.publish"] },
+    refusalRecovery: commonRecovery,
+    requiresEnvironmentDerivedIds: true,
+});
 const childTable = Object.freeze({
     id: "minimal-child-table",
     title: "创建带两个标量列的子表字段",
@@ -315,8 +329,7 @@ const externalLookupModel = Object.freeze({
     conditionalRequirements: [
         "**数据段首选（平台标准模式，2026-10-29 playwright 门户实证定案）**：映射模型的 GetList/Load 规则挂 BIZ_ACTION 实时调接口（接口方法配 frontEndExtensionEnable:true）——门户关联控件**打开即触发**前端查询链→GetList 规则→BIZ_ACTION 实时调外部接口（引擎日志 bizBusService.invoke + 外部网关日志双侧铁证）。**验证必须走门户填表；data.list 后端查询不反映此链，别用它判死**（r29 曾据此误判不成立）。配置侧三个收尾点：① WORK_SHEET 字段必须带 relativeCode（仅 options.schemaCode 发布表单会 301015 关联业务模型为空）；② GetList 规则的 BIZ_ACTION 入参映射要接前端搜索词（实测未配词时 invoke 参数为空 {}）；③ 出参→列表行的映射配完候选才回显（未配时弹窗 Total 0 但接口已调）。「下拉框形态（输关键字回车查询）」是表单 attributes 层的控件形态设置，默认弹窗形态。备选（不需要实时时）：预置 Create/Update 规则落映射表 / TIMING 定时同步。图内「BIZ_ACTION→CREATE 落表→再查」回环在 1.1.25 不可表达，不要走这条岔路。",
         "**表单段是平台原生能力**：关联单选指向映射模型后，门户上输入关键字回车即查映射表、选中即 mappings 带出——前台填表时映射自然出现，无需按钮/脚本。",
-        "下拉框形态（输入关键字回车查询而非弹窗选择）在表单 attributes 层配置（form.draft 改控件形态），不在字段 options。",
-        "映射模型表要有数据下拉才有选项——空表=空下拉；数据段先通再配表单段。",
+        "下拉框形态在 form.draft 控件层配置；映射表要有数据下拉才有选项。",
     ],
     priorToolReferences: [
         { tool: "model.create", args: { environment }, purpose: "建映射模型（字段与接口返回一一对应）" },
@@ -333,6 +346,6 @@ const externalLookupModel = Object.freeze({
 });
 export const FIELD_METADATA = Object.freeze({
     "field.update": Object.freeze({ recipes: [fieldSerialNumber, formConditionalRequired, formAlwaysReadonly, formConditionalReadonly], relatedTools: ["field.list", "field.publish", "form.draft", "form.publish"] }),
-    "field.create": Object.freeze({ recipes: [numericTwoDecimals, dictionarySelection, childTable, businessModelDropdown, formulaAggregationCrossModel, externalLookupModel], relatedTools: ["dictionary.names", "dictionary.records", "discover_environment", "field.list", "field.publish", "form.draft", "configure_form", "form.publish"] }),
+    "field.create": Object.freeze({ recipes: [numericTwoDecimals, dictionarySelection, dictionaryMultiSelection, childTable, businessModelDropdown, formulaAggregationCrossModel, externalLookupModel], relatedTools: ["dictionary.names", "dictionary.records", "discover_environment", "field.list", "field.publish", "form.draft", "configure_form", "form.publish"] }),
 });
 //# sourceMappingURL=field.js.map

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: "确认字段已发布" }],
@@ -36,7 +36,7 @@ const formDraftTwoColumn = Object.freeze({
         draftViewJson: '[[\"visitNo\",\"customer\"],[\"remark\"]]',
         draftAttributesJson: JSON.stringify({
             visitNo: { key: "visitNo", type: 1, options: { name: "拜访单号", span: 12 } },
-            customer: { key: "customer", type: 1, options: { name: "客户", span: 12 } },
+            customer: { key: "customer", type: 9, options: { name: "客户", span: 12 } },
             remark: { key: "remark", type: 1, options: { name: "备注", span: 24 } },
         }, null, 0),
     },
@@ -44,6 +44,7 @@ const formDraftTwoColumn = Object.freeze({
     conditionalRequirements: [
         "**列数由行分组决定，不由 span 决定**：一行放几个 code 就是几列；span 只控制控件在行内的 24 栅格宽度，且必须与行分组自洽（两列 span:12+12，整宽 span:24）",
         "draftAttributesJson 的每个控件的 `options` 必须是**对象**，不能是 JSON 字符串（否则运行时写 options.name_i18n 抛错、整页空白）",
+        "控件 type 与 field propertyType 数字同源（WORK_SHEET=9）",
         "rows 与 attrs 的 code 集合必须一致，否则 `layout_coverage_mismatch`",
         "改列数就改行分组、重写 attrs 的 span —— 不要只改 span",
     ],

package/dist/recipes/runtime-data.js

@@ -76,6 +76,7 @@ const dataListFilter = Object.freeze({
     conditionalRequirements: [
         "filter 是**一个**子句 `{op, field, value?}`；op ∈ eq/neq/gt/lt/gte/lte/like/notlike/in/notin/between/notbetween/isnull/isnotnull（camelCase 别名 equals/notEquals/contains/isNull/isNotNull 等价——r36 体检发现别名合法但只列规范名会被误判『静默接受坏 op』）。",
         "多条件 `filters:[…]`（AND）；分组 `filterGroup:{op:'and'|'or',clauses:[…]}`；系统/外部字段用 rawCondition。",
+        "列投影：`fields` / `displayFields` / `columns` 三名同义（与 data.load 的 fields 对齐）。",
     ],
     priorToolReferences: [
         { tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认要过滤的字段 code 已发布" },
@@ -85,30 +86,79 @@ const dataListFilter = Object.freeze({
     refusalRecovery: [{ code: "invalid-filter-DSL", action: "按错误里的 minimalValidFilter/acceptedOps 修正 op/field/value" }],
     requiresEnvironmentDerivedIds: false,
 });
+const childRowsUpsert = Object.freeze({
+    id: "child-rows-upsert",
+    title: "子表三合一：改既有行 / 追加 / 显式删除",
+    status: "offline-valid",
+    tool: "data.update",
+    args: {
+        environment,
+        schemaCode: model,
+        bizObjectId: "<data.load 的 id>",
+        formData: {
+            items: [
+                { id: "<既有行 id>", qty: 2, price: 10, amount: 20 },
+                { sku: "NEW", qty: 1, price: 5, amount: 5, rowStatus: "Added" },
+                { id: "<要删的行 id>", rowStatus: "Deleted" },
+            ],
+        },
+    },
+    preconditions: ["data.load 拿子行 id"],
+    conditionalRequirements: [
+        "既有行带 id（省 id 当新增）；追加 rowStatus:Added；删除 {id,rowStatus:Deleted}；**少传行不删除**（readback.warnings: child-rows-not-deleted）",
+    ],
+    priorToolReferences: [
+        { tool: "data.load", args: { environment, schemaCode: model, bizObjectId: "<id>" }, purpose: "取子行 id" },
+    ],
+    dryRun: { supported: true, command: `omc call data.update --env ${environment} --dry-run --args '<recipe.args>'`, notes: "校验子行形状" },
+    expectedReadback: { readback: { authoritative: "子表行按 Added/Modified/Deleted 落地" } },
+    refusalRecovery: [
+        { code: "child-rows-missing-id", action: "无 id 的行补 id 或改 rowStatus:Added" },
+    ],
+    notes: "data.save 新建时子行可不带 id（工具 stamp Added）；本配方指 update/既有记录",
+    requiresEnvironmentDerivedIds: true,
+});
 const dataDeleteSweep = Object.freeze({
     id: "sweep-all-readback",
-    title: "清空模型数据并权威验证（list 取 ids → delete → 复验 total:0）",
+    title: "清空模型数据并权威验证（list 取 ids → 逐条 delete → 逐条 load 确认 absent）",
     status: "offline-valid",
     tool: "data.delete",
-    args: { environment, schemaCode: model, bizObjectIds: ["<data.list 逐条 id>"] },
+    // 1.1.x 上 bizObjectIds:[多个] 是假成功（blocker:data-delete-batch-fake-success）。
+    // recipe.args 给单条形状；多条用 dryRun.command 的 --args-list 一次跑完。
+    args: { environment, schemaCode: model, bizObjectId: "<data.list 一条 id>" },
     preconditions: [
         "先 data.list 取全量 ids（`all:true` 才含 DRAFT；翻页取全），清理对象按 data.list 全量",
         "**行数以 data.list total 为准，别按「N 提交=2N 行」外推**：带流程的 submit 原地推进同一行（r28b 实测 3→3）；双行只在平台另起草稿行时出现（r30 的 5→10）",
     ],
     conditionalRequirements: [
-        "参数名是 `bizObjectIds`（数组）——不是 ids/bizObjectId（单条删除另有其参）",
+        "1.1.x 上批量 `bizObjectIds` 是假成功（回执 DELIVERED+absent:true 但行仍在），必须单条 `bizObjectId`；用 `--args-list` 一次跑多条单删，不要抄 `bizObjectIds:[多个]`",
+        "删完逐条 `data.load` 确认 `exists:false`（`absent:true` / `modelResidue.total` 递减都不是删除成功的证明）；最后再 `data.list` 复验 total:0",
         "id 已被删时幂等 no-op，重复清理安全",
     ],
     priorToolReferences: [
-        { tool: "data.list", args: { environment, schemaCode: model }, purpose: "取全量 bizObjectIds（含 DRAFT 行）" },
+        { tool: "data.list", args: { environment, schemaCode: model }, purpose: "取全量 ids（含 DRAFT 行），再拆成逐条 bizObjectId" },
+    ],
+    dryRun: {
+        supported: true,
+        command: `omc call data.delete --env ${environment} --args-list '[{"schemaCode":"${model}","bizObjectId":"<id1>"},{"schemaCode":"${model}","bizObjectId":"<id2>"}]'`,
+        notes: "多条用 --args-list 逐条单删（每条一个 bizObjectId）；不要用 bizObjectIds 数组。dry-run 可加 --dry-run 预检不落库",
+    },
+    expectedReadback: {
+        readback: { deleted: true, exists: false },
+        next: [
+            "对每条 id：omc call data.load --args '{\"schemaCode\":\"…\",\"bizObjectId\":\"<id>\"}' 确认 exists:false",
+            "最后 data.list 复验 total:0 / items:[]（权威清空判据）",
+        ],
+    },
+    refusalRecovery: [
+        { code: "data-delete-batch-fake-success", action: "改用单条 bizObjectId，或 --args-list 一次跑多条单删；不要再传 bizObjectIds:[多个]" },
+        { code: "wire-business", action: "模型须已创建且有已发布字段；运行面 50000 时先 model.inspect modelPresent 判存在" },
     ],
-    dryRun: { supported: true, command: `omc call data.delete --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 出删除计划不落库" },
-    expectedReadback: { readback: { deleted: "N", modelResidue: { total: 0 } }, next: ["data.list 复验 total:0 / items:[]（权威清空判据）"] },
-    refusalRecovery: [{ code: "wire-business", action: "模型须已创建且有已发布字段；运行面 50000 时先 model.inspect modelPresent 判存在" }],
     requiresEnvironmentDerivedIds: false,
 });
 export const RUNTIME_DATA_METADATA = Object.freeze({
-    "data.save": Object.freeze({ recipes: [workflowSave], relatedTools: ["workflow.get_published", "data.submit", "workitem.list"] }),
+    "data.save": Object.freeze({ recipes: [workflowSave], relatedTools: ["workflow.get_published", "data.submit", "workitem.list", "data.update"] }),
+    "data.update": Object.freeze({ recipes: [childRowsUpsert], relatedTools: ["data.load", "data.save", "data.submit"] }),
     "data.submit": Object.freeze({ recipes: [plainSubmit, workflowSubmit], relatedTools: ["data.save", "workitem.list", "data.load"] }),
     "data.list": Object.freeze({ recipes: [dataListFilter], relatedTools: ["data.load", "data.delete", "listview.configure", "field.list"] }),
     "data.delete": Object.freeze({ recipes: [dataDeleteSweep], relatedTools: ["data.list", "data.load", "data.submit"] }),