@stalfh233/omc-cli 0.4.99 → 0.4.101

package/dist/goal-routes.js

@@ -146,7 +146,13 @@ function bestRecipe(registry, capabilityId, lane, goal, minScore = 3) {
         if (tool.lane !== lane)
             continue;
         for (const recipe of tool.executionMetadata?.recipes ?? []) {
-            const score = overlap(goal, `${recipe.title} ${recipe.id} ${(recipe.aliases ?? []).join(" ")}`);
+            // r19 ticket 04: an authored ALIAS phrase present in the goal is a much
+            // stronger signal than bigram overlap — "…汇总另一个模型的…" must route to
+            // formula-aggregation-cross-model, not the title-overlapping dropdown
+            // recipe. +20 per exact alias hit keeps authored intent decisive while
+            // overlap still ranks within equally aliased candidates.
+            const aliasBonus = (recipe.aliases ?? []).reduce((sum, alias) => (goal.includes(alias) ? sum + 20 : sum), 0);
+            const score = overlap(goal, `${recipe.title} ${recipe.id} ${(recipe.aliases ?? []).join(" ")}`) + aliasBonus;
             if (score >= minScore && (best === undefined || score > best.score))
                 best = { tool: tool.name, recipe: recipe.id, title: recipe.title, score };
         }
@@ -265,50 +271,39 @@ function sectionPointersFor(ids) {
     return pointers;
 }
 /**
- * Ready-to-run methodology reads.
+ * Ready-to-run methodology reads — r19 ticket 04: ONE pointer, not a shelf.
  *
- * Round 15 (bench60-62) collapsed ~18 per-section reads into one per topic to
- * save turns. r10 F7 found the other edge: following that hint fetched
- * EVERYTHING at once (~15 KB) when most tasks need only the first section.
- * So the primary command per topic fetches the FIRST required section, and the
- * remaining sections are offered as separate incremental commands (each keeps
- * its byte count in `readSections`) — cheap by default, still one command away.
+ * Round 15 collapsed per-section reads; r10 F7 made the first section cheap.
+ * r18 then showed the residual cost is ATTENTION, not bytes: seven pointers
+ * made the agent crawl methodology before acting, and the generic draft
+ * template ("3. Draft template") was read and produced nothing on
+ * recipe-matched routes. So: a recipe-matched route carries NO pointer (the
+ * recipe command is the answer); otherwise exactly one — the first authored
+ * pointer that is not the omc-config-draft-review human-gate template (that
+ * gate is conversational, not a section to prefetch), falling back to the
+ * first pointer when every authored pointer is draft-review.
  */
-function splitReadCommands(pointers) {
-    const byTopic = new Map();
-    for (const pointer of pointers)
-        byTopic.set(pointer.topic, [...(byTopic.get(pointer.topic) ?? []), pointer.section]);
-    const readCommands = [];
-    const readMore = [];
-    for (const [topic, sections] of byTopic.entries()) {
-        readCommands.push(`omc help ${topic} --section "${sections[0]}"`);
-        for (const section of sections.slice(1))
-            readMore.push(`omc help ${topic} --section "${section}"`);
-    }
-    return { readCommands, readMore };
+function pickSectionPointer(pointers, recipeMatched) {
+    if (recipeMatched || pointers.length === 0)
+        return [];
+    const specific = pointers.find((pointer) => pointer.topic !== "omc-config-draft-review");
+    return [specific ?? pointers[0]];
 }
+const FIRST_SECTION_INLINE_BUDGET_BYTES = 2048;
 /**
- * The route's methodology-read surface: pointers (+ per-section bytes) +
- * ready-to-run batched commands + hint.
- *
- * F9 (r10-friction): the most common task flow was `next` followed
- * IMMEDIATELY by fetching the first readSection — one extra process +
- * round-trip every task. The first section now rides inline when it fits the
- * inline budget (~2 KB); larger sections stay pointer-only so `next` never
- * balloons.
+ * r19 ticket 04: a multi-capability ladder already carries tool maps and
+ * recipes, so its inline section budget is tighter — the 4096B `next` ceiling
+ * must survive a ladder + a 2.5KB section (r18: "工作流审批流程" would have
+ * been 4729B). Single-capability routes keep the fuller budget (F9).
  */
-const FIRST_SECTION_INLINE_BUDGET_BYTES = 2560;
-function routeReads(readSections) {
-    // Per-section UTF-8 bytes ride each pointer (one field, not a parallel array)
-    // so a caller can budget which sections to fetch — dogfood R1 found the
-    // batched readCommands could exceed a window with no way to see sizes.
-    const budgeted = readSections.map((pointer) => ({ ...pointer, bytes: sectionBytes(pointer) }));
-    // Inline the FIRST pointer that fits the budget (order = relevance); an
-    // oversized head section falls through to the next fitting one rather than
-    // dropping the inline content entirely.
+const LADDER_INLINE_BUDGET_BYTES = 1200;
+function routeReads(readSections, recipeMatched = false, inlineBudget = FIRST_SECTION_INLINE_BUDGET_BYTES) {
+    const budgeted = pickSectionPointer(readSections, recipeMatched).map((pointer) => ({ ...pointer, bytes: sectionBytes(pointer) }));
+    // Inline the ONE pointer's content when it fits the budget: the agent then
+    // needs zero extra calls for methodology (F9, r10-friction).
     let firstSection;
-    for (const pointer of budgeted.slice(0, 3)) {
-        if (pointer.bytes > 0 && pointer.bytes <= FIRST_SECTION_INLINE_BUDGET_BYTES) {
+    for (const pointer of budgeted) {
+        if (pointer.bytes > 0 && pointer.bytes <= inlineBudget) {
             const resolved = readSkillSection(pointer.topic, pointer.section);
             if (resolved) {
                 firstSection = { topic: pointer.topic, section: pointer.section, bytes: pointer.bytes, content: resolved.section };
@@ -316,15 +311,19 @@ function routeReads(readSections) {
             }
         }
     }
-    const commands = splitReadCommands(readSections);
-    return { readSections: budgeted, readCommands: commands.readCommands, ...(commands.readMore.length > 0 ? { readMore: commands.readMore } : {}), readHint: READ_HINT, ...(firstSection !== undefined ? { firstSection } : {}) };
+    return {
+        readSections: budgeted,
+        readCommands: budgeted.map((pointer) => `omc help ${pointer.topic} --section "${pointer.section}"`),
+        readHint: READ_HINT,
+        ...(firstSection !== undefined ? { firstSection } : {}),
+    };
 }
 /** UTF-8 byte length of one methodology section (best-effort; 0 when unreadable). */
 function sectionBytes(pointer) {
     const resolved = readSkillSection(pointer.topic, pointer.section);
     return resolved ? Buffer.byteLength(resolved.section, "utf8") : 0;
 }
-const READ_HINT = '先跑 readCommands（每个 topic 只取第一节，形状 `omc help <topic> --section "<section>"`，字节数见 readSections）；不够再按需补 readMore，不要一次全读。`omc help <topic>` 默认只回节索引（每节带字节数，约 1KB），不要再用 `--all` 读整篇（5–14KB，读一次就留在后续每一轮）。';
+const READ_HINT = '方法论只挂最相关的一节（readSections[0] 带字节数，`omc help <topic> --section "<节>"` 可回放，firstSection 已内联时就不用再取）；其他具体问题（错误码/跨能力语义/某个词）用 `omc help --search "<词>"` 一步全文检索；不要 `--all` 读整篇。';
 function orderedCapabilities(ids, index) {
     const selected = new Set(ids);
     const nodes = [...index.nodeById.values()];
@@ -434,6 +433,21 @@ const COMPOSER_ROUTES = Object.freeze([
 ]);
 /** Test seam: the composer registry, so a template typo can be caught offline. */
 export const COMPOSER_ROUTES_FOR_TEST = COMPOSER_ROUTES;
+/**
+ * r19 ticket 04 — the ONE question that unlocks each composer. A composer
+ * skeleton always carries placeholders, so a composer match is a `needs-input`
+ * first answer by definition; the question names exactly what to fill in.
+ */
+const COMPOSER_QUESTIONS = Object.freeze({
+    "model-purge": "要清理哪个模型？给我 schemaCode（不确定就先跑下面的只读判别动作拿清单）",
+    "model-scaffold": "给我模型 code、显示名和字段清单（每字段 code/名称/类型；子表放 subFields），我一条命令建完",
+    "approval-flow": "目标模型 schemaCode 和每级审批节点（节点名@角色code，多级用重复 --steps）是什么？",
+    compute: "目标模型 schemaCode、结果字段 code、公式是什么？（子表条件聚合再加 --where \"子列 = 值\"）",
+    "rule-when": "目标模型 schemaCode、触发时机（Create/Update…）、条件（--when）和动作（--then）各是什么？",
+    "form-default": "目标模型 schemaCode、字段 code 和默认值是什么？",
+});
+/** The read-only discriminator that supplies a missing schema code. */
+const LIST_MODELS_ACTION = "omc call model.list --args '{}'";
 function matchComposer(goal, mode) {
     // A composer is a WRITE path: reads and scouting asks must keep their ladder.
     if (mode !== "build" && mode !== "modify")
@@ -471,11 +485,19 @@ function wholePackageRoute(registry, goal, index) {
             primary: "intent",
             atomicSupplement: { note: "intent 已覆盖下列能力的创建；这些原子工具只用于 intent 未覆盖面（删除/生命周期/运行数据/精确 patch）：", ladder },
             ...routeReads(sectionPointersFor(ordered)),
-            firstCommands: [DISCOVERY_AUTHORITY.readiness],
+            // r19 ticket 04: readiness (discover_environment) left firstCommands —
+            // the probe executed it 0 times in 184 calls; it rides its own field now.
+            readiness: DISCOVERY_AUTHORITY.readiness,
+            firstCommands: ["omc intent schema"],
             write: true,
         },
         write: true,
         intent: intentGuidance(),
+        firstAnswer: {
+            state: "ready",
+            action: "omc intent schema",
+            why: "整包需求走声明式意图：先看 intent YAML 的键位与可运行示例，再按 starter 写文件（validate → plan → apply）",
+        },
     };
 }
 /** A configuration read-back ask that names no capability ("给我一份现状说明"). */
@@ -490,8 +512,13 @@ function readOverviewRoute(registry, goal, index) {
         confident: true,
         mode: "read",
         match: { kind: "read-overview", ref: ordered.join("→"), capabilities: ordered },
-        route: { ladder, ...routeReads(sectionPointersFor(["environment"])), firstCommands: [DISCOVERY_AUTHORITY.readiness], write: false, readback: true },
+        route: { ladder, ...routeReads(sectionPointersFor(["environment"])), readiness: DISCOVERY_AUTHORITY.readiness, firstCommands: [LIST_MODELS_ACTION], write: false, readback: true },
         write: false,
+        firstAnswer: {
+            state: "ready",
+            action: LIST_MODELS_ACTION,
+            why: "盘点从模型清单开始：一次调用拿到全部 schemaCode，后续读面（inspect/field.list）据此展开",
+        },
     };
 }
 export function goalRoute(registry, goal) {
@@ -522,12 +549,45 @@ export function goalRoute(registry, goal) {
                 verify: "omc capabilities / omc capability <id>（运行时清单才是权威边界；能力表只是阅读辅助）",
                 topics: ["omc-requirement-analysis", "omc-capability-scouting"].filter((topic) => availableTopics.has(topic)),
             },
-            route: { write: false, readback: false, firstCommands: ["omc capabilities", "omc capability <id>", "omc help omc-capability-scouting"] },
+            route: { write: false, readback: false, readiness: DISCOVERY_AUTHORITY.readiness, firstCommands: ["omc capabilities", "omc capability <id>", "omc help omc-capability-scouting"] },
+            firstAnswer: { state: "blocked", why: boundary.note },
         };
     }
     // Composer before the capability solver: a recurring write SHAPE has a single
     // command that does the job with preflight + idempotency, which beats a ladder
     // of atomic tools even when the ladder also matches (r13: 26 field.create).
+    // r19 券商 issue 1.1（2026-10-27）：子表**控件**（type 201）的显示/只读条件
+    // （displayFormula/readonlyFormula）不在字段面——field.update 对子表只管**列**、
+    // 对控件条件必拒；唯一路径是表单 attributes（form.get 读 draftAttributesJson
+    // 定位控件 → form.draft 改 → form.publish）。此前该场景路由进 field→form 梯子
+    // 且首级无可行工具（firstCommands 为空），agent 只能靠拒收文案自己悟。
+    if (/子表|控件/.test(goal) && /子表.*(显示|隐藏|只读|显隐).*(条件|公式|规则)|displayFormula|readonlyFormula/.test(goal)) {
+        return {
+            status: "ok",
+            goal,
+            confident: true,
+            mode: "modify",
+            write: true,
+            match: { kind: "capability", ref: "form", title: "子表控件显示/只读条件（表单 attributes 面）" },
+            route: {
+                capability: "form",
+                note: "子表控件的 displayFormula/readonlyFormula 走表单 attributes：form.get(controls:true) 读 draftAttributesJson 定位控件 → form.draft 改该控件条件 → form.publish。field.update 只管子表列，对控件条件必拒（券商 issue 2026-10-27 实证）",
+                readiness: DISCOVERY_AUTHORITY.readiness,
+                firstCommands: [
+                    "omc call form.get --args '{\"schemaCode\":\"<schemaCode>\",\"controls\":true}'",
+                    "omc describe form.draft",
+                ],
+                write: true,
+            },
+            firstAnswer: {
+                state: "needs-input",
+                question: "目标模型 schemaCode 与子表控件 code 是什么？（form.get controls:true 读 draftAttributesJson 定位控件，form.draft 改其条件后 form.publish）",
+                action: LIST_MODELS_ACTION,
+                pendingCommand: "omc call form.draft --args '{\"schemaCode\":\"<schemaCode>\",\"draftAttributesJson\":\"<改好后的完整 attributes JSON>\"}'",
+                why: "子表控件（type 201）的显示/只读条件在表单 attributes，不在字段面——field.update 对子表只管列、必拒",
+            },
+        };
+    }
     const composer = matchComposer(goal, mode);
     if (composer) {
         const topics = (composer.topics ?? []).filter((topic) => availableTopics.has(topic));
@@ -542,14 +602,22 @@ export function goalRoute(registry, goal) {
                 composer: composer.id,
                 command: composer.command,
                 summary: composer.summary,
-                // The composer IS the first step; readiness still comes first because
-                // the command needs a bound environment to run.
-                firstCommands: [DISCOVERY_AUTHORITY.readiness, composer.command, composer.usage],
+                readiness: DISCOVERY_AUTHORITY.readiness,
+                // The composer IS the first step (its skeleton waits on the ONE
+                // question in firstAnswer; discover_environment no longer occupies
+                // the head slot — r18 executed it 0 times in 184 calls).
+                firstCommands: [composer.command, composer.usage],
                 write: true,
                 readback: true,
-                ...(topics.length > 0 ? { readCommands: topics.map((topic) => `omc help ${topic} --section "<节>"`), readHint: "只在 composer 的 --help 不够用时再读这些 topic 的对应节" } : {}),
             },
             ...(topics.length > 0 ? { topics } : {}),
+            firstAnswer: {
+                state: "needs-input",
+                question: COMPOSER_QUESTIONS[composer.id] ?? "补齐命令里的尖括号占位符后运行（形状见 pendingCommand）",
+                pendingCommand: composer.command,
+                ...(composer.id === "model-purge" || composer.id === "compute" ? { action: LIST_MODELS_ACTION } : {}),
+                why: composer.summary,
+            },
         };
     }
     const scores = [...capabilityScores(registry, goal).entries()].sort((left, right) => right[1] - left[1]);
@@ -562,6 +630,13 @@ export function goalRoute(registry, goal) {
         topics: [...availableTopics],
         write: false,
         mode,
+        // Not confident → say so and hand ONE next move instead of a topic shelf.
+        firstAnswer: {
+            state: "needs-input",
+            question: "把目标说成一个具体动作短语（对象 + 动作，如「给 X 模型加一个汇总字段」），我就能给出一步可跑的命令",
+            action: "omc help omc-requirement-analysis",
+            why: "没命中任何能力线索；不猜路径（precision over recall）",
+        },
     };
     const best = scores[0];
     if (best === undefined) {
@@ -601,6 +676,12 @@ export function goalRoute(registry, goal) {
         const readSections = sectionPointersFor(ordered);
         const write = readish ? false : ordered.some((id) => routeById.get(id)?.tools.some((name) => registryTools.get(name)?.kind === "write"));
         const whole = isWholePackageWrite(mode, goal, ordered.length);
+        // r19 ticket 04: the ladder's first RECIPE command is the first answer
+        // when one exists (its describe carries the copyable firstCall shape);
+        // otherwise the only missing input is the target object code.
+        const recipeCommands = ladder.flatMap((step) => step.recipe?.command ? [step.recipe.command] : []);
+        const firstAction = recipeCommands[0];
+        const firstRecipeId = ladder.find((step) => step.recipe) && (ladder.find((step) => step.recipe).recipe.id);
         // When intent is the primary path, the atomic ladder is only a POINTER to the
         // capabilities (dogfood R1: repeating every tool map was ~60% unused bytes).
         const atomicSupplement = { note: "intent 已覆盖这些能力的创建；原子工具只用于 intent 未覆盖面：", ladder: ladder.map((step) => ({ capability: step.capability, lane: step.lane, firstCommand: step.firstCommand ?? `omc commands --json --compact --lane ${step.lane}` })) };
@@ -612,13 +693,14 @@ export function goalRoute(registry, goal) {
             match: { kind: readish ? "read-ladder" : "ladder", ref: ordered.join("→"), capabilities: ordered },
             route: {
                 ...(whole ? { primary: "intent", atomicSupplement } : { ladder }),
-                ...routeReads(readSections),
+                ...routeReads(readSections, recipeCommands.length > 0, LADDER_INLINE_BUDGET_BYTES),
+                readiness: DISCOVERY_AUTHORITY.readiness,
                 // r18: when a step already carries a goal-matched recipe, the generic
                 // first section ("3. Draft template") is noise — the probe read it and
                 // got nothing. Say that the recipe command is the answer and the
                 // sections are only a fallback.
-                ...(ladder.some((step) => step.recipe)
-                    ? { readHint: "已命中配方：先跑 firstCommands 里的 `omc describe … --example …` 取形状；下面的 readSections 只是补充，不必先读（确实需要时用 `omc help <topic> --section \"<节>\"`，按 readMore 逐节补）。" }
+                ...(recipeCommands.length > 0
+                    ? { readHint: "已命中配方：先跑 firstCommands 里的 `omc describe … --example …` 取形状（首答自带 firstCall 可照抄）；方法论节已按需收缩，确实需要时用 `omc help <topic> --section \"<节>\"`。" }
                     : {}),
                 // Each ladder step already carried a runnable recipe command, but it sat
                 // buried at `ladder[i].recipe.command` behind a readiness line — r14's
@@ -626,8 +708,7 @@ export function goalRoute(registry, goal) {
                 // graph instead. Surface them at the top level where `firstCommands` is
                 // the thing an agent actually reads.
                 firstCommands: [
-                    DISCOVERY_AUTHORITY.readiness,
-                    ...ladder.flatMap((step) => step.recipe?.command ? [step.recipe.command] : []),
+                    ...recipeCommands,
                     // r13 #3: `capability workflow --executable` is 23 KB and still did not
                     // answer "how do I submit an approval" — the answer is a data.submit
                     // recipe, which lives in a DIFFERENT capability. When the goal is about
@@ -640,7 +721,17 @@ export function goalRoute(registry, goal) {
                 ...(readish ? { readback: true } : {}),
             },
             write,
-            ...(whole ? { intent: intentGuidance() } : {}),
+            ...(whole
+                ? { intent: intentGuidance(), firstAnswer: { state: "ready", action: "omc intent schema", why: "整包需求走声明式意图：先看 intent 的键位与示例，再按 starter 写文件" } }
+                : readish
+                    // A read ask about the model inventory itself is answered BY the
+                    // inventory call; any other read needs the target object code first.
+                    ? ordered.every((id) => id === "environment" || id === "model")
+                        ? { firstAnswer: { state: "ready", action: LIST_MODELS_ACTION, why: "问的就是模型清单本身：model.list 一次调用直接回答" } }
+                        : { firstAnswer: { state: "needs-input", question: "要查看哪个对象？给我 schemaCode（或业务名，我列清单核对）", action: LIST_MODELS_ACTION, why: "读路径命中多个能力：readTools 已内联，只差目标对象 code" } }
+                    : firstAction !== undefined
+                        ? { firstAnswer: { state: "ready", action: firstAction, why: `命中配方 ${firstRecipeId}：describe 首答自带 firstCall 形状，代入你的 schemaCode/字段 code 即可执行` } }
+                        : { firstAnswer: { state: "needs-input", question: "第一步要操作哪个对象？给我 schemaCode（或模型业务名，我列清单核对）", action: LIST_MODELS_ACTION, why: "未命中配方：需要目标对象 code 才能给出一步可跑的写命令" } }),
         };
     }
     // Single-capability mode: when several capabilities tie, a matching recipe
@@ -651,7 +742,7 @@ export function goalRoute(registry, goal) {
         return fallback;
     const write = readish ? false : route.tools.some((name) => registryTools.get(name)?.kind === "write");
     const recipe = readish ? undefined : bestRecipe(registry, capabilityId, route.lane, goal);
-    const firstCommands = [DISCOVERY_AUTHORITY.readiness];
+    const firstCommands = [];
     if (recipe)
         firstCommands.push(`omc describe ${recipe.tool} --example ${recipe.recipe}`);
     if (readish)
@@ -666,6 +757,7 @@ export function goalRoute(registry, goal) {
     if (!readish && /审批|通过|驳回|提交|签收/.test(goal) && (capabilityId === "workflow" || capabilityId === "runtimeData"))
         firstCommands.push("omc describe data.submit --example workflow-backed-data-submit");
     const whole = isWholePackageWrite(mode, goal, 1);
+    const recipeCommand = recipe ? `omc describe ${recipe.tool} --example ${recipe.recipe}` : undefined;
     return {
         status: "ok",
         goal,
@@ -683,13 +775,23 @@ export function goalRoute(registry, goal) {
             lane: route.lane,
             ...(whole ? { primary: "intent" } : {}),
             ...(readish ? { readTools: readToolsInLane(registry, route.lane) } : { tools: route.tools }),
-            ...routeReads(sectionPointersFor([capabilityId])),
+            ...routeReads(sectionPointersFor([capabilityId]), recipe !== undefined),
+            readiness: DISCOVERY_AUTHORITY.readiness,
             firstCommands,
             write,
             ...(readish ? { readback: true } : {}),
         },
         write,
         ...(whole ? { intent: intentGuidance() } : {}),
+        ...(whole
+            ? { firstAnswer: { state: "ready", action: "omc intent schema", why: "整包需求走声明式意图：先看 intent 的键位与示例，再按 starter 写文件" } }
+            : readish
+                ? capabilityId === "model"
+                    ? { firstAnswer: { state: "ready", action: LIST_MODELS_ACTION, why: "问的就是模型清单本身：model.list 一次调用直接回答" } }
+                    : { firstAnswer: { state: "needs-input", question: "要查看哪个对象？给我 schemaCode（或业务名，我列清单核对）", action: LIST_MODELS_ACTION, why: `读路径命中能力 ${capabilityId}：readTools 已内联，只差目标对象 code` } }
+                : recipeCommand !== undefined
+                    ? { firstAnswer: { state: "ready", action: recipeCommand, why: `命中配方 ${recipe.recipe}：describe 首答自带 firstCall 形状，代入你的 schemaCode/字段 code 即可执行` } }
+                    : { firstAnswer: { state: "needs-input", question: "要操作哪个对象？给我 schemaCode（或模型业务名，我列清单核对）", action: LIST_MODELS_ACTION, why: "未命中配方：需要目标对象 code 才能给出一步可跑的写命令" } }),
     };
 }
 //# sourceMappingURL=goal-routes.js.map

package/dist/governed-execution.js

@@ -20,7 +20,7 @@ export async function admitGovernedWrite(ctx, request) {
             blocker: "environment-write-disabled",
             environment: resolved.name,
             production: resolved.profile.production === true,
-            message: `${environmentNotice(resolved.profile)} 请在 omc setup 中开启“允许写入此环境”。`,
+            message: `${environmentNotice(resolved.profile)} 请在 omc setup 中开启“允许写入此环境”。若你本意是写项目环境：检查当前目录是否项目根（.omc-env 所在目录）——在其它目录跑 omc 会解析不到项目环境而落到全局只读策略，cd 回项目根再试。`,
         });
     let session;
     try {

package/dist/lanes/b2-registration.js

@@ -416,7 +416,7 @@ export function registerB2Lane(tools) {
         });
         const afterRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data);
         const after = afterRows.find((row) => row.code === args.methodCode);
-        return { performed: { errcode: performed.errcode }, readback: { methodPresent: after != null, nameMatches: args.name === undefined || after?.name === args.name, configMatches: methodConfigPlain === undefined || after?.configJson === methodConfigPlain, inputParameters: decodeJsonColumn(after?.inputParametersJson), outputParameters: decodeJsonColumn(after?.outputParametersJson) } };
+        return { performed: { errcode: performed.errcode }, readback: { methodCode: args.methodCode, methodPresent: after != null, nameMatches: args.name === undefined || after?.name === args.name, configMatches: methodConfigPlain === undefined || after?.configJson === methodConfigPlain, inputParameters: decodeJsonColumn(after?.inputParametersJson), outputParameters: decodeJsonColumn(after?.outputParametersJson), mappingNote: "规则映射直接用这里的参数 code（bizPropertyType 供类型对账），不必再 service.get" } };
     }, (args) => {
         assertStructuredConfig(args.methodConfig, "methodConfig");
     }, undefined, b2ServiceRollbackSpec("method.update"));
@@ -463,7 +463,7 @@ export function registerB2Lane(tools) {
         });
         const afterRows = wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data);
         const after = afterRows.find((row) => row.code === args.methodCode);
-        return { performed: { errcode: performed.errcode }, readback: { methodPresent: after != null, nameMatches: after?.name === args.name, configMatches: methodConfigPlain === undefined || after?.configJson === methodConfigPlain, inputParameters: decodeJsonColumn(after?.inputParametersJson), outputParameters: decodeJsonColumn(after?.outputParametersJson) } };
+        return { performed: { errcode: performed.errcode }, readback: { methodCode: args.methodCode, methodPresent: after != null, nameMatches: after?.name === args.name, configMatches: methodConfigPlain === undefined || after?.configJson === methodConfigPlain, inputParameters: decodeJsonColumn(after?.inputParametersJson), outputParameters: decodeJsonColumn(after?.outputParametersJson), mappingNote: "规则映射直接用这里的参数 code（bizPropertyType 供类型对账），不必再 service.get" } };
     }, (args) => {
         assertStructuredConfig(args.methodConfig, "methodConfig");
     }, undefined, b2ServiceRollbackSpec("method.create"));
@@ -850,9 +850,26 @@ export function registerB2Lane(tools) {
             ? wireRows((await wireCall(session, { path: ENDPOINTS.bizServiceMethodList, query: { serviceCode: args.serviceCode, filterFlag: "false" } })).data)
             : [];
         const registered = args.methodName ? methodRows.some((row) => row.code === args.methodName) : undefined;
+        // r19 p7：readback 只回布尔时，agent 只能再调 service.get 拿参数 code（12 次里
+        // 6 次是这种写后验证读）。方法视图内联进 readback，rule.save 的 methodMapping
+        // 直接用这里的 code，不必再读。
+        const methodRow = args.methodName ? methodRows.find((row) => row.code === args.methodName) : undefined;
         return {
             performed: { errcode: performed.errcode },
-            readback: { servicePresent: readback.data != null, ...(registered !== undefined ? { methodPresent: registered, methodCount: methodRows.length } : {}) },
+            readback: {
+                servicePresent: readback.data != null,
+                ...(registered !== undefined ? { methodPresent: registered, methodCount: methodRows.length } : {}),
+                ...(methodRow !== undefined
+                    ? {
+                        method: {
+                            code: methodRow.code,
+                            inputParameters: decodeJsonColumn(methodRow.inputParametersJson),
+                            outputParameters: decodeJsonColumn(methodRow.outputParametersJson),
+                        },
+                        mappingNote: "rule.save 的 methodMapping 直接用上面的参数 code：inputMappings.bizCode=来源字段 code、serviceMethodParameterCode=参数 code；不必再 service.get",
+                    }
+                    : {}),
+            },
         };
     }, (args) => {
         // Dry-lint (zero wire). `omc call` bypasses zod, so every schema-level

package/dist/lanes/businessrule-contract.js

@@ -151,6 +151,10 @@ export const BUSINESSRULE_LANE_CONTRACT = Object.freeze({
             scope: "rule node route readback",
             description: "读回一条业务规则的完整定义（businessrule/get?id=），解析并回显 node/route 图 JSON（触发节点、UPDATE/CREATE 动作节点的 targetObjectCode/inputParam/dataActions/filterCondition 等）——规则族读写链的权威读回面，也是对照设计器生成图形的取证入口。",
         }),
+        "rule.references": Object.freeze({
+            scope: "cross-rule reference search",
+            description: "跨规则引用检索（r23 实证的能力缺失：agent 为查『谁引用了服务 X』枚举了全平台 147 个 schema×ruleCode 组合/171 次 rule.get——本工具一调替代）。kind=service 查 BIZ_ACTION 的 methodMapping.serviceCode；kind=model 查 CREATE/UPDATE/DELETE 的 targetObjectCode 与 methodMapping.schemaCode（删模型前的影响面）；kind=field 查 dataActions.targetDataItem 与 inputMappings/outputMappings 的 bizCode（删字段前的影响面；字段 code 跨模型不唯一，建议配 schemaCodes 限范围）。实现为客户端聚合（model.list→rule.list→rule.get 全扫，约几十次 wire 读、几秒完），输出只回命中行。第一版不含：条件叶子里的字段引用、datarule 引用、workflow.bindRule 绑定。",
+        }),
         "rule.save": Object.freeze({
             scope: "dead-state CRUD conditional node graphs",
             description: RULE_SAVE_DESCRIPTION,

package/dist/lanes/businessrule-coverage.js

@@ -10,7 +10,7 @@ export const BUSINESSRULE_COVERAGE = declareLaneCoverage(BUSINESSRULE_LANE_CONTR
     {
         capability: "rule.list latest business-rule listing and rule.get node route definition readback",
         evidence: ["packages/omc-cli/src/tools.ts", "packages/omc-cli/test/rule-list.test.ts"],
-        tools: [claim("rule.list", T["rule.list"].scope), claim("rule.get", T["rule.get"].scope)],
+        tools: [claim("rule.list", T["rule.list"].scope), claim("rule.get", T["rule.get"].scope), claim("rule.references", T["rule.references"].scope)],
     },
 ]);
 //# sourceMappingURL=businessrule-coverage.js.map

package/dist/lanes/businessrule.js

@@ -116,6 +116,99 @@ export function registerBusinessRuleLane(tools) {
             };
         }, { full: args.full === true, target: `rule.list:${args.schemaCode}` }),
     }));
+    tools.push(defineTool({
+        name: "rule.references",
+        layer: "low",
+        kind: "read",
+        lane: RULE_LANE,
+        scope: RULE_TOOLS["rule.references"].scope,
+        description: RULE_TOOLS["rule.references"].description,
+        inputSchema: {
+            environment: environmentArg,
+            kind: z.enum(["service", "model", "field"]).describe("按什么找引用：service=BIZ_ACTION methodMapping.serviceCode；model=CREATE/UPDATE/DELETE targetObjectCode 与 methodMapping.schemaCode；field=dataActions.targetDataItem 与映射 bizCode"),
+            code: z.string().min(1).describe("要查引用的编码（服务 code / 模型 code / 字段 code）"),
+            schemaCodes: z.union([z.array(z.string().min(1)), z.string()]).optional().describe("只扫这些模型（省 wire 读）；省略=全平台模型"),
+            capability: capabilityArg,
+        },
+        handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
+            // r23（2026-10-27）：agent 为查「谁引用了服务 X」枚举了 147 个
+            // schema×ruleCode 组合（171 次 rule.get / 229KB）。没有引用检索面时，
+            // 全库枚举是理性选择——所以给它一个。客户端聚合：模型清单 → 每模型
+            // rule.list → 每规则 rule.get → 图内匹配，一次调用、只回命中行。
+            const scoped = args.schemaCodes === undefined
+                ? wireRows((await wireCall(session, { path: ENDPOINTS.modelList })).data).map((row) => String(row.schemaCode ?? "")).filter((code) => code !== "")
+                : (Array.isArray(args.schemaCodes) ? args.schemaCodes : [args.schemaCodes]);
+            const wanted = args.code;
+            const matches = [];
+            let scannedRules = 0;
+            let parseFailures = 0;
+            for (const schemaCode of scoped) {
+                let rows = [];
+                try {
+                    rows = wireRows((await wireCall(session, { path: ENDPOINTS.businessRuleListBySchemaCode, query: { schemaCode } })).data);
+                }
+                catch {
+                    continue; // 模型无规则面（读失败/空）按无规则处理，不让单个模型挡住全扫
+                }
+                for (const row of rows) {
+                    const ruleCode = String(row.code ?? "");
+                    const ruleId = row.id;
+                    scannedRules += 1;
+                    if (typeof ruleId !== "string" || ruleId === "")
+                        continue;
+                    let record = null;
+                    try {
+                        record = (await wireCall(session, { path: ENDPOINTS.businessRuleGet, query: { id: ruleId } })).data;
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (!record)
+                        continue;
+                    const nodes = decodeJsonColumn(record.node, JSON_COLUMN_NULL_COALESCE);
+                    if (!Array.isArray(nodes)) {
+                        parseFailures += 1;
+                        continue;
+                    }
+                    for (const rawNode of nodes) {
+                        const nodeCode = String(rawNode.nodeCode ?? "");
+                        const nodeType = String(rawNode.nodeType ?? "");
+                        const mapping = rawNode.methodMapping;
+                        if (args.kind === "service") {
+                            if (nodeType === "BIZ_ACTION" && mapping && String(mapping.serviceCode ?? "") === wanted)
+                                matches.push({ schemaCode, ruleCode, nodeCode, nodeType, via: "methodMapping.serviceCode" });
+                        }
+                        else if (args.kind === "model") {
+                            if (["CREATE", "UPDATE", "DELETE"].includes(nodeType) && String(rawNode.targetObjectCode ?? "") === wanted)
+                                matches.push({ schemaCode, ruleCode, nodeCode, nodeType, via: "targetObjectCode" });
+                            if (mapping && String(mapping.schemaCode ?? "") === wanted)
+                                matches.push({ schemaCode, ruleCode, nodeCode, nodeType, via: "methodMapping.schemaCode" });
+                        }
+                        else {
+                            if (["CREATE", "UPDATE", "DELETE"].includes(nodeType) && Array.isArray(rawNode.dataActions)
+                                && rawNode.dataActions.some((action) => String(action.targetDataItem ?? "") === wanted))
+                                matches.push({ schemaCode, ruleCode, nodeCode, nodeType, via: "dataActions.targetDataItem" });
+                            if (mapping) {
+                                for (const [key, label] of [["inputMappings", "inputMappings.bizCode"], ["outputMappings", "outputMappings.bizCode"]]) {
+                                    if (Array.isArray(mapping[key]) && mapping[key].some((row2) => String(row2.bizCode ?? "") === wanted && (row2.codeType === undefined || row2.codeType === 1)))
+                                        matches.push({ schemaCode, ruleCode, nodeCode, nodeType, via: label });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return {
+                kind: args.kind,
+                code: wanted,
+                scanned: { models: scoped.length, rules: scannedRules, ...(parseFailures > 0 ? { parseFailures } : {}) },
+                matches,
+                ...(matches.length === 0
+                    ? { note: "零命中=全平台（或指定 schemaCodes 范围内）没有规则引用它。范围：service→methodMapping.serviceCode；model→targetObjectCode/methodMapping.schemaCode；field→dataActions.targetDataItem/映射 bizCode（不含条件叶子与 datarule，第一版边界）" }
+                    : {}),
+            };
+        }, { target: `rule.references:${args.kind}:${args.code}` }),
+    }));
     tools.push(defineTool({
         name: "rule.get",
         layer: "low",

package/dist/lanes/field.js

@@ -333,7 +333,16 @@ export function registerFieldLane(tools) {
                 ...(selector.length > 0 ? { selected: selector } : {}),
                 ...(args.all !== true ? { businessOnly: true } : {}),
                 fields: projected,
-                ...(detailed ? {} : { inventory: true, hint: '字段详情（options/subSchema）用 code/fields 选择器或 full:true' }),
+                // 券商 issue 1.4（2026-10-27）：默认面空清单曾被误读成「模型没有字段」。
+                // 空清单要自己解释三种可能，别让 agent 二次试错。
+                ...(detailed
+                    ? {}
+                    : {
+                        inventory: true,
+                        hint: projected.length === 0
+                            ? "字段详情（options/subSchema）用 code/fields 选择器或 full:true。当前 draft 面没有业务字段——字段可能都在 published 面（published:true）、尚未创建，或只有系统字段（all:true 核对）"
+                            : "字段详情（options/subSchema）用 code/fields 选择器或 full:true",
+                    }),
             };
         }, {
             // Round 4: the default diet reduced the whole list to a count, so agents

package/dist/lanes/form.js

@@ -50,7 +50,7 @@ export function registerFormLane(tools) {
             controls: z
                 .union([z.boolean(), z.array(z.string().min(1))])
                 .optional()
-                .describe("控件定义投影：true = 返回全部控件的 draft/published 定义；字符串数组 = 只返回这些控件码的定义；省略 = 只回控件码清单"),
+                .describe("布尔或字符串数组：true=返回全部控件的 draft/published 定义；数组如 [\"controlA\",\"controlB\"]=只回这些控件码的定义；省略=只回控件码清单。注意：逗号拼出的单个字符串不是合法取值（invalid_union）——多控件用 JSON 数组。要控件的 options/subSchema 时改用 full:true 再 artifact get --jq <field> 取单字段"),
             full: z.boolean().optional().describe("返回全部六份布局 JSON 原文（大体积）"),
             buttonScripts: z.boolean().optional().describe("附带表单按钮的脚本原文（options.customButtonJson 里 SCRIPT 按钮的 actionConfig.scriptData）及 sha/字节数"),
             capability: capabilityArg,
@@ -148,7 +148,7 @@ export function registerFormLane(tools) {
     writeTool(tools, "form.draft", FORM_LANE, FORM_TOOLS["form.draft"].scope, FORM_TOOLS["form.draft"].description, {
         schemaCode: z.string().min(1),
         sheetCode: z.string().min(1).optional().describe("表单槽位码；省略时默认 = schemaCode（模型码即默认表单槽位）"),
-        draftViewJson: z.string().optional(),
+        draftViewJson: z.string().optional().describe("行分组：一行 N 个 code=N 列；改列数须改行分组，非改 span"),
         draftAttributesJson: z.string().optional(),
         draftHtmlJson: z.string().optional(),
         fieldCodes: z.array(z.string().min(1)).optional().describe("脚手架绑定的已发布字段（按此顺序）；由 configure_form/intent 显式传入"),

package/dist/lanes/report.js

@@ -387,11 +387,27 @@ export function registerReportLane(tools) {
         const page = (await wireCall(session, { path: ENDPOINTS.reportGet, query: { code } })).data;
         const objectId = String(page.id ?? page.reportObjectId ?? "");
         if (objectId) {
-            await biCall(session, {
-                path: ENDPOINTS.biReportPageSave,
-                body: { report: { objectId, title: args.name, attributes: "{}", global: JSON.stringify(DEFAULT_REPORT_GLOBAL) } },
-                auth: authOf(args.corpId, code, args.appCode),
-            });
+            try {
+                await biCall(session, {
+                    path: ENDPOINTS.biReportPageSave,
+                    body: { report: { objectId, title: args.name, attributes: "{}", global: JSON.stringify(DEFAULT_REPORT_GLOBAL) } },
+                    auth: authOf(args.corpId, code, args.appCode),
+                });
+            }
+            catch (error) {
+                // r19 p14（p9 实证）：报表服务未启动时 BI 初始化统一 502，但平台层的
+                // 报表页行**已经建了**。裸抛 uncertain 会掩盖这个残留——半成功必须
+                // 显式：回执带 halfSuccess 警示 + 清理命令，让 agent 下一调用就能收拾。
+                return {
+                    performed: { errcode: 0, code, appCode: args.appCode, objectId, biInit: "failed" },
+                    readback: { present: page.code === code, report: reportPageView(page), biInitialized: false },
+                    halfSuccess: {
+                        message: `平台层报表页已建（code=${code}，objectId=${objectId}），但 BI 初始化失败（${error instanceof Error ? error.message : String(error)}）——元数据已残留`,
+                        cleanup: `omc call report.delete --args '{"code":"${code}"}'（或保留，待报表服务启动后重试 BI 配置）`,
+                        boundary: "报表服务未启动时 BI 层（/dashboard/v1/*）统一 502——这是环境边界，不要原样重试",
+                    },
+                };
+            }
         }
         void created;
         return {