@stalfh233/omc-cli 0.5.7 → 0.5.9

package/dist/cli.js

@@ -1405,8 +1405,10 @@ function cmdHelpSearch(topic, query, transport, searchMode, limit) {
         sectionCount: outline.sections.length,
         // Each section carries its price inline. `{"heading":"入口","bytes":282}`
         // is cheaper than parallel arrays and reads better than a heading→bytes map;
-        // the heading names are what `--section` accepts.
-        sections: outline.sections.map((entry) => ({ heading: entry.heading, bytes: entry.bytes })),
+        // the heading names are what `--section` accepts. The blurb carries the
+        // section's first line so a bare index read still transfers key pointers
+        // (r36: four bare reads, zero section opens → body-only knowledge invisible).
+        sections: outline.sections.map((entry) => ({ heading: entry.heading, bytes: entry.bytes, ...(entry.blurb !== undefined ? { blurb: entry.blurb } : {}) })),
         hint: "默认只回节索引：先按各节 bytes 挑要读的节，再用 --section 取正文（可重复或逗号一次多节，也可用节序号或唯一前缀）。确需整篇才 --all。",
         sectionCommand: `omc help ${outline.document.name} --section "<heading>"`,
         fullCommand: `omc help ${outline.document.name} --all`,
@@ -1745,6 +1747,10 @@ async function main() {
         .option("--environment <environment>")
         .option("--no-form", "跳过表单重建")
         .option("--no-list", "跳过列表加列")
+        .option("--conditions <json>", "列表固定过滤条件 JSON 数组（listview.configure 契约，增量合并）")
+        .option("--conditions-json <json>")
+        .option("--demo-rows <json>", "演示数据行 JSON 数组（每项一份 formData，逐行 data.submit；非幂等）")
+        .option("--demo-rows-json <json>")
         .option("--force-publish", "有字段失败也发布（默认停在发布前）")
         .option("--apply")
         .addHelpText("after", `\n存量模型加字段一条命令：建字段 → 发布字段 → 重建表单 → 列表追加列（增量合并，保留既有列/条件/排序）。\n默认 dry-run 只列计划；--apply 执行。幂等：字段已存在记 skipped 继续。\n子表不属于本命令（存量挂子表走 field.create CHILD_TABLE + 子列，见 model-scaffold）。\n\nr30/r31 探针实证：同一条链手工要走 4 次写调用 + 各自回读。\n`)
@@ -1759,6 +1765,10 @@ async function main() {
             ...(options.environment ? ["--environment", options.environment] : []),
             ...(options.form === false ? ["--no-form"] : []),
             ...(options.list === false ? ["--no-list"] : []),
+            ...(options.conditions !== undefined ? ["--conditions", options.conditions] : []),
+            ...(options.conditionsJson !== undefined ? ["--conditions-json", options.conditionsJson] : []),
+            ...(options.demoRows !== undefined ? ["--demo-rows", options.demoRows] : []),
+            ...(options.demoRowsJson !== undefined ? ["--demo-rows-json", options.demoRowsJson] : []),
             ...(options.forcePublish ? ["--force-publish"] : []),
             ...(options.apply ? ["--apply"] : [])];
         commandExitCode = await cmdFieldAdd(rest);

package/dist/field-add.js

@@ -17,6 +17,70 @@ import { argvValue } from "./args.js";
 import { runToolCall } from "./call.js";
 import { CLI_EXIT_CODES, classifyResult, envelope, refusalText, requestId } from "./cli-contract.js";
 import { writeEnvelope } from "./cli-output.js";
+/**
+ * 字典简写展开（r30/r36 实证：字典字段要先 names 查 id、records 取记录、
+ * 再拼 optionsSet.dictionary 三段 4–5 调；`dictCode` 把它折进 field-add 一步）：
+ * `{"code":"x","propertyType":"DROPDOWN_BOX","dictCode":"purchase_coop_status"}`
+ * → 内部解析 checkedDictionary(id)+checkedDictionaryCode+useDictionariesData(records)
+ * 按 dictionary-backed-single-select recipe 形状组装 options.optionsSet。
+ */
+async function expandDictShorthand(fields, environment, contextForTest, request) {
+    const problems = [];
+    const expanded = [];
+    const call = async (tool, args) => {
+        const outcome = await runToolCall(tool, {
+            args,
+            requestId: request,
+            ...(environment !== undefined ? { environment } : {}),
+            ...(contextForTest !== undefined ? { context: contextForTest } : {}),
+            print: () => undefined,
+        });
+        return outcome.exitCode === 0 ? outcome.result : null;
+    };
+    const out = [];
+    for (const field of fields) {
+        const dictCode = field.dictCode;
+        if (typeof dictCode !== "string" || dictCode.length === 0) {
+            out.push({ ...field });
+            continue;
+        }
+        const rest = { ...field };
+        delete rest.dictCode;
+        // dictionary.list 是真假两平台都稳的清单面（names 的 getDictionaryIdAndNames
+        // 在 fake 上未实现）；list 的回执可能是 {dictionaries:{content:[...]}} 分页
+        // 或裸数组，两种都吃。
+        const listResult = await call("dictionary.list", { limit: 200 });
+        const listPayload = listResult === null ? null : (listResult.dictionaries ?? listResult.names ?? listResult.content ?? listResult);
+        const names = Array.isArray(listPayload)
+            ? listPayload
+            : (Array.isArray(listPayload?.content) ? listPayload.content : []);
+        const hit = names.find((row) => String(row.code ?? row.dictionaryCode ?? "") === dictCode);
+        if (hit === undefined) {
+            problems.push(`${String(field.code)}: 字典 ${dictCode} 不存在（dictionary.names 未命中）——先 dictionary.save 或修正 dictCode`);
+            continue;
+        }
+        const dictId = String(hit.id ?? hit.dictionaryId ?? "");
+        const recordsResult = await call("dictionary.records", { code: dictCode, enabledOnly: true });
+        const recordsRaw = recordsResult === null ? [] : (recordsResult.records ?? {});
+        const recordRows = (Array.isArray(recordsRaw) ? recordsRaw : (recordsRaw.content ?? []));
+        if (recordRows.length === 0) {
+            problems.push(`${String(field.code)}: 字典 ${dictCode} 无启用记录——先补 dictionary.records`);
+            continue;
+        }
+        const useDictionariesData = recordRows.map((row) => ({ id: String(row.id ?? ""), code: String(row.code ?? ""), name: String(row.name ?? row.code ?? "") }));
+        out.push({
+            ...rest,
+            options: {
+                optionsSet: {
+                    optionsType: "dictionary",
+                    dictionary: { checkedDictionary: dictId, checkedDictionaryCode: dictCode, useDictionariesData },
+                },
+            },
+        });
+        expanded.push(String(field.code));
+    }
+    return { fields: out, expanded, problems };
+}
 export function validateFields(schemaCode, fields) {
     const problems = [];
     const seen = new Set();
@@ -50,12 +114,17 @@ export async function cmdFieldAdd(args, contextForTest) {
     const publishForm = !args.includes("--no-form");
     const addToList = !args.includes("--no-list");
     const forcePublish = args.includes("--force-publish");
+    const conditionsJson = flag("--conditions") ?? flag("--conditions-json");
+    const demoRowsJson = flag("--demo-rows") ?? flag("--demo-rows-json");
     const usage = [
         "用法：omc field-add --schema <模型code> --fields '<JSON 数组>' [--apply]",
-        "  --fields 每项是一个 field.create 的参数：{\"code\",\"name\",\"propertyType\",...}（choices/字典 options 原样透传）。",
+        "  --fields 每项是一个 field.create 的参数：{\"code\",\"name\",\"propertyType\",...}（choices/字典 options 原样透传）；",
+        "  字典简写：{\"dictCode\":\"<字典code>\"} 代替手拼 options.optionsSet（内部解析字典 id+启用记录，recipe 同形状）。",
         "  默认 dry-run；--apply 依次执行 建字段 → 发布字段 → 重建表单 → 列表追加列。",
         "  幂等：字段已存在记 skipped 继续；有真失败默认不发布/不重建（--force-publish 强发）。",
         "  --no-form 跳过表单重建；--no-list 跳过列表加列（默认两者都做）。",
+        "  --conditions '<JSON 数组>' 列表固定过滤条件（listview.configure 契约；**整体替换**既有固定条件——要保留旧的须一并带上；不传则不动）；需 --list（默认开）。",
+        "  --demo-rows '<JSON 数组>' 演示数据行（每项一份 formData，逐行 data.submit）；非幂等——重复执行会重复插行。",
     ].join("\n");
     const invalid = (message) => {
         writeEnvelope(envelope("error", {}, request, { code: "invalid-input", message: `${message}\n${usage}`, retryable: false }));
@@ -78,6 +147,45 @@ export async function cmdFieldAdd(args, contextForTest) {
     const problems = validateFields(schemaCode, fields);
     if (problems.length > 0)
         return invalid(`--fields 有 ${problems.length} 处问题：\n  - ${problems.join("\n  - ")}`);
+    // r38 后执行层折叠（调查批 v2）：--conditions/--demo-rows 把「加字段+过滤+演示行」
+    // 整链折进一条命令（此前 6-8 调）。conditions 走 listview.configure 契约；
+    // demo-rows 逐行 data.submit（非幂等，文档声明）。
+    let conditions;
+    if (conditionsJson !== undefined) {
+        if (!addToList)
+            return invalid("--conditions 需要列表配置面（不要与 --no-list 同用）");
+        try {
+            const parsed = JSON.parse(conditionsJson);
+            if (!Array.isArray(parsed) || parsed.length === 0)
+                throw new Error("必须是非空 JSON 数组");
+            conditions = parsed;
+        }
+        catch (error) {
+            return invalid(`--conditions 解析失败：${error instanceof Error ? error.message : String(error)}（形状见 omc describe listview.configure --param conditions）`);
+        }
+    }
+    let demoRows;
+    if (demoRowsJson !== undefined) {
+        try {
+            const parsed = JSON.parse(demoRowsJson);
+            if (!Array.isArray(parsed) || parsed.length === 0)
+                throw new Error("必须是非空 JSON 数组");
+            demoRows = parsed;
+        }
+        catch (error) {
+            return invalid(`--demo-rows 解析失败：${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // 字典简写展开（dictCode → optionsSet.dictionary，含 id/记录解析）——展开失败
+    // 在任何写之前拒绝（名字对不上/无启用记录）。
+    let dictExpanded = 0;
+    if (fields.some((field) => typeof field.dictCode === "string")) {
+        const expandedResult = await expandDictShorthand(fields, environment, contextForTest, request);
+        if (expandedResult.problems.length > 0)
+            return invalid(`dictCode 展开失败（未写入）：\n  - ${expandedResult.problems.join("\n  - ")}`);
+        fields = expandedResult.fields;
+        dictExpanded = expandedResult.expanded.length;
+    }
     const options = {
         schemaCode, fields, apply, publishForm, addToList, forcePublish,
         ...(environment !== undefined ? { environment } : {}),
@@ -115,11 +223,14 @@ export async function cmdFieldAdd(args, contextForTest) {
             status: "dry-run",
             schema: schemaCode,
             fields: fields.map((field) => String(field.code)),
+            ...(dictExpanded > 0 ? { dictExpanded } : {}),
             steps: [
                 `field.create ×${fields.length}`,
                 "field.publish（发布失败/有字段失败则停）",
                 ...(publishForm ? [`form.publish ${schemaCode} --rebuild（重建让新字段进默认表单）`] : []),
-                ...(addToList ? [`listview.configure ${schemaCode} 增量追加列（保留既有列与条件）`] : []),
+                ...(addToList ? [`listview.configure ${schemaCode} 增量追加列（列保留；固定条件整体替换）`] : []),
+                ...(conditions !== undefined ? [`listview.configure 附带固定过滤条件 ×${conditions.length}`] : []),
+                ...(demoRows !== undefined ? [`data.submit 演示行 ×${demoRows.length}（非幂等）`] : []),
             ],
             preflight: { checked: fields.length, passed: true },
             note: "dry-run 只列计划；已对每个字段跑过本地形状预检（零 wire）。--apply 依次执行全部步骤。",
@@ -199,21 +310,38 @@ export async function cmdFieldAdd(args, contextForTest) {
     }
     // 4) 列表增量加列：默认合并语义保留既有列/条件/排序（r31 实证）；只有字段全部
     //    失败才跳过（部分成功时把成功的列加上去仍有意义）。
-    if (addToList && createdCodes.length > 0 && !publishingBlocked) {
-        const configured = await call("listview.configure", { schemaCode, fieldCodes: createdCodes });
+    const listviewArgs = { schemaCode };
+    if (createdCodes.length > 0)
+        listviewArgs.fieldCodes = createdCodes;
+    if (conditions !== undefined)
+        listviewArgs.conditions = conditions;
+    if (addToList && (createdCodes.length > 0 || conditions !== undefined) && !publishingBlocked) {
+        const configured = await call("listview.configure", listviewArgs);
         steps.push({
             step: "listview.configure",
             status: configured.ok ? "ok" : "failed",
             detail: configured.ok
-                ? { schemaCode, appended: createdCodes, semantics: "增量合并：保留既有列/条件/排序" }
-                : { schemaCode, fieldCodes: createdCodes, message: String(configured.result.message ?? "") },
+                ? { schemaCode, ...(createdCodes.length > 0 ? { appended: createdCodes } : {}), ...(conditions !== undefined ? { conditions: conditions.length, conditionsSemantics: "整体替换（既有固定条件要保留须一并带上）" } : {}), semantics: "列增量合并保留既有列/排序；固定条件整体替换" }
+                : { schemaCode, ...listviewArgs, message: String(configured.result.message ?? "") },
         });
     }
     else if (addToList) {
         steps.push({
             step: "listview.configure",
             status: "skipped",
-            detail: { reason: createdCodes.length === 0 ? "没有字段落到发布面" : "有字段创建失败，默认不动列表（--force-publish 可强发）" },
+            detail: { reason: createdCodes.length === 0 && conditions === undefined ? "没有字段落到发布面" : "有字段创建失败，默认不动列表（--force-publish 可强发）" },
+        });
+    }
+    // 演示数据（--demo-rows）：逐行 data.submit；失败记 failed 不阻断（行级独立）。
+    for (const [index, row] of (demoRows ?? []).entries()) {
+        const submitted = await call("data.submit", { schemaCode, formData: row });
+        const readback = submitted.ok ? (submitted.result.readback ?? {}) : {};
+        steps.push({
+            step: "data.submit",
+            status: submitted.ok ? "ok" : "failed",
+            detail: submitted.ok
+                ? { row: index + 1, bizObjectId: readback.objectId ?? null, sequenceStatus: readback.sequenceStatus ?? null }
+                : { row: index + 1, message: String(submitted.result.message ?? "") },
         });
     }
     const failedSteps = steps.filter((step) => step.status === "failed");
@@ -230,6 +358,20 @@ export async function cmdFieldAdd(args, contextForTest) {
         ...(lastSummaries.length > 0 ? { summaries: lastSummaries } : {}),
         steps,
         folded: "field.create → field.publish → form.publish(rebuild) → listview.configure(增量) 4 写调合成 1 条命令",
+        ...(status === "ok"
+            ? {
+                hint: [
+                    "本命令覆盖单模型加字段；变更还涉及多模型/规则/流程/视图重排时，改走声明式 intent 链（omc intent schema 看清单 → validate → plan → apply，dry-run→读回校验）",
+                    // r39 实证：agent 做完字段后把过滤/演示行拆成 listview.configure×N + data.submit×N
+                    // 串行做。回执直接给续段一条命令——conditions 增量幂等可单独重跑，demo-rows 非幂等。
+                    ...(conditions === undefined || demoRows === undefined
+                        ? [
+                            `同模型还要列表固定过滤/演示数据？直接续一条（不必另跑 listview.configure/data.submit）：omc field-add --schema ${schemaCode} ${conditions === undefined ? "--conditions '<固定过滤>' " : ""}${demoRows === undefined ? "--demo-rows '<演示行>' " : ""}--apply（conditions 增量幂等；demo-rows 非幂等重复插行）`,
+                        ]
+                        : []),
+                ].join("；"),
+            }
+            : {}),
     };
     const classified = classifyResult(status === "partial" ? { ...result, requested: steps.length, succeeded: steps.length - failedSteps.length } : result);
     writeEnvelope(envelope(classified.status, result, request, classified.error));

package/dist/form-support.js

@@ -1147,6 +1147,15 @@ export async function executeFormDraftWrite(session, args) {
                 }
                 : {}),
             ...(args.rebuild === true && previousAttributes ? { rebuildPreservedControls } : {}),
+            // r36（2026-11-01）：rebuild 后草稿与重建前逐字节一致时明示——rebuild 的
+            // 语义就是"按已发布字段重搭"，一致通常意味着预期的新控件没进来（字段未
+            // 发布/写错槽位），静默 no-op 会让"新增字段后刷新表单"看起来成功实则没变。
+            ...(args.rebuild === true && previousAttributes !== undefined && typeof attributes === "string" && attributes.trim() === JSON.stringify(previousAttributes).trim()
+                ? {
+                    rebuildUnchanged: true,
+                    rebuildNote: "rebuild 后草稿与重建前完全一致——若你预期新增控件（新字段上表单），检查：① 字段是否已 field.publish；② 写入槽位 sheetCode 是否正确（省略=模型 code 槽位）；r36 实测同序列下重建静默 no-op。",
+                }
+                : {}),
         },
     };
 }

package/dist/goal-routes.js

@@ -383,9 +383,9 @@ const COMPOSER_ROUTES = Object.freeze([
     },
     {
         id: "field-add",
-        command: "omc field-add --schema <存量模型code> --fields '<JSON数组>' --apply",
+        command: "omc field-add --schema <存量模型code> --fields '<JSON数组>' [--conditions '<固定过滤>'] [--demo-rows '<演示行>'] --apply",
         usage: "omc field-add --help",
-        summary: "存量模型加字段一条命令：建字段 → 发布 → 重建表单 → 列表追加列（增量合并）；4 次写调合成 1 条命令",
+        summary: "存量模型加字段一条命令：建字段 → 发布 → 重建表单 → 列表追加列；--conditions 固定过滤 + --demo-rows 演示行同链折入——字段+过滤+演示数据的多段需求整句一次问，4-8 次调用合成 1 条命令",
         // (add verb) × (field noun)——「给既有/存量模型加字段」是变更类需求的最高频动作（r30/r31 探针实证手工链 4 调）
         groups: [["加", "新增", "添加", "补", "增加"], ["字段"]],
         // 只收「加字段本体」；规则/校验/计算/编号/流程语义各有归宿（round10：'给金额字段加自动校验规则' 应归 datarule，不能被本 composer 抢走）
@@ -452,7 +452,7 @@ export const COMPOSER_ROUTES_FOR_TEST = COMPOSER_ROUTES;
 const COMPOSER_QUESTIONS = Object.freeze({
     "model-purge": "要清理哪个模型？给我 schemaCode（不确定就先跑下面的只读判别动作拿清单）",
     "model-scaffold": "给我模型 code、显示名和字段清单（每字段 code/名称/类型；子表放 subFields），我一条命令建完",
-    "field-add": "目标存量模型 schemaCode 和字段清单（每字段 code/名称/类型；choices 给字符串数组、字典给 options）是什么？建完自动发布、重建表单、列表加列",
+    "field-add": "目标存量模型 schemaCode 和字段清单（每字段 code/名称/类型；choices 给字符串数组、字典 dictCode 简写）是什么？需求还带列表固定过滤或演示行的话**一并整句给我——全折进本命令（--conditions/--demo-rows），不要拆成字段/过滤/数据三段串行做**；建完自动发布、重建表单、列表加列",
     "approval-flow": "目标模型 schemaCode 和每级审批节点（节点名@角色code，多级用重复 --steps）是什么？",
     compute: "目标模型 schemaCode、结果字段 code、公式是什么？（子表条件聚合再加 --where \"子列 = 值\"）",
     "rule-when": "目标模型 schemaCode、触发时机（Create/Update…）、条件（--when）和动作（--then）各是什么？",

package/dist/human-summary.js

@@ -126,7 +126,7 @@ function phraseOf(tool, args, outcome) {
         case "field.publish":
             return `发布模型 ${schemaCode ?? "?"} 的全部草稿字段（模型级一次发布）`;
         case "form.draft":
-            return `保存表单 ${stringArg(args, "sheetCode") ?? "?"}（模型 ${schemaCode ?? "?"}）的草稿布局`;
+            return `保存表单 ${stringArg(args, "sheetCode") ?? (schemaCode !== undefined ? String(schemaCode) : "?")}（模型 ${schemaCode ?? "?"}）的草稿布局——sheetCode 省略时实际写入 = 模型 code 槽位`;
         case "form.publish":
             // r26 finding: sheetCode is optional (resolved from schemaCode for the
             // default form) — the summary showed "?" when the agent omitted it.

package/dist/journal.js

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, appendFileSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { invalidateProjectCard } from "./project-card.js";
 /**
  * Per-environment append-only journal of delivered governed config writes.
  *
@@ -26,6 +27,9 @@ export function appendJournalEntry(artifactsDir, entry) {
     const seq = countLines(file) + 1;
     const full = { ...entry, seq, ts: new Date().toISOString() };
     appendFileSync(file, `${JSON.stringify(full)}\n`, "utf8");
+    // 2026-11-01 项目卡失效：模型面写操作改变清单——下次会话不得读旧卡。
+    if (/^model\.(create|delete|move|update)/.test(entry.tool))
+        invalidateProjectCard(artifactsDir);
     return full;
 }
 export function readJournal(environment, artifactsDir) {

package/dist/lanes/b2-registration.js

@@ -722,6 +722,10 @@ export function registerB2Lane(tools) {
                 }
             }
             return { adapters, rawPresent: typeof result.data === "string" };
+        }, {
+            // 2026-11-01 读门 2048：适配器面本身就是这个工具的存在意义（注册预检的
+            // 同源依据）——compact 保留 adapters 本体，不折码表。
+            compact: (result) => result,
         }),
     }));
     tools.push(defineTool({

package/dist/lanes/businessrule.js

@@ -88,8 +88,22 @@ export function registerBusinessRuleLane(tools) {
             // key (schemaCode+ruleCode), so the row id is rarely needed.
             const fullRows = args.full === true;
             const visible = args.onlyCustom === true ? rows.filter((row) => row.defaultRule !== true) : rows;
+            // r40 维护者自踩：schemaCode 不存在时平台静默回空数组——空规则被读成
+            // 『模型在、无规则』走错分支（mcc_contract 从不存在却答 0 规则）。
+            // 空结果时用 field.list 探一次真身（300004=不存在），把 modelPresent 标进结果。
+            let modelPresent = true;
+            if (visible.length === 0) {
+                try {
+                    await wireCall(session, { path: ENDPOINTS.fieldList, query: { schemaCode: args.schemaCode, isPublish: "true" } });
+                }
+                catch (error) {
+                    if (String(error.message ?? error).includes("errcode 300004"))
+                        modelPresent = false;
+                }
+            }
             return {
                 schemaCode: args.schemaCode,
+                ...(modelPresent ? {} : { modelPresent: false, hint: "模型不存在（field.list 300004）——空规则是假象；先 model.create / configure_model，判定模型面用 model.inspect" }),
                 ...(args.onlyCustom === true ? { filtered: { onlyCustom: true, total: rows.length, returned: visible.length } } : {}),
                 rules: visible.map((row) => ({
                     code: row.code,

package/dist/lanes/environment.js

@@ -7,6 +7,7 @@ import { flattenTreeRows } from "../support.js";
 import { defineTool } from "../tool-types.js";
 import { wireCall, wireRows } from "../wire.js";
 import { ENVIRONMENT_LANE_CONTRACT } from "./environment-contract.js";
+import { readProjectCard, writeProjectCard } from "../project-card.js";
 const ENVIRONMENT_LANE = ENVIRONMENT_LANE_CONTRACT.lane;
 const ENVIRONMENT_TOOLS = ENVIRONMENT_LANE_CONTRACT.tools;
 export function registerEnvironmentLane(tools) {
@@ -22,9 +23,17 @@ export function registerEnvironmentLane(tools) {
             applicationCode: z.string().optional(),
             modelCode: z.string().optional(),
             full: z.boolean().optional().describe("内联完整发现结果；默认返回计数与 detailFile"),
+            refresh: z.boolean().optional().describe("跳过项目卡缓存强制重查（模型清单有变更但未被自动失效时用）"),
             capability: capabilityArg,
         },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            // 2026-11-01 项目卡（预算压缩批 v1）：新鲜缓存命中时一次本地读替代
+            // 2–3 次 wire（r31–r37 每会话重新盘点的纯浪费）。refresh:true 强制重查。
+            if (args.refresh !== true && args.applicationCode === undefined && args.modelCode === undefined && args.full !== true) {
+                const cached = readProjectCard(ctx.artifactsDir, String(args.environment ?? session.environmentName ?? ""));
+                if (cached !== undefined)
+                    return { ...cached, status: "ok", fromCache: true };
+            }
             // List every application the tenant exposes — the configured
             // applicationCode is a default, never the only application. Resolve
             // the active code through the same priority chain as writes:
@@ -120,7 +129,7 @@ export function registerEnvironmentLane(tools) {
                     .filter((row) => !args.modelCode || row.code === args.modelCode || row.schemaCode === args.modelCode)
                     .map((row) => ({ schemaCode: row.code ?? row.schemaCode, name: row.name }));
             }
-            return {
+            const discovered = {
                 applications: apps,
                 groups,
                 applicationCode: selected ?? null,
@@ -130,6 +139,21 @@ export function registerEnvironmentLane(tools) {
                 foldersAndModels,
                 models,
             };
+            // 项目卡写入（软失败）：默认形态（无收窄参数）时缓存模型清单，下次会话一次本地读。
+            if (args.applicationCode === undefined && args.modelCode === undefined && args.full !== true) {
+                const envName = String(args.environment ?? session.environmentName ?? "");
+                if (envName !== "" && Array.isArray(discovered.models) && discovered.models.length > 0 && typeof selected === "string" && selected !== "") {
+                    writeProjectCard(ctx.artifactsDir, {
+                        environment: envName,
+                        applicationCode: selected,
+                        ...(applicationResolution !== undefined ? { applicationResolution: { code: String(selected ?? applicationResolution.requested ?? ""), source: String(applicationResolution.source ?? "") } } : {}),
+                        models: discovered.models.slice(0, 300).map((row) => ({ code: String(row.schemaCode), name: String(row.name ?? "") })),
+                        modelCount: discovered.models.length,
+                        generatedAt: new Date().toISOString(),
+                    });
+                }
+            }
+            return discovered;
         }, {
             full: args.full === true,
             target: `discover_environment:${args.applicationCode ?? ""}:${args.modelCode ?? ""}`,

package/dist/lanes/form.js

@@ -143,6 +143,24 @@ export function registerFormLane(tools) {
                 publishedControlCodes: publishedControls,
                 ...(wanted ? { draftControls: pick(sheet.draftAttributesJson), publishedControls: pick(sheet.publishedAttributesJson) } : {}),
             };
+        }, {
+            // 2026-11-01 读门 2048：controls=true 是**显式**取控件定义的请求——compact
+            // 保留定义映射与按钮/options（--full 的语义面），其余大数组归码表/计数。
+            compact: (result) => {
+                const KEEP = new Set(["draftControls", "publishedControls", "customButtonJson", "options", "formButtons", "formButtonCodes"]);
+                const out = {};
+                for (const [key, value] of Object.entries(result)) {
+                    if (KEEP.has(key))
+                        out[key] = value;
+                    else if (Array.isArray(value))
+                        out[`${key}Codes`] = value.map((entry) => (entry && typeof entry === "object" ? String(entry.code ?? entry.propertyCode ?? "") : String(entry))).filter((entry) => entry.length > 0), out[`${key}Count`] = value.length;
+                    else if (value !== null && typeof value === "object")
+                        out[`${key}Count`] = Object.keys(value).length;
+                    else
+                        out[key] = value;
+                }
+                return out;
+            },
         }),
     }));
     writeTool(tools, "form.draft", FORM_LANE, FORM_TOOLS["form.draft"].scope, FORM_TOOLS["form.draft"].description, {
@@ -242,7 +260,23 @@ export function registerFormLane(tools) {
             });
             results.push({ step: "form.publish", errcode: publishOutcome.performed.errcode });
             const published = await wireCall(session, { path: ENDPOINTS.sheetGet, query: { schemaCode: args.schemaCode, sheetCode } });
-            return { steps: results, readback: { formPublished: (published.data ?? {}).published === true, publishedHtmlJsonPresent: typeof (published.data ?? {}).publishedHtmlJson === "string" } };
+            const pub = (published.data ?? {});
+            const publishedControlCodes = parseControlCodes(pub.publishedAttributesJson);
+            // r40 F4：published=true ≠ 请求的字段进了布局——模型已有手工布局时，非 rebuild
+            // 草稿保留原控件，新字段不会出现，而 formPublished 仍是 true（假成功）。
+            // readback 必须核「请求面是否真的落进 published 控件」，缺了就点名+给重建路。
+            const missing = (args.fieldCodes ?? []).filter((code) => !publishedControlCodes.includes(code));
+            return {
+                steps: results,
+                readback: {
+                    formPublished: pub.published === true,
+                    publishedHtmlJsonPresent: typeof pub.publishedHtmlJson === "string",
+                    publishedControlCodes,
+                    ...(missing.length > 0
+                        ? { missingFieldCodes: missing, warning: `表单已发布，但请求的 ${missing.join("、")} 不在 published 控件里（既有手工布局未带上新字段）——重跑 configure_form 带 rebuild:true（或 form.draft {rebuild:true} → form.publish）后重验本字段` }
+                        : {}),
+                },
+            };
         },
         summarize: (args, _outcome, phase) => writeSummary("configure_form", args, undefined, phase),
     });

package/dist/path-projection.js

@@ -2,6 +2,30 @@ import { readFileSync } from "node:fs";
 import { readArtifact } from "./artifacts.js";
 import { artifactRoot } from "./command-transport.js";
 export function projectJsonPath(value, path) {
+    // r40 F9：`$.x`（jq 标准根写法）此前 pathMiss——agent/人都习惯带根前缀。
+    // 归一剥掉前导 `$.`/`$`，语义等价（本 DSL 根就是整份结果）。
+    if (path.startsWith("$."))
+        path = path.slice(2);
+    else if (path === "$")
+        path = "";
+    // 2026-11-01（r36 维护者实测）：jq 切片 `a[0:6]`/`a[:n]`/`a[n:]` 此前
+    // pathMiss 且 hint 的 available 还把数组列成"可用键"，误导下一步。数组
+    // 切片与 jq 语义一致（含头不含尾）。
+    const sliceSel = /\[(\d*):(\d*)\]/.exec(path);
+    if (sliceSel !== null) {
+        const [, rawFrom, rawTo] = sliceSel;
+        const before = path.slice(0, sliceSel.index);
+        const after = path.slice(sliceSel.index + sliceSel[0].length);
+        const base = projectJsonPath(value, before);
+        if (base.missed)
+            return base;
+        if (!Array.isArray(base.value))
+            return { missed: true, at: before || "$", available: `该层不是数组（是 ${base.value === null ? "null" : typeof base.value}）；切片 [from:to] 需要数组` };
+        const from = rawFrom === "" ? undefined : Number(rawFrom);
+        const to = rawTo === "" ? undefined : Number(rawTo);
+        const sliced = base.value.slice(from, to);
+        return after === "" ? { missed: false, value: sliced } : projectJsonPath(sliced, after);
+    }
     // 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
@@ -97,7 +121,7 @@ function argvValues(args, name) {
     return values;
 }
 /** Shared wording for every projection miss, so all three faces teach the same syntax. */
-const PATH_MISS_HINT = "路径未命中（这一层没有该段）。可用写法：点式 a.b、下标 a[0]、数组映射 items[].fields.x、按键选择 rules[code=Create]（返回第一个匹配项）。available 是该层真实存在的键。";
+const PATH_MISS_HINT = "路径未命中（这一层没有该段）。可用写法：点式 a.b、下标 a[0]、切片 a[0:6]、数组映射 items[].fields.x、按键选择 rules[code=Create]（返回第一个匹配项）。available 是该层真实存在的键。";
 /**
  * `call --extract/--extract-keys`: resolve paths inside the result's own
  * artifact (or inside the result object when the tool returned no artifact).

package/dist/project-card.js

@@ -0,0 +1,55 @@
+/**
+ * Project card — one ~1KB local read that replaces the per-session 3–5 live
+ * wire calls of environment discovery (discover_environment → 2–3 wire reads;
+ * model.list → 1 wire read; r31–r37 every probe re-inventoried the platform).
+ *
+ * Design copied from describe-cache (`.omc/describe-full-cache.json`):
+ * an index file inside the artifacts dir points at an artifact body; a hit is
+ * soft (failure never breaks the main path), freshness = TTL + model-write
+ * invalidation; content changes that don't touch models (fields/rules/views)
+ * do NOT change the model inventory and don't invalidate.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createArtifact, readArtifact } from "./artifacts.js";
+const CARD_INDEX = "project-card.json";
+const CARD_TTL_MS = 6 * 60 * 60 * 1000;
+function indexPath(root) {
+    return path.join(root, CARD_INDEX);
+}
+/** Fresh card for this environment, or undefined (missing/stale/other env). */
+export function readProjectCard(root, environment) {
+    try {
+        const index = JSON.parse(fs.readFileSync(indexPath(root), "utf8"));
+        if (index.environment !== environment)
+            return undefined;
+        if (Date.now() - index.at > CARD_TTL_MS)
+            return undefined;
+        const card = JSON.parse(readArtifact(root, index.artifactId).content.toString("utf8"));
+        return { ...card, fromCacheHint: `项目卡 ${new Date(index.at).toISOString()} 生成（TTL 6h，模型写操作失效）；要强制重查传 refresh:true` };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Persist the card (artifact body + index). Soft-fail: never throws. */
+export function writeProjectCard(root, card) {
+    try {
+        const artifact = createArtifact(root, JSON.stringify({ ...card, fromCacheHint: undefined }));
+        const index = { artifactId: artifact.artifactId, environment: card.environment, at: Date.now(), modelCount: card.modelCount };
+        fs.writeFileSync(indexPath(root), JSON.stringify(index), "utf8");
+    }
+    catch {
+        // The card is a pure optimization layer; failure to cache is not an error.
+    }
+}
+/** Invalidate on model-shape writes (create/delete) so a fresh session never reads a stale inventory. */
+export function invalidateProjectCard(root) {
+    try {
+        fs.rmSync(indexPath(root), { force: true });
+    }
+    catch {
+        // best-effort
+    }
+}
+//# sourceMappingURL=project-card.js.map

package/dist/read.js

@@ -56,7 +56,10 @@ export async function governedRead(ctx, tool, args, execute, options = {}) {
         if (ctx.readbackCacheBypass === 0 && cached && cached.environmentFingerprint === environmentFingerprint && cached.targetFingerprint === targetFingerprint && options.full !== true)
             return { status: "ok", unchanged: true, detailFile: cached.detailFile, detailSha256: cached.detailSha256, environmentFingerprint };
         const detail = { status: "ok", ...result, environmentFingerprint };
-        const large = jsonBytes(result) > 4096;
+        // 2026-11-01 预算批 v2（r38 usage 实证）：1-4KB 中结果 59 次/135KB≈37% 全内联，
+        // model.inspect 17 次全部卡在旧门下。降到 2048；compact 对配置清单保形为码表
+        // （CODE_LIST_KEYS），完整正文仍在 detailArtifactId。
+        const large = jsonBytes(result) > 2048;
         const fileName = `${tool.name.replace(/[^a-zA-Z0-9._-]/g, "_")}-${sha256(target).slice(0, 16)}.json`;
         const artifactRef = writeArtifact(ctx, fileName, detail);
         ctx.readbackCache.set(target, { environmentFingerprint, targetFingerprint, detailFile: artifactRef.detailFile, detailSha256: artifactRef.detailSha256 });
@@ -100,12 +103,29 @@ function compactReadback(result) {
         if (BULKY_READ_KEYS.has(key)) {
             compact[`${key}Count`] = Array.isArray(value) ? value.length : value && typeof value === "object" ? Object.keys(value).length : 0;
         }
+        else if (CODE_LIST_KEYS.has(key) && Array.isArray(value)) {
+            // 2026-11-01 预算批 v2：读门 4096→2048 后，中结果（r38 实测 model.inspect
+            // 17 次 51KB 全部卡旧门下全内联）走 compact——配置清单类数组保形为码表
+            // （不是只给 count），否则 agent 被迫二次 artifact get 反加回合。
+            compact[key] = value.map(codeOfEntry).filter((entry) => entry !== undefined);
+            compact[`${key}Count`] = value.length;
+        }
         else {
             compact[key] = summarizeValue(value);
         }
     }
     return compact;
 }
+/** Config-inventory keys that compact to a code list (not a bare count). */
+const CODE_LIST_KEYS = new Set(["fields", "columns", "conditions", "sorts", "datarules", "buttons", "views"]);
+function codeOfEntry(entry) {
+    for (const key of ["propertyCode", "code", "schemaCode", "ruleCode", "fieldCode"]) {
+        const value = entry[key];
+        if (typeof value === "string" && value.length > 0)
+            return value;
+    }
+    return undefined;
+}
 /**
  * Keys whose values are the bulk a compact projection replaces with a count.
  * Everything else is a small facet identity/decision fields (workflowCode,

package/dist/skills.js

@@ -157,6 +157,23 @@ export function readSkillSection(name, requested) {
  * headings. An index costs ~600 B and names the price of each part, so the
  * caller chooses instead of paying for the whole document by default.
  */
+/** First meaningful body line of a section: skip headings/blank/fence/list markers. */
+function sectionBlurb(body) {
+    const limit = 70;
+    // sliceSectionText includes the section's own heading line — skip it.
+    for (const raw of body.split(/\r?\n/).slice(1)) {
+        const line = raw.trim();
+        if (line.length === 0)
+            continue;
+        if (line.startsWith("#") || line.startsWith("```") || line.startsWith("<!--") || line.startsWith("|"))
+            continue;
+        const text = line.replace(/^[-*]\s+/, "").replace(/^\d+\.\s*/, "").replace(/\*\*/g, "");
+        if (text.length === 0)
+            continue;
+        return text.length > limit ? `${text.slice(0, limit)}…` : text;
+    }
+    return undefined;
+}
 export function readSkillOutline(name) {
     const document = readSkill(name);
     if (!document)
@@ -165,7 +182,7 @@ export function readSkillOutline(name) {
     const headings = scanHeadings(lines);
     const sections = headings.map((entry) => {
         const body = sliceSectionText(lines, entry.index, entry.level);
-        return { heading: entry.heading, level: entry.level, bytes: Buffer.byteLength(body, "utf8") };
+        return { heading: entry.heading, level: entry.level, bytes: Buffer.byteLength(body, "utf8"), blurb: sectionBlurb(body) };
     });
     const bytes = Buffer.byteLength(document.content, "utf8");
     // A topic whose whole body sits under a single H1 (the title) would produce a

package/package.json

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

package/skills/omc-capabilities.md

@@ -68,7 +68,7 @@ only the section for the capability you need —
 - **能做哪些事**：字典与字典记录全生命周期（键值型/树型、启停）；作为选择字段的选项来源；字典分类。
 - **工具**：`dictionary.list`、`dictionary.type`、`dictionary.names`、`dictionary.get`、`dictionary.records`、`dictionary.save`、`dictionary.status`、`dictionary.usage`、`dictionary.parent`、`dictionary.classes`、`dictionary.class.save`、`dictionary.class.delete`
 - **recipe**：`omc describe dictionary.save --example dictionary-key-value`
-- **边界 / 陷阱**：选择字段有三种选项来源——`custom` / `dictionary` / `businessModel`；关联单选/多选支持 `searchFormula` 与 `conditions` JSON 筛选。
+- **边界 / 陷阱**：选择字段有三种选项来源——`custom` / `dictionary` / `businessModel`；关联单选/多选支持 `searchFormula` 与 `conditions` JSON 筛选。**字典没有删除**——平台只有停用/启用（`dictionary.status`，target= dictionary|record）；不要找 dictionary.delete（分类有 `class.delete`，字典本体没有），清理测试残留用停用即可。
 
 ## 业务模型 `model`
 

package/skills/omc-start-here.md

@@ -12,7 +12,7 @@ be treated as a second source. Read this, then follow the topics it names.
 
 ## 最小路径（先读这段就能开始）
 
-0. **调用与检索（跨平台）**：`omc call ... --args '<json>'` 的内联 JSON 在 Windows PowerShell 下因引号转义不可靠——**PS 环境优先 `--args-file <path>`**（把 JSON 写临时文件再引用；解析失败的报错里也有此提示）。读命令输出默认把中文转义为 `\uXXXX`（防乱码）——**对输出做内容检索前先加 `--utf8`（单次明文）或先解 JSON，"grep 搜不到中文"≠"没有配置"**（静默假阴性坑）。**stdout 恒为纯 JSON 信封，人读进度（「已执行 xxx」等）走 stderr**——脚本解析别 `2>&1` 合流（r33/r34 两轮探针同坑），合流后从首个 `{` 截断。
+0. **调用与检索（跨平台）**：`omc call ... --args '<json>'` 的内联 JSON 在 Windows PowerShell 下因引号转义不可靠——**PS 环境优先 `--args-file <path>`**（把 JSON 写临时文件再引用；解析失败的报错里也有此提示）。读命令输出默认把中文转义为 `\uXXXX`（防乱码）——**对输出做内容检索前先加 `--utf8`（单次明文）或先解 JSON，"grep 搜不到中文"≠"没有配置"**（静默假阴性坑）。stdout 恒为纯 JSON、人读进度在 stderr——脚本解析勿 `2>&1` 合流。
 
 0. **拼装器优先（高频写面一条命令）**：整模型建模（模型+N 字段+子表+发布+表单）`omc model-scaffold`；**存量模型加字段（建→发布→重建表单→列表加列）`omc field-add`**；字段计算 `omc compute`；条件→动作 `omc rule-when`；线性审批流 `omc approval-flow`；表单默认值 `omc form-default`；存量盘点 `data.list all:true`——命中这些形态先看 `--help`，比 recipe 手拼省 10+ 轮。
 0c. **清理一个模型用 `omc model-purge --code <x> [--purge-instances] --apply`**——按依赖倒序（实例 → 模型级联带走流程/视图/字段/表单），**不要手工逐层删**：删部门/字段留下缓存或孤儿，会让后续调用出现「假 40009 / 假孤儿 / 全局待办 50000」这类幽灵故障（r12–r14 三次实测）。若返回 `unremovableInstances`（业务对象已删的停滞实例，平台 `delete_instance` NPE），按返回的 `maintainerAction` 让维护者清 `biz_workflow_instance`；**不要改用 model.delete 硬来**。

package/skills/omc-write-hazards.md

@@ -189,16 +189,24 @@ omc call field.publish --env local --args '{"schemaCode":"expense"}'
 ## 审批身份与角色作用域（r30 真机 2026-10-31）
 
 - `workitem.list` 只回**当前登录人**的待办：审批人配别人 → 看不到待办，`data.submit` 被 `submit-workitem-not-mine` 拒（40005）。演示闭环要么节点参与者用 `{Originator}`，要么把登录人加进审批角色。
-- **`org.role.addUsers` 必须紧跟 `org.role.setUserScope`**：只加成员不布作用域，平台不报错（仅 `org-role-member-scope-empty` 警告），但成员**无法被流程解析为参与人**。一对调用别做半。
-- **`transferDepartment` 迁人不迁作用域**（r33 真机）：用户换部门后 `role.userScope` 仍指旧部门——成员随人走、作用域不随人走；迁移后按业务复核各成员作用域。
-- **`user.delete` 是软删**（r33 真机）：回 `deleted:true` 但 `user.info` 仍 `exists:true`（`userStatus:DISABLE`）、部门树也可能仍见节点——验证口径用「列表/状态」，别声称物理清除。
+- **`org.role.addUsers` 必须紧跟 `setUserScope`**：不布作用域仅警告但成员无法被流程解析为参与人。一对调用别做半。
+- **`transferDepartment` 迁人不迁作用域**（r33 真机）：换部门后 `role.userScope` 仍指旧部门——迁移后复核成员作用域。
+- **`user.delete` 是软删**（r33 真机）：回 `deleted:true` 但 `user.info` 仍 `exists:true`（DISABLE）——验证口径用列表/状态，别称物理清除。
 - **「名称重复 200001」≠ 失败**（r33 真机）：多为首次已建成、重发才撞重复——先读回确认首建结果再决定。
+- **删了的东西≠删干净（孤儿三连，1101 三例）**：①删模型留收藏+h_biz_* 行→日志刷 `appFunction not exist`；②规则死服务 A1→submit 500015；③流程模板删后绑定残留（h_workflow_relative_object/header 指死 code）→getWorkflow 50000。都是删上游留下游引用、报错在别处——先查孤儿引用，维护者按表清。
+- **两套条件 DSL（r38/r39）**：listview.configure `conditions`={propertyCode, filterType, **defaultValue**}（值键叫 defaultValue）；data.list `filter`={op, field, value}。互抄必错——形状各查 `--param conditions`/`--param filter`。
+- **表单读回以控件清单为准，不看布尔位（r40）**：form.get 的 `published` 布尔会 false→true 抖动；draftViewJson 可含已删字段悬空引用（rebuild 自清）。判定布局依据=`publishedControlCodes` 内容；configure_form 回执已点名 `missingFieldCodes`。
+- **submit 被拒仍可能已落草稿（r40）**：`data.save --submit:true` 遇许可证/权限拒绝时平台可能在拒答前已写草稿——拒后 data.list 对账 total，残留 data.delete 单清。
+- **空聚合≠模型存在（r40）**：rule.list/datarule.list 对不存在模型静默回空——「0 条规则」≠模型在（mcc_contract 从不存在却一路答空）。rule.list 已修（空时探真身标 `modelPresent:false`）；datarule.list 同陷阱——判存在性一律 model.inspect。
+- **form.publish(rebuild) 后立即 submit 可能丢字段（r41 疑似竞态）**：链内演示行 `order_no` 落 null，同形状延迟复现正常。落演示行后 `data.load` 抽验非选项字段，缺值 data.save 单补，不重跑整链。
+- **data.list 选项列投影可为 null（r40/r41）**：`all:true`/queryCode 下 RADIO 读 null，`data.load`/`filter` 才有值——验证选项字段以 data.load 为权威。
+- **读回形状≠可写形状**（r38）：`listview.get` 读回条件带 `null` 字段，原样回写被拒——读回是输出形态，可写面有自己的契约；null 归一（false/省略）或只回写要改的键。
+- **data.list 的 columns 收窄可能静默空**（r38）：非视图列字段投影 null；甚至 columns+分页 total>0 而 items 0——判"无数据"先去 columns 复查或用 data.load。
 
 ## workflow.update 的行级替换语义（r32 真机 2026-10-31）
 
 - **`btnConfigList` 局部行=整行替换**：只传 `{code, remark}` 会把该按钮的 `enabled` 静默置 `false`、`commentPermission` 置 `null`（"驳回意见必填"丢失），同提交未提及的其他属性也被重置。改前先 `workflow.get_published`/`get_draft` 取整行，改目标属性后**整条回写**；`propertyPermissions` 同粒度。
-- 只改 `participant`/`btnConfigList` 的 activity 行**必须显式带 `type`**——省略 type 的豁免仅限带 `propertyPermissions` 的权限编辑行（拒绝信封已注明）。
-- **`SINGLE_PARTICIPANT` 配多角色只取第一个解析出的成员**（`MULTI_PARTICIPANT` 则全员会签）——演示/测试时"配置没生效"常是它；回读确认实际解析人。
+- **`SINGLE_PARTICIPANT` 多角色只取第一个解析成员**（MULTI 则全员会签）——"配置没生效"常是它，回读确认解析人。
 
 ## 跨表回写的真实语义（1.1.25 源码 + 真机 2026-10-20）