@stalfh233/omc-cli 0.5.8 → 0.5.10

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,9 +1747,13 @@ 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`)
+        .addHelpText("after", `\n存量模型加字段一条命令：建字段 → 发布字段 → 重建表单 → 列表追加列（列增量合并；固定条件整体替换）。\n默认 dry-run 只列计划；--apply 执行。幂等：字段已存在记 skipped 继续。\n子表不属于本命令（存量挂子表走 field.create CHILD_TABLE + 子列，见 model-scaffold）。\n\nr30/r31 探针实证：同一条链手工要走 4 次写调用 + 各自回读。\n`)
         .action(async (options) => {
         const rest = ["field-add",
             ...(options.schema ? ["--schema", options.schema] : []),
@@ -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

@@ -114,6 +114,8 @@ 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 原样透传）；",
@@ -121,6 +123,8 @@ export async function cmdFieldAdd(args, contextForTest) {
         "  默认 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 }));
@@ -143,6 +147,35 @@ 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;
@@ -195,7 +228,9 @@ export async function cmdFieldAdd(args, contextForTest) {
                 `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 依次执行全部步骤。",
@@ -275,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");
@@ -306,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/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/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,12 @@ 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 语义一致（含头不含尾）。

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.8",
+  "version": "0.5.10",
   "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.8",
+    "@stalfh233/omc-fake-platform": "0.5.10",
     "commander": "14.0.3",
-    "omc-core": "0.5.8",
+    "omc-core": "0.5.10",
     "proper-lockfile": "4.1.2",
     "write-file-atomic": "6.0.0",
     "zod": "^3.23.8",

package/skills/omc-write-hazards.md

@@ -189,11 +189,19 @@ 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` 警告），但成员**无法被流程解析为参与人**。一对调用别做半。
+- **`org.role.addUsers` 必须紧跟 `setUserScope`**：不布作用域仅警告但成员无法被流程解析为参与人。一对调用别做半。
 - **`transferDepartment` 迁人不迁作用域**（r33 真机）：换部门后 `role.userScope` 仍指旧部门——迁移后复核成员作用域。
 - **`user.delete` 是软删**（r33 真机）：回 `deleted:true` 但 `user.info` 仍 `exists:true`（DISABLE）——验证口径用列表/状态，别称物理清除。
 - **「名称重复 200001」≠ 失败**（r33 真机）：多为首次已建成、重发才撞重复——先读回确认首建结果再决定。
-- **删模型≠删干净（收藏夹死引用）**（2026-11-01 真机）：模型删除后用户收藏（`h_user_favorites`，含 `_wf` 变体）与 h_biz_property/query/sheet/data_rule/button/method_mapping 等行残留——之后**每次**数据读写都在 launcher 日志抛 `appFunction not exist, schemaCode:<死模型>`（刷屏不阻断）。清理=按 schemaCode 关联删八表+收藏（维护者）；见此报错先查收藏夹。
+- **删了的东西≠删干净（孤儿三连，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）