@stalfh233/omc-cli 0.4.98 → 0.4.100

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,7 +549,8 @@ 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
@@ -542,14 +570,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 +598,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 +644,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 +661,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 +676,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 +689,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 +710,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 +725,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 +743,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/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 {

package/dist/lanes/runtime-data-contract.js

@@ -40,7 +40,7 @@ export function dataSubmitDescription() {
         `就地语义：${wire.submitInPlace}；无流程 readback 必须确认 objectId 与传入 bizObjectId 相同；无 bizObjectId 的 workflowCode 新建单 → PROCESSING + workflowInstanceId，无流程 → 该行 COMPLETED。`,
         `既有草稿发起流程的唯一支持形状是两段式：先 data.save 带 workflowCode 暂存（${wire.workflowDraftSave}），再以返回的 workItemId 提交。`,
         `仅无 workflowCode/workItemId/workflowInstanceId 且无 bizObjectId 时保留 save→submit 便捷链（新建记录）；只要存在 workItemId 或 workflowInstanceId 就 fail-closed 拒绝（blocker submit-biz-object-id-required），零 runtime/form/submit wire。`,
-        `formType 自动判定：无任何 workflowCode/workItemId/workflowInstanceId 时**先按模型自动判定**——GET workflow/isworkflow?schemaCode=true 则用 workflow/getWorkflow 解析已发布流程码并**发起流程**（formType="${wire.formTypeWorkflow}"，自动先 GET getReplayToken 注入 replayToken，否则 ${wire.replayTokenErrcode} 频繁重复提交）；模型无流程 → "${wire.formTypeNoWorkflow}"（无流程提交，走 live 已证链 ${wire.submitChain}；单发新建对象会 ${wire.typeCastErrcode}，bizObject 勿带字符串 status）或 workItemId+workflowInstanceId（审批待办，agree 通过/驳回，**必须带 bizObjectId 指向在途单据**，否则引擎 NPE ${wire.approvalNpeErrcode}）→ "${wire.formTypeWorkflow}"。即「无流程直接提交、有流程发起流程」，不再把有流程模型的新建数据落成游离 sheet 行。`,
+        `formType 自动判定：无任何 workflowCode/workItemId/workflowInstanceId 时**先按模型自动判定**——GET workflow/isworkflow?schemaCode=true 则用 workflow/getWorkflow 解析已发布流程码并**发起流程**（formType="${wire.formTypeWorkflow}"，自动先 GET getReplayToken 注入 replayToken，否则 ${wire.replayTokenErrcode} 频繁重复提交）；模型无流程 → "${wire.formTypeNoWorkflow}"（无流程提交，走 live 已证链 ${wire.submitChain}；单发新建对象会 ${wire.typeCastErrcode}，bizObject 勿带字符串 status）或 workItemId+workflowInstanceId（审批待办，agree **顶层**通过/驳回（approval 对象里放 agree 会被静默忽略并按通过处理），**必须带 bizObjectId 指向在途单据**，否则引擎 NPE ${wire.approvalNpeErrcode}）→ "${wire.formTypeWorkflow}"。即「无流程直接提交、有流程发起流程」，不再把有流程模型的新建数据落成游离 sheet 行。`,
         "根因提示（环境相关，ticket 78 观测）：**某些环境**里模型所在应用未发布时运行时提交稳定 50000，工具会反推并拒 app-not-published。该根因非普遍规律（见 data.save 的同条提示与 docs/issues/omc-cli-findings-2026-09-19.md B17）——遇 50000 先只读核对再判断。",
         "Pass `sheetCode` explicitly when the model has multiple sheets; otherwise the default-form sheetCode is resolved from bizsheet/get.",
         `计算字段：${wire.formulaFieldNote}`,

package/dist/lanes/runtime-data.js

@@ -1290,6 +1290,27 @@ export function registerRuntimeDataLane(tools) {
                     `而错误里不会说是哪一个。要么给出真实 id，要么整个省略该键（省略 ≠ 传空串）。`,
             });
         const hasWorkItem = typeof args.workItemId === "string" && args.workItemId.trim().length > 0;
+        // r18b: pure shape check — run before any read/wire so a wrong-result
+        // payload never costs a round trip.
+        if (args.approval && typeof args.approval === "object") {
+            const misplaced = args.approval;
+            if (misplaced.agree !== undefined)
+                throw new ToolRefusalError({
+                    status: "refused",
+                    blocker: "submit-approval-agree-misplaced",
+                    schemaCode: args.schemaCode,
+                    message: `approval.agree 不生效：平台只读**顶层** agree（true=通过 / false=驳回）。approval 对象里放 agree 会被**静默忽略并按通过处理**` +
+                        `（r18b 真机：approval:{agree:false} 仍写入 result=APPROVE 并把流程走完）。改成顶层参数 {"agree":false,...}。`,
+                });
+            if (misplaced.opinion !== undefined)
+                throw new ToolRefusalError({
+                    status: "refused",
+                    blocker: "submit-approval-opinion-misplaced",
+                    schemaCode: args.schemaCode,
+                    message: `approval.opinion 不是平台键，会被静默丢弃（r18b 真机：意见不进 h_biz_comment，content 为 NULL）。` +
+                        `审批意见（BizCommentModel）用 **approval.content**；附件 approval.resources；下一步审批人 approval.relUsers。`,
+                });
+        }
         const hasInstance = typeof args.workflowInstanceId === "string" && args.workflowInstanceId.trim().length > 0;
         const targetObjectId = typeof args.bizObjectId === "string" && args.bizObjectId.trim() ? args.bizObjectId.trim() : null;
         if ((hasWorkItem || hasInstance) && !targetObjectId) {
@@ -1688,6 +1709,15 @@ export function registerRuntimeDataLane(tools) {
                 // SEPARATE concern from server-side business rules (which DO run on
                 // submit) — name that so `portalRulesExecuted:false` is not misread as
                 // "no rule ran" (dogfood R2).
+                // r18b: an approval submit that omits `agree` is treated as APPROVE by
+                // the platform (`agree: args.agree !== false`). That default is right
+                // for the portal button, but for an API caller "I forgot the flag" and
+                // "I approve" must not look identical in the receipt.
+                ...(hasWorkItem && args.agree === undefined
+                    ? {
+                        approvalNote: "本次是审批提交但未传 agree——平台按**通过**处理（顶层 agree 缺省 true）。要驳回必须显式 agree:false；approval.agree 不生效。",
+                    }
+                    : {}),
                 portalRulesExecuted: false,
                 portalRulesNote: "portalRulesExecuted 只指门户客户端的必填/控件校验未在 REST 提交时执行；服务端业务规则（含流程 end 规则）照常运行。",
                 requiredFields: validation.requiredFields,

package/dist/recipes/field.js

@@ -259,7 +259,7 @@ const formulaAggregationCrossModel = Object.freeze({
     conditionalRequirements: [
         "**DYNAMIC 条件的两个 code 分属两侧，写反了就静默 0**：`propertyCode` = **来源模型**的字段（这里是 r17_c.nm），`currentPropertyCode` = **目标模型**的字段（这里是 r17_d.srcNo）。语义 = 「来源行的 nm 等于本目标行的 srcNo」。",
         "`propertyType`/`currentPropertyType` 是 BizPropertyType 的**整数码**（0=SHORT_TEXT 2=NUMERICAL 9=WORK_SHEET…），`operatorType` 是 OperatorType 的**整数码**（1=EQ 6=ITEQ 9=IS_NULL 10=IS_NOT_NULL…）。写名字会被 ObjectMapperUtils 抛 json processing exception 并掩码成 305003；工具会自动转码。",
-        "`calculateType` 是**字符串**（SUM/COUNT/COUNTIF/SUMIF/AVG/MAX/MIN/LARGE/SMALL/UNION），不是枚举 code。",
+        "`calculateType` 是**字符串**（SUM/COUNT/COUNTIF/SUMIF/AVG/MAX/MIN/**LARGE/SMALL/UNION**），不是枚举 code。r18b 真机三种特殊算法：LARGE/SMALL **必须带位置参数** `LARGE({<来源>.<列>},2)`（缺 k → 平台 NumberFormatException → 目标写入 50000）；**UNION 是文本拼接**，顶层 `resultType` 必须是 0/LONG_TEXT=1（写 2 会 50000，读回是去重串，如单号本身）；SUM/AVG/MAX/MIN/COUNT 用 resultType:2。",
         "发布后平台会**自动生成一条 t100 CALCULATE_RULE 镜像行**（h_biz_data_rule，propertyCode=字段 code），它是回算触发的前置条件，别手动删。",
         "**回算时机（r17b 2026-10-26 真机完整行为图谱）**：① 目标行**自己 submit** 时镜像规则一定算（最可靠，不依赖事件）；② 来源行 submit/update/delete 触发 `RollUpEventListener`→`FormulaPropertySupport` 事件回算——FIXED+DYNAMIC 混用、多组 OR、COUNTIF/MAX、子表行级条件（propertyCode 带 `.`）都验证过，DELETE 也会回算；③ ⚠️ 事件回算**只在目标模型发布后的几分钟内可靠**，之后静默停止（源端数据变了目标字段不更新、无报错）——重新 `field.publish --force` 目标模型即可恢复。定时巡检/对账场景务必重发或依赖目标行写入路径。",
     ],

package/dist/recipes/runtime-data.js

@@ -48,7 +48,9 @@ const workflowSubmit = Object.freeze({
     tool: "data.submit",
     args: { environment, schemaCode: model, workflowCode: "<workflow.code>", bizObjectId: "<data.save.performed.bizObjectId>", workflowInstanceId: "<data.save.performed.workflowInstanceId>", workItemId: "<data.save.performed.workItemId>", formData: { name: "recipe draft" } },
     preconditions: ["同一 recipe 的 data.save 已成功并读回 DRAFT；workflowInstanceId/workItemId/bizObjectId 均非空"],
-    conditionalRequirements: ["workItemId 或 workflowInstanceId 出现时必须传 bizObjectId；身份只能复制 data.save 的 authoritative readback"],
+    conditionalRequirements: [
+        "workItemId 或 workflowInstanceId 出现时必须传 bizObjectId；身份只能复制 data.save 的 authoritative readback",
+    ],
     priorToolReferences: [
         { tool: "data.save", args: { environment, schemaCode: model, workflowCode: "<workflow.code>", formData: { name: "recipe draft" } }, purpose: "提供三个环境生成的提交身份" },
         { tool: "workitem.list", args: { environment }, purpose: "当 data.save 未直接返回 workItemId 时按 workflowInstanceId 解析待办" },