@stalfh233/omc-cli 0.4.75 → 0.4.77

package/dist/lanes/list-view.js

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { z } from "zod";
 import { ENDPOINTS } from "../endpoints.js";
 import { capabilityArg, environmentArg } from "../args.js";
@@ -195,6 +196,50 @@ export function filterDefaultSystemColumns(columns, hideDefaultSystemFields) {
         return [...columns];
     return columns.filter((column) => typeof column.propertyCode !== "string" || !SYSTEM_FIELD_CODES.has(column.propertyCode));
 }
+/**
+ * Decode a BizButtonModel row's `actionConfig` (stored as a JSON STRING) and
+ * pull out the script source. Everything else is passed through so the caller
+ * can see bindAction/targetCode without a second read.
+ */
+export function decodeButtonScript(input) {
+    const button = (input ?? {});
+    const rawConfig = button.actionConfig;
+    let parsed;
+    if (typeof rawConfig === "string" && rawConfig.trim() !== "") {
+        try {
+            const value = JSON.parse(rawConfig);
+            if (value !== null && typeof value === "object" && !Array.isArray(value))
+                parsed = value;
+        }
+        catch {
+            parsed = undefined;
+        }
+    }
+    else if (rawConfig !== null && typeof rawConfig === "object" && !Array.isArray(rawConfig)) {
+        parsed = rawConfig;
+    }
+    const script = typeof parsed?.scriptData === "string" ? parsed.scriptData : undefined;
+    return {
+        code: button.code ?? null,
+        name: button.name ?? null,
+        useLocation: button.useLocation ?? null,
+        bindAction: button.bindAction ?? null,
+        operateType: button.operateType ?? null,
+        targetCode: button.targetCode ?? null,
+        ...(script !== undefined
+            ? {
+                scriptData: script,
+                scriptBytes: Buffer.byteLength(script, "utf8"),
+                scriptSha256: createHash("sha256").update(script, "utf8").digest("hex"),
+            }
+            : {
+                scriptAbsent: typeof rawConfig === "string" && rawConfig.trim() !== "" && parsed === undefined
+                    ? "actionConfig 不是合法 JSON"
+                    : "该按钮没有 scriptData（非 SCRIPT 按钮，或脚本未配置）",
+            }),
+        ...(parsed !== undefined ? { actionConfig: parsed } : {}),
+    };
+}
 export function registerListViewLane(tools) {
     tools.push(defineTool({
         name: "listview.get",
@@ -208,6 +253,8 @@ export function registerListViewLane(tools) {
             schemaCode: z.string().min(1),
             code: z.string().optional().describe("视图 code；省略时用默认视图（=schemaCode）"),
             full: z.boolean().optional().describe("返回 query/get 原始报文（大体积）；默认返回列/排序/条件/动作/按钮的紧凑清单"),
+            buttons: z.boolean().optional().describe("附带按钮明细（code/name/useLocation/bindAction/targetCode + SCRIPT 按钮的 scriptData 原文、actionConfig 解析结果）。按钮脚本存在 h_biz_button.actionConfig.scriptData，不必再翻 artifact"),
+            buttonCode: z.string().min(1).optional().describe("只返回这一个按钮的脚本（与 buttons 同效但更省输出）；不存在时报 button-absent 并列出可用 code"),
             capability: capabilityArg,
         },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
@@ -255,6 +302,27 @@ export function registerListViewLane(tools) {
                 conditions,
                 actionCodes: readArray(model, "queryActions").map((action) => action.actionCode).filter((value) => value !== undefined),
                 buttonCount: readArray(model, "customButtons").length,
+                // Button scripts live in h_biz_button.actionConfig (a JSON STRING)
+                // whose `scriptData` holds the source for bindAction=SCRIPT. Surfacing
+                // them here removes the "listview.get → artifact → JSON.parse →
+                // JSON.parse" chain for a plain script inspection.
+                ...(() => {
+                    if (args.buttons !== true && args.buttonCode === undefined)
+                        return {};
+                    const rows = readArray(model, "customButtons");
+                    const decoded = rows.map((button) => decodeButtonScript(button));
+                    if (args.buttonCode !== undefined) {
+                        const hit = decoded.find((button) => button.code === args.buttonCode);
+                        if (!hit)
+                            return {
+                                buttonAbsent: args.buttonCode,
+                                availableButtonCodes: decoded.map((button) => button.code),
+                                buttonHint: `视图 ${code} 没有按钮 ${args.buttonCode}；可用：${decoded.map((button) => button.code).join("、") || "（无）"}`,
+                            };
+                        return { button: hit };
+                    }
+                    return { buttons: decoded };
+                })(),
                 options: model.options !== undefined && model.options !== null ? parseConditionOptions(model.options) : null,
                 // Round 16 (bench65 feedback): the query row's `published=false` is NOT
                 // an "inactive view" signal — a list view has no draft/publish
@@ -264,6 +332,10 @@ export function registerListViewLane(tools) {
             };
         }),
     }));
+    /**
+     * Decode a BizButtonModel row's `actionConfig` (stored as a JSON STRING) and
+     * pull out the script source. Everything else is passed through so the caller
+    
     /** Reverse enum map: the wire stores numeric queryActionType, the tool arg takes the enum name. */
     const QUERY_ACTION_TYPE_NAME = new Map(Object.entries(QUERY_ACTION_TYPE.index).map(([name, index]) => [index, name]));
     /**
@@ -402,6 +474,10 @@ export function registerListViewLane(tools) {
             .array(listViewButtonArg)
             .optional()
             .describe("customButtons; sent as the customButtonJson JSON array string; omitted leaves the existing buttons untouched, provided replaces every button under the QUERY trigger (schema + child tables)"),
+        buttonScripts: z
+            .array(z.object({ code: z.string().min(1), script: z.string() }))
+            .optional()
+            .describe("直接改按钮脚本：按 code 把 actionConfig.scriptData 换成 script（不改其它按钮/字段）。内部读回现有按钮再回写，因此不必先 listview.get 再整表重发；与 buttons 互斥"),
         options: listViewOptionsArg.optional(),
         presentationType: presentationTypeArg.optional(),
         gantt: listViewGanttArg.optional(),
@@ -513,7 +589,50 @@ export function registerListViewLane(tools) {
         // expanded into the authoritative actionConfig shape from readback
         // BEFORE normalizeButtons (targetCode/targetObjCode never emitted for
         // ADD_DATA/FORM — measured ineffective, see dry-lint).
-        if (args.buttons !== undefined) {
+        if (args.buttons !== undefined && args.buttonScripts !== undefined)
+            throw new ToolRefusalError({ status: "refused", blocker: "listview-buttons-ambiguous", message: "buttons 与 buttonScripts 互斥：整表重配用 buttons，只改脚本用 buttonScripts" });
+        if (args.buttonScripts !== undefined) {
+            // Patch ONE field of ONE button in place: read the stored rows, rewrite
+            // actionConfig.scriptData by code, and send the full list back. This is
+            // the write counterpart of `listview.get --buttons`.
+            const existing = readArray(model, "customButtons");
+            if (existing.length === 0)
+                throw new ToolRefusalError({ status: "refused", blocker: "listview-button-absent", schemaCode: args.schemaCode, message: `视图 ${code} 没有自定义按钮——先用 listview.configure 的 buttons 建按钮（bindAction:SCRIPT）` });
+            const byCode = new Map(existing.map((button) => [String(button.code ?? ""), button]));
+            const missing = args.buttonScripts.map((entry) => entry.code).filter((buttonCode) => !byCode.has(buttonCode));
+            if (missing.length > 0)
+                throw new ToolRefusalError({
+                    status: "refused",
+                    blocker: "listview-button-absent",
+                    schemaCode: args.schemaCode,
+                    buttonCodes: missing,
+                    available: existing.map((button) => String(button.code ?? "")),
+                    message: `视图 ${code} 没有按钮 ${missing.join("、")}；可用：${existing.map((button) => String(button.code ?? "")).join("、")}`,
+                });
+            const patched = existing.map((button) => {
+                const entry = args.buttonScripts.find((candidate) => candidate.code === String(button.code ?? ""));
+                if (!entry)
+                    return button;
+                const rawConfig = button.actionConfig;
+                let config = {};
+                if (typeof rawConfig === "string" && rawConfig.trim() !== "") {
+                    try {
+                        const parsed = JSON.parse(rawConfig);
+                        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed))
+                            config = parsed;
+                    }
+                    catch {
+                        config = {};
+                    }
+                }
+                else if (rawConfig !== null && typeof rawConfig === "object" && !Array.isArray(rawConfig)) {
+                    config = { ...rawConfig };
+                }
+                return { ...button, actionConfig: encodeJsonColumn({ ...config, scriptData: entry.script }) };
+            });
+            body.customButtonJson = JSON.stringify(normalizeButtons(patched, args.schemaCode, code));
+        }
+        else if (args.buttons !== undefined) {
             const expandedButtons = await expandButtonActionConfigs(session, args.schemaCode, args.buttons);
             body.customButtonJson = JSON.stringify(normalizeButtons(expandedButtons, args.schemaCode, code));
         }
@@ -628,6 +747,12 @@ export function registerListViewLane(tools) {
             readback.buttons = buttons
                 .map(decodeButtonRow)
                 .sort((a, b) => Number(a.sortKey ?? 0) - Number(b.sortKey ?? 0));
+            if (args.buttonScripts !== undefined) {
+                const decoded = buttons.map((button) => decodeButtonScript(button));
+                readback.buttonScripts = decoded
+                    .filter((button) => (args.buttonScripts ?? []).some((entry) => entry.code === button.code))
+                    .map((button) => ({ code: button.code, bindAction: button.bindAction, scriptBytes: button.scriptBytes ?? 0, scriptSha256: button.scriptSha256 ?? null, scriptData: button.scriptData ?? null }));
+            }
             readback.buttonsRenderCompat = buttonsRenderCompat(buttons);
         }
         if (afterModel.options !== undefined && afterModel.options !== null) {

package/dist/lanes/model-contract.js

@@ -126,6 +126,10 @@ export const MODEL_LANE_CONTRACT = Object.freeze({
             scope: MODEL_SCOPE,
             description: "Set the model's data title / 数据标题 (POST bizmodels/update_summary {schemaCode, summary}) — the fallback display of relation fields and the portal list title. The platform stores `Summary[]` JSON and runtime resolution runs JsonUtility.toList(summaryExpression, Summary.class) (BizObjectTitleSetter :140-160); Summary is {int isDataItem (1=表单字段, 2=查询字段), String code, String param}. The tool normalizes: canonical Summary[] JSON is validated/re-serialized, a PURE {field} placeholder template is converted to [{isDataItem:1,code}], and anything else (literal text, malformed JSON) refuses `model-summary-invalid` — a raw template stored verbatim poisoned the model so ALL later data.save/data.submit answered a bare 50000 (live-verified). Readback is the sibling GET bizmodels/get_summary face; it warns when the STORED value is not a valid Summary[]. Empty summary refuses `model-summary-empty`; a missing schema answers 300014 数据模型未发布.",
         }),
+        "model.move": Object.freeze({
+            scope: "move a model's app-tree node to another folder (bizmodels/update parentId)",
+            description: "把模型移动到指定应用目录（分组）：复用 `POST bizmodels/update`，只把 `parentId` 换成目标目录节点 id（AppFunctionController 补丁语义：bizSchemaCode/id/name/parentId 全量必填，工具从应用树解析）。`folderId` 必须是 `folder.tree` 里 type=Folder 的 **id**，给目录名会 `folder-not-found` 并列出可用目录。移动只改菜单节点归属：schema/字段/表单/视图/发布状态不动。回读用应用树按 `parentId` 核对（`moved:true`）。",
+        }),
         "model.update": Object.freeze({
             scope: MODEL_SCOPE,
             description: "Rename a model's app-tree node (POST bizmodels/update with AppFunctionVO; source-pinned BizSchemaController.update:266-305 — bizSchemaCode, id=<AppFunction node id>, name, parentId are ALL validateNotEmpty-required; the tool resolves id/parentId from the app tree). The endpoint patches the MENU NODE only: the underlying schema is fixed at create (modelType refused `model-type-immutable`; get_all keeps the original type/name — the authoritative rename readback is the tree node, recordName reported informationally). Absent tree node refuses `model-update-target-absent`; an empty patch refuses `model-update-empty-patch` (data title belongs to model.setSummary).",
@@ -145,6 +149,7 @@ export function assertModelContract() {
         throw new Error("model contract must require per-step authoritative readbacks");
     assertDescriptionCarries(MODEL_LANE_CONTRACT, "model.deleteMany", ["physically_delete", "List<AppDeleteParamVO>", "blockedTargets", "wait-and-recheck"]);
     assertDescriptionCarries(MODEL_LANE_CONTRACT, "model.setSummary", ["update_summary", "get_summary", "数据标题", "300014", "model-summary-empty", "model-summary-invalid", "Summary[]"]);
+    assertDescriptionCarries(MODEL_LANE_CONTRACT, "model.move", ["bizmodels/update", "parentId", "folder.tree", "folder-not-found", "moved"]);
     assertDescriptionCarries(MODEL_LANE_CONTRACT, "model.update", ["bizmodels/update", "get_all", "model-type-immutable", "model-update-target-absent", "model-update-empty-patch"]);
     if (!MODEL_WIRE.summaryWire.includes("validateNotEmpty"))
         throw new Error("model contract must carry the update_summary validateNotEmpty fact");

package/dist/lanes/model-coverage.js

@@ -8,6 +8,7 @@ export const MODEL_COVERAGE = declareLaneCoverage(MODEL_LANE_CONTRACT.lane, [
         tools: [
             claim("model.create", T["model.create"].scope),
             claim("model.update", T["model.update"].scope),
+            claim("model.move", T["model.move"].scope),
             claim("model.delete", T["model.delete"].scope),
             claim("model.deleteMany", T["model.deleteMany"].scope),
             claim("model.setSummary", T["model.setSummary"].scope),

package/dist/lanes/model.js

@@ -42,6 +42,8 @@ function modelRollbackSpec(toolName) {
             const snapshot = before;
             if (toolName === "model.update")
                 return { kind: "calls", calls: snapshot.node?.name === undefined ? [] : [{ tool: "model.update", args: { schemaCode: code, name: String(snapshot.node.name) } }] };
+            if (toolName === "model.move")
+                return { kind: "calls", calls: snapshot.node?.parentId === undefined ? [] : [{ tool: "model.move", args: { schemaCode: code, folderId: String(snapshot.node.parentId) } }] };
             return { kind: "calls", calls: [{ tool: "model.create", args: { code, name: String(snapshot.node?.name ?? snapshot.record?.name ?? code) } }], notes: ["字段/表单/视图不随行恢复，需重建"] };
         },
     };
@@ -812,6 +814,73 @@ export function registerModelLane(tools) {
                 message: "模型类型在创建时固化——bizmodels/update 只更新应用菜单节点显示，不能把底层 schema 从 LIST 迁移为 TREE（get_all 仍返回原类型与树系统字段，live 取证）。要树模型请建新模型",
             });
     }, undefined, modelRollbackSpec("model.update"));
+    writeTool(tools, "model.move", MODEL_LANE, "move a model's app-tree node to another folder (bizmodels/update parentId)", "把模型移动到指定应用目录（分组）：`POST bizmodels/update` 的 `parentId`（与 model.update 同一端点，AppFunctionController 补丁语义：bizSchemaCode/id/name/parentId 全量必填，工具从应用树解析）。`folderId` 必须是目录节点 id（`folder.tree` 的 id），**不能直接给目录名**——重名目录会定位错。移动后按应用树回读 `parentId/path` 确认；模型的 schema、字段、表单、视图都不动，只换菜单节点归属。目标目录不存在时拒绝 `folder-not-found` 并列出目录树。", {
+        schemaCode: z.string().min(1),
+        folderId: z.string().min(1).describe("目标目录 id（folder.tree 的 id）；顶层目录也是真实 id，不要传空"),
+        applicationCode: z.string().optional().describe("模型所在应用 code（跨应用时显式给）"),
+    }, async (session, args) => {
+        const resolved = await resolveModelTreeNode(session, args.schemaCode, args.applicationCode);
+        if (!resolved.node)
+            throw new ToolRefusalError({
+                status: "refused",
+                blocker: "model-update-target-absent",
+                schemaCode: args.schemaCode,
+                message: `模型 ${args.schemaCode} 无应用树节点——确认 schemaCode/应用 code（model.move 只改 AppFunction 节点归属）`,
+            });
+        const appCode = resolved.applicationCode;
+        const tree = resolved.treeRows.length > 0 ? resolved.treeRows : flattenTreeRows(wireRows((await wireCall(session, { path: ENDPOINTS.applicationTree, query: { appCode } })).data));
+        const target = tree.find((row) => String(row.id ?? "") === args.folderId);
+        if (!target || String(target.type ?? "") !== "Folder") {
+            // A folder from ANOTHER application is the common miss (the model and
+            // the folder must live in the same app tree). Name that instead of a
+            // bare "not found".
+            const apps = wireRows((await wireCall(session, { path: ENDPOINTS.applicationList, query: {} })).data);
+            let otherApp;
+            for (const app of apps) {
+                const candidate = String(app.appCode ?? app.code ?? "");
+                if (!candidate || candidate === appCode)
+                    continue;
+                const rows = flattenTreeRows(wireRows((await wireCall(session, { path: ENDPOINTS.applicationTree, query: { appCode: candidate } })).data));
+                if (rows.some((row) => String(row.id ?? "") === args.folderId && String(row.type ?? "") === "Folder")) {
+                    otherApp = candidate;
+                    break;
+                }
+            }
+            throw new ToolRefusalError({
+                status: "refused",
+                blocker: otherApp ? "folder-other-application" : "folder-not-found",
+                folderId: args.folderId,
+                applicationCode: appCode,
+                ...(otherApp ? { folderApplicationCode: otherApp } : {}),
+                available: tree.filter((row) => row.type === "Folder").map((row) => ({ id: row.id, name: row.name })).slice(0, 40),
+                message: otherApp
+                    ? `目录 ${args.folderId} 属于应用 ${otherApp}，而模型 ${args.schemaCode} 在应用 ${appCode}——模型的目录必须同应用；跨应用请先在 ${appCode} 建同名目录再移动`
+                    : `应用 ${appCode} 没有目录 ${args.folderId}——folderId 必须用 folder.tree 的目录节点 id（不是目录名）`,
+            });
+        }
+        const node = resolved.node;
+        const nodeId = String(node.id ?? "");
+        const beforeParent = String(node.parentId ?? "");
+        const performed = await wireCall(session, {
+            path: ENDPOINTS.modelUpdate,
+            method: "POST",
+            body: { bizSchemaCode: args.schemaCode, id: nodeId, parentId: args.folderId, name: String(node.name ?? args.schemaCode) },
+        });
+        const after = await resolveModelTreeNode(session, args.schemaCode, appCode);
+        const parentNow = String(after.node?.parentId ?? "");
+        return {
+            performed: { errcode: performed.errcode },
+            readback: {
+                schemaCode: args.schemaCode,
+                applicationCode: appCode,
+                moved: parentNow === args.folderId,
+                beforeParentId: beforeParent,
+                afterParentId: parentNow || null,
+                folder: { id: args.folderId, name: target.name ?? null },
+                note: "只改菜单节点归属；schema/字段/表单/视图与发布状态都不动",
+            },
+        };
+    }, undefined, undefined, modelRollbackSpec("model.move"));
     registerPackageTool(tools, {
         name: "configure_model",
         lane: MODEL_LANE,

package/dist/path-projection.js

@@ -0,0 +1,129 @@
+import { readFileSync } from "node:fs";
+import { readArtifact } from "./artifacts.js";
+import { artifactRoot } from "./command-transport.js";
+export function projectJsonPath(value, path) {
+    // 1.5 of issue 2026-10-23: an array-of-objects selection WITHOUT jq pipes.
+    // `.rules[code=Create]` (or `[code="Create"]`) picks the FIRST element whose
+    // key matches — exactly the shape callers reached for with
+    // `jq '.[] | select(...)'`, which then died on shell quoting.
+    const selector = /\[\s*([A-Za-z_][\w.]*)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\]]*?))\s*\]/.exec(path);
+    if (selector !== null) {
+        const [, key, dq, sq, bare] = selector;
+        const expected = String(dq ?? sq ?? bare ?? "").trim();
+        const before = path.slice(0, selector.index);
+        const after = path.slice(selector.index + selector[0].length);
+        const base = projectJsonPath(value, before);
+        if (base.missed)
+            return base;
+        const array = base.value;
+        if (!Array.isArray(array))
+            return { missed: true, at: before || "$", available: `该层不是数组（是 ${array === null ? "null" : typeof array}）；选择器 [${key}=${expected}] 需要数组` };
+        const readKey = (entry) => (entry !== null && typeof entry === "object" ? String(entry[key] ?? "") : "");
+        const index = array.findIndex((entry) => readKey(entry) === expected);
+        if (index < 0)
+            return { missed: true, at: `${before}[${key}=${expected}]`, available: `数组长度 ${array.length}；${key} 的候选值：${[...new Set(array.map(readKey))].slice(0, 12).join("、") || "（无）"}` };
+        return after === "" ? { missed: false, value: array[index] } : projectJsonPath(array[index], after);
+    }
+    const normalized = path
+        .trim()
+        .replace(/^[.\/]+/, "")
+        .replace(/\[(\d+)\]/g, ".$1")
+        .replace(/\[(?:"([^"]+)"|'([^']+)')\]/g, (_all, dq, sq) => `.${dq || sq}`)
+        .replace(/\.{2,}/g, ".");
+    const segments = normalized.split(/[./]/).filter((segment) => segment.length > 0);
+    let current = value;
+    for (const segment of segments) {
+        if (Array.isArray(current)) {
+            const index = Number(segment);
+            if (!Number.isInteger(index) || index < 0 || index >= current.length)
+                return { missed: true, at: segment, available: `数组长度 ${current.length}（下标 0-${Math.max(current.length - 1, 0)}）` };
+            current = current[index];
+        }
+        else if (current && typeof current === "object") {
+            const record = current;
+            if (!Object.prototype.hasOwnProperty.call(record, segment)) {
+                const keys = Object.keys(record);
+                return { missed: true, at: segment, available: keys.length > 0 ? keys.slice(0, 12) : "（该层是空对象）" };
+            }
+            current = record[segment];
+        }
+        else {
+            return { missed: true, at: segment, available: `路径在第 ${segments.indexOf(segment) + 1} 段之前已到标量/undefined（前段类型 ${current === null ? "null" : typeof current}）` };
+        }
+    }
+    return { missed: false, value: current };
+}
+/** Collect every value of a repeatable flag (`--extract a --extract b`). */
+function argvValues(args, name) {
+    const values = [];
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] !== name)
+            continue;
+        const value = args[index + 1];
+        if (value !== undefined && !value.startsWith("--"))
+            values.push(value);
+    }
+    return values;
+}
+/**
+ * `call --extract/--extract-keys`: resolve paths inside the result's own
+ * artifact (or inside the result object when the tool returned no artifact).
+ * Returns undefined when there is nothing to project so the caller's result is
+ * emitted unchanged.
+ */
+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);
+    // command-transport later swaps it for detailArtifactId. Extraction runs
+    // BEFORE that swap, so accept both.
+    const detailFile = typeof result.detailFile === "string" ? result.detailFile : undefined;
+    let source = result;
+    let artifact;
+    let readFromArtifact = false;
+    try {
+        const content = artifactId !== undefined
+            ? (artifact = readArtifact(artifactRoot(), artifactId)).content
+            : detailFile !== undefined
+                ? readFileSync(detailFile)
+                : undefined;
+        if (content !== undefined) {
+            readFromArtifact = true;
+            const text = content.toString("utf8");
+            try {
+                source = JSON.parse(text);
+            }
+            catch {
+                source = text;
+            }
+        }
+    }
+    catch {
+        // A pruned/expired artifact must not mask the real tool answer.
+        return { ...result, extract: { artifactId: artifactId ?? null, error: "artifact not found", hint: "产物已过期或被清理；去掉 --extract 重新调用该工具即可重新生成" } };
+    }
+    const out = {
+        status: result.status ?? "ok",
+        ...(artifactId !== undefined ? { artifactId, sha256: artifact?.sha256 } : {}),
+        from: readFromArtifact ? "artifact" : "result",
+    };
+    if (keysOnly) {
+        const record = source && typeof source === "object" && !Array.isArray(source) ? source : undefined;
+        out.keys = record
+            ? Object.entries(record)
+                .map(([key, value]) => ({ key, bytes: Buffer.byteLength(JSON.stringify(value) ?? "null", "utf8"), kind: Array.isArray(value) ? `array[${value.length}]` : value === null ? "null" : typeof value }))
+                .sort((left, right) => right.bytes - left.bytes)
+            : [];
+    }
+    if (paths.length > 0) {
+        out.extract = paths.map((path) => {
+            const projected = projectJsonPath(source, path);
+            return projected.missed
+                ? { path, content: null, pathMiss: true, missedAt: projected.at, available: projected.available }
+                : { path, content: projected.value ?? null };
+        });
+        if (paths.length === 1)
+            out.content = out.extract[0]?.content ?? null;
+    }
+    return out;
+}
+//# sourceMappingURL=path-projection.js.map

package/dist/tools.js

@@ -4,6 +4,7 @@ import { registerMetaLane } from "./lanes/meta.js";
 import { registerEnvironmentLane } from "./lanes/environment.js";
 import { registerAppLane } from "./lanes/app.js";
 import { registerDictionaryLane } from "./lanes/dictionary.js";
+import { registerFolderLane } from "./lanes/folder.js";
 import { registerModelLane } from "./lanes/model.js";
 import { registerFieldLane } from "./lanes/field.js";
 import { registerDataRuleLane } from "./lanes/datarule.js";
@@ -35,6 +36,7 @@ export function buildToolRegistry() {
     registerAppLane(tools);
     registerDictionaryLane(tools);
     registerModelLane(tools);
+    registerFolderLane(tools);
     registerFieldLane(tools);
     registerDataRuleLane(tools);
     registerFormLane(tools);

package/dist/write.js

@@ -22,7 +22,7 @@ import { plannableArgsRaw } from "./plan.js";
 import { defineTool, ToolRefusalError } from "./tool-types.js";
 import { assertFieldFamilyAllowed } from "./field-families.js";
 import { validateBusinessCode } from "./code-rules.js";
-import { validateFormLayout } from "./form-layout.js";
+import { hardLayoutViolations, validateFormLayout } from "./form-layout.js";
 import { prepareRuleGraph, validateRuleNodeGraph } from "./lanes/rule-graph.js";
 import { WireError } from "./wire.js";
 /**
@@ -219,8 +219,14 @@ export function writeTool(tools, name, lane, scope, description, inputSchema, ex
         }
         // CFG-form-layout: a supplied draft layout must satisfy the platform's
         // span/row/coverage invariants before it reaches the environment.
-        if (name === "form.draft" && typeof args.draftViewJson === "string" && typeof args.draftAttributesJson === "string") {
-            const violations = validateFormLayout(parseJsonOrUndefined(args.draftViewJson), parseJsonOrUndefined(args.draftAttributesJson));
+        // `fromReadback:true` means "these faces came from form.get" — the strict
+        // shape gate cannot tell a platform layout from a hand-written one without
+        // the session, so defer to form.draft's session-aware comparison (which
+        // still refuses a modified face). See issue 2026-10-23 §1.3.
+        if (name === "form.draft" && args.fromReadback !== true && typeof args.draftViewJson === "string" && typeof args.draftAttributesJson === "string") {
+            // Only HARD violations refuse here: the platform's own scaffold/layouts
+            // carry overflow/full-row/child-column shapes (issue 2026-10-23 §1.3).
+            const violations = hardLayoutViolations(validateFormLayout(parseJsonOrUndefined(args.draftViewJson), parseJsonOrUndefined(args.draftAttributesJson)));
             if (violations.length > 0)
                 throw new ToolRefusalError({ status: "refused", blocker: "form-layout-invalid", message: "表单布局未过出门前校验；按 validation 修正（span 白名单/行宽≤24/整行独占/控件覆盖率）", validation: violations });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stalfh233/omc-cli",
-  "version": "0.4.75",
+  "version": "0.4.77",
   "description": "CloudPivot 8.6 configuration capability CLI — governed, fail-closed, coverage-manifest bounded.",
   "type": "module",
   "bin": {
@@ -50,9 +50,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@stalfh233/omc-fake-platform": "0.4.75",
+    "@stalfh233/omc-fake-platform": "0.4.77",
     "commander": "14.0.3",
-    "omc-core": "0.4.75",
+    "omc-core": "0.4.77",
     "proper-lockfile": "4.1.2",
     "write-file-atomic": "6.0.0",
     "zod": "^3.23.8",

package/skills/omc-capabilities.md

@@ -25,6 +25,7 @@ only the section for the capability you need —
 | --- | --- | --- | --- |
 | 环境治理 `environment` | 环境发现/指纹/就绪 | 环境、指纹、版本、连接、登录、就绪、发现 | [环境治理](#环境治理-environment) |
 | 应用 `app` | 应用包生命周期 | 应用、门户、分组、app 建删移 | [应用](#应用-app) |
+| 应用目录（分组）`folder` | 应用树目录/分组 | 目录、分组、文件夹、应用树、移动模型到目录 | [应用目录](#应用目录分组-folder) |
 | 数据字典 `dictionary` | 字典与字典记录 | 字典、选项来源、树型、键值、字段下拉来源 | [数据字典](#数据字典-dictionary) |
 | 业务模型 `model` | 模型生命周期 | 模型、对象、表、主数据、改名、物理删除 | [业务模型](#业务模型-model) |
 | 字段 `field` | 字段族 + 子表 + **计算字段** | 字段、属性、子表、明细、下拉、单选、多选、附件、人员、部门、日期、数值、关联、**公式/计算/求和/汇总/合计/回主表** | [字段](#字段-field) |
@@ -52,9 +53,15 @@ only the section for the capability you need —
 
 ## 应用 `app`
 
-- **能做哪些事**：列出应用包、创建、改名/分组移动、删除（删除级联其模型）。
-- **工具**：`app.list`、`app.create`、`app.update`、`app.delete`
-- **边界 / 陷阱**：环境已带默认 `applicationCode`，建模**不必**先建应用；`app` 未进 intent 声明式面。**要把 intent 落到新应用**：`omc call app.create`（原子面）→ 把该环境的 `applicationCode` 指向新应用（`omc setup` 重配或改 `~/.config/omc/` 环境配置）→ 再 `intent plan/apply`，模型即落在新应用（用户实测摩擦：曾误以为应用能进 intent）。
+- **能做哪些事**：列出应用包、创建、改名/分组移动、删除（删除级联其模型）；**应用树目录（分组）的建/改名/挂载/删**，以及把模型放进目录。
+- **工具**：`app.list`、`app.create`、`app.update`、`app.delete`、`folder.tree`、`folder.create`、`folder.update`、`folder.delete`
+- **边界 / 陷阱**：**目录（分组）是应用树节点**：`folder.create` 省略 `parentId` 建的是顶层目录（平台默认挂应用根）、平台**不校验重名**（工具默认按同父同名拒绝）、`folder.delete` **非递归**（有子节点回 `DIRECTORY_NOT_EMPTY`）、树是嵌套 `children`（`folder.tree` 已递归展平给 `path/depth`，只看顶层会误判“没建成”）。模型进目录用 `model.move`。环境已带默认 `applicationCode`，建模**不必**先建应用；`app` 未进 intent 声明式面。**要把 intent 落到新应用**：`omc call app.create`（原子面）→ 把该环境的 `applicationCode` 指向新应用（`omc setup` 重配或改 `~/.config/omc/` 环境配置）→ 再 `intent plan/apply`，模型即落在新应用（用户实测摩擦：曾误以为应用能进 intent）。
+
+## 应用目录（分组）`folder`
+
+- **能做哪些事**：读应用树（目录 + 模型，递归展平带 `path/depth`）、建目录、改名/挂载、删除空目录；配合 `model.move` 把模型放进目录。
+- **工具**：`folder.tree`、`folder.create`、`folder.update`、`folder.delete`、`model.move`
+- **边界 / 陷阱**：`folder.create` 省略 `parentId` 建的是**顶层目录**（平台默认挂应用根）；平台**不校验重名**（工具默认同父同名拒绝，并列同名传 `allowDuplicate:true`）；`folder.delete` **非递归**（有子节点即拒 `folder-not-empty`）；应用树是**嵌套** `children`，`folder.tree` 已展平并给 `path/depth`——只看顶层会误判"目录没建成"。模型进目录用 `model.move {schemaCode, folderId}`，`folderId` 必须是目录 **id**（给名字回 `folder-not-found` / 跨应用回 `folder-other-application`）。
 
 ## 数据字典 `dictionary`
 
@@ -65,10 +72,10 @@ only the section for the capability you need —
 
 ## 业务模型 `model`
 
-- **能做哪些事**：模型创建、改名、物理删除（`absent:true` 回读）、存在性、批量删除、摘要；一次建模型+字段+表单用 `configure_model`。
-- **工具**：`model.list`、`model.inspect`、`model.create`、`model.delete`、`model.deleteMany`、`model.setSummary`、`model.update`、`configure_model`
+- **能做哪些事**：模型创建、改名、**移动到目录/分组**、物理删除（`absent:true` 回读）、存在性、批量删除、摘要；一次建模型+字段+表单用 `configure_model`。**应用目录（分组）本身**：`folder.tree` / `folder.create` / `folder.update` / `folder.delete`。
+- **工具**：`model.list`、`model.inspect`、`model.create`、`model.delete`、`model.deleteMany`、`model.setSummary`、`model.update`、`model.move`、`configure_model`、`folder.tree`、`folder.create`、`folder.update`、`folder.delete`
 - **recipe**：`omc describe configure_model --example model-with-fields-form`
-- **边界 / 陷阱**：`model.inspect <schemaCode>` 一次拿全字段/表单/列表/规则/流程摘要，别逐面 6 次调用。**保留 code**：字段 code 用 `name` 会被平台占用，须避开。**每个模型都必须建并发布默认表单**——只建模型不建/不发布表单则无法录入查看（`configure_form` 或 `form.draft(rebuild:true)` + `form.publish`）。**「汇总/统计/按月」类需求**：常见做法是**一张汇总表**（独立业务模型，如 `x_monthly_summary`）接住结果，用定时任务/规则把源数据汇总写进去——**但这按需求定**，不是写死的规则。需求确认时把"汇总表"作为常规选项提出来跟用户确认，别默认往报表或二开上引。
+- **边界 / 陷阱**：`model.inspect <schemaCode>` 一次拿全字段/表单/列表/规则/流程摘要，别逐面 6 次调用。**目录（分组）**：`folder.create` 省略 `parentId` 建的是**顶层目录**（平台默认挂应用根）；`folder.delete` **非递归**（有子节点即拒 `folder-not-empty`）；应用树是**嵌套**的，`folder.tree` 已递归展平并给 `path/depth`（只看顶层会误判“目录没建成”）。移动模型用 `model.move {schemaCode, folderId}`，`folderId` 必须是目录 **id**（给目录名会 `folder-not-found`）。**保留 code**：字段 code 用 `name` 会被平台占用，须避开。**每个模型都必须建并发布默认表单**——只建模型不建/不发布表单则无法录入查看（`configure_form` 或 `form.draft(rebuild:true)` + `form.publish`）。**「汇总/统计/按月」类需求**：常见做法是**一张汇总表**（独立业务模型，如 `x_monthly_summary`）接住结果，用定时任务/规则把源数据汇总写进去——**但这按需求定**，不是写死的规则。需求确认时把"汇总表"作为常规选项提出来跟用户确认，别默认往报表或二开上引。
 
 ## 字段 `field`