@stalfh233/omc-cli 0.4.99 → 0.4.101

package/README.md

@@ -28,6 +28,9 @@
 - **应用目录（分组）**——`folder.tree/create/update/delete` + `model.move`；
   应用树是嵌套 `children`，读面已递归展平并给 `path`/`depth`。
 - **方法论即可读**——`skills/` 下的方法论通过 `omc help <topic>` 按需读取；agent 不必去翻仓库文件。
+- **一次调用就是答案（0.4.100）**——`omc help --search "<词>"` 跨全部 topic 全文检索、命中节正文内联（严禁自己 `--all | grep`）；`omc describe <tool>` 默认带 `firstCall` 最小可跑形状（上下文键占位符化并列入 missing，绝不冒充合法值）；`omc next "<目标>"` 首答只给一个可执行动作或一个问题（`firstAnswer`）；`omc commands --filter` 支持能力语言（聚合/字典/业务集成…），零命中回 ≤3 个最近候选。
+- **拒绝即教学**——写前拒绝信封自带「你错在哪、正确形状、同源配方命令、不要做什么」；平台/权限/环境类只给「先修什么」，不给注定失败的重试命令。
+- **复合写命令**——`omc submit-verify`（逐条提交 → 真实 id 读回 → 差异汇总）、`omc rule-save-enable`（保存成功才启用，回执回答「会不会真的运行」）、`omc workflow-update-publish`（显式合成最终模板：默认保留旧节点，`--confirm-replace` 才丢弃）。全部默认 dry-run、第一步失败立即停、不自动重试。
 - **凭据零回显**——凭据（0600 存储或环境变量）不会出现在任何输出、产物或错误里。
 - **不确定性语义**——传输失败时冻结（`status: "uncertain", frozen: true`），
   绝不伪造成功。
@@ -130,10 +133,19 @@ omc call discover_environment --env <env> --args '{}'   # 环境就绪（真实
 - **intent**：`partial` 表示该能力可声明式（`omc intent`）覆盖一部分——通常 create/update；
   `none` 表示只走 `omc call`。删除类、方法面、分类/连接池等仍走 `omc call` 逃生舱。
 
-## 近期能力（0.4.74 → 0.4.88）
+## 近期能力（0.4.84 → 0.4.100）
 
 | 版本 | 新增 / 修复 |
 |---|---|
+| 0.4.100 | **回合经济学批（r19–r20，同题面实测 184 调用/503KB → 84 调用/98KB）**：`omc help --search "<词>"` 全文检索（命中节正文内联，单节 >6KB 只给精确回放命令）；`describe` 默认带 `firstCall`（offline-valid 最小可跑形状，`executable === missing为空`）；`omc next` 首答 `firstAnswer`（ready=无占位符可跑 / needs-input=一个问题 / blocked=不伪造路径），`discover_environment` 退出 firstCommands 首位、章节指针 ≤1 且非通用草稿模板、输出 ≤4096B；`commands --filter` 语义检索（工具名/能力别名/配方/摘要，大小写与分隔符归一；零命中最小信封+≤3 候选；宽词按能力分组 ≤3.5KB）；拒绝即教学（拒绝信封自带正确形状+与 firstCall 同源的配方命令+不要做什么；平台/权限类只给先修什么）；三条复合写命令 `submit-verify` / `rule-save-enable` / `workflow-update-publish`（默认 dry-run、第一步失败立即停、合并语义显式）；`OMC_NO_USAGE=1` 计量隔离（读侧不受影响）；报表能力按裁决暂缓（报表类目标 boundary 首答；`/dashboard/v1/*` 502 教学「环境边界不要重试」；`report.create` 半成功显式警示+清理命令） |
+| 0.4.99 | 聚合算法三态实测定案：`LARGE/SMALL` 必带 k（缺 → 50000 掩码）、`UNION` 的 `resultType` 只能 0/1；审批提交**顶层 `agree` 才有效**（`approval.agree/opinion` 被静默忽略且仍按通过处理——写前拒绝 + `approvalNote` 顶层参数）；聚合事件回算窗口 ≈3 分钟实测（`field.publish --force` 重置） |
+| 0.4.98 | 聚合指向子表 schema 写前拒绝（会让目标模型整体 40000 无明细且匹配恒 0）；`40000` 裸掩码给排查解释（先疑字段级配置）；`omc next` 造数据场景路由 |
+| 0.4.97 | 三个写前 gate：日期毫秒时间戳（落库 NULL）、单值关联传数组（50000）、更新时无 id 子表行按新增插入不判重（实测 2 行变 8 行）；跨模型聚合行为图谱（混用条件/多组 OR/COUNTIF/MAX/来源删除回算） |
+| 0.4.96 | 聚合定案（反编译 1.1.25 运行版 jar）：`propertyType/operatorType/resultType` 等 `@JsonCreator get(int)` 枚举**只认整数码**（写名字 → 305003 掩码，CLI 自动转码）；同模型子表聚合是平台死路（`checkCycleOfAggregation:1032` 判环，`field.create` 接受、`field.publish` 炸）→ 写前拒绝；跨模型汇总配方 `formula-aggregation-cross-model`（DYNAMIC 条件两侧字段分属两模型、`queryConditions` 不能为空） |
+| 0.4.95 | `omc compute` 诚实化：`datarule` type2（shortTextStitch）在 REST 路径**永不执行**（`CalculateHandler` 由 `forceExecuteCalculateRule` 门控、全库 0 调用方；门户「能算」是客户端 JS 求值器）——不再假装可配 |
+| 0.4.94 | QUERY 输出不可寻址写前拒绝；`100005` 判「同 workItem 已提交」（永久，非时间窗） |
+| 0.4.92 | `rule.run` 真门（此前是假成功）；custompage 八工具 |
+| 0.4.89/90 | 修 0.4.88 DRAFT 实例回归；`/organization/department/tree` 深度 BFS（deptIds 只回直接子级）；组织树参与人解析按 `ouScope ∩ 发起人部门链`（全空=静默回退发起人 → 写前拒绝）；结构化 nextCommand |
 | 0.4.88 | **`omc model-purge`**：一条命令按依赖倒序清掉一个模型（流程实例 → model.delete 级联带走流程/视图/字段/表单/规则）。这是 r12–r14 三次「脏沙盒幽灵故障」的根治——顺手修了它的死锁（视图最后一条不能删 306103 + 列表绑定流程 303024，所以不删流程、让模型级联）。另：ladder 的 **recipe 命令提到 firstCommands**（r14 抱怨「ladder 没给可直接跑的命令」）、recipe 增加 `aliases` 意图词、`listview.configure` 的拒绝恢复补上 `targetCode` 按 bindAction 的语义 |
 | 0.4.87 | **r14 真机探针修复**：`workitem.list` 的 50000 **不再是无解题**——按 `participant` 走 JPA 查询端点（能查**别人**名下的待办、且不解析流程模板），全局搜索失败时回 `workitem-search-unavailable` 带成因与三条绕行；`workflow.delete` 的 402508 改 `workflow-has-instances` 并说明**不要改用 model.delete 绕过**；`model.delete` 在有未完结待办时回 `workflowWarning`（级联会留脏待办 → 全局待办搜索整页 NPE）。另修两个 composer 模板参数名写错（`form-default --value`→`--default`、`rule-when --rule`→`--on`），并加**模板 vs `--help` 自动校验测试** |
 | 0.4.86 | **r13 真机探针修复**：`omc next` 增加 **composer 路由**（含建模型+字段/审批流/计算/条件规则/表单默认值 → 直接给出对应一条命令；读面仍走 ladder，条件分支流程仍走 recipe）——r13 读了文档里那行 `model-scaffold` 却仍调 26 次 `field.create`，说明「写进文档」不等于「能被发现」。`data.submit` 审批提交**写前校验身份**：非本人在办的待办直接回 `submit-workitem-not-mine`（带待办持有者 + 三条出路），不再让平台回一个 `40005 权限不足`让 agent 猜 |

package/coverage/m1-coverage-manifest-v1.json

@@ -1240,7 +1240,7 @@
     {
       "capability": "rule.list latest business-rule listing and rule.get node route definition readback",
       "status": "executable",
-      "scope": "GET /api/api/runtime/business_rule/list_by_schemacode returning the full latest-version business-field set (no server-side filters); GET /api/api/app/businessrule/get returning the saved node and route graph for readback",
+      "scope": "GET /api/api/runtime/business_rule/list_by_schemacode returning the full latest-version business-field set (no server-side filters); GET /api/api/app/businessrule/get returning the saved node and route graph for readback; cross-rule reference search over model.list + businessrule list/get scans (rule.references)",
       "version_family": "8.6",
       "anchor_version": "8.6.26",
       "evidence": [
@@ -1251,16 +1251,22 @@
         {
           "path": "packages/omc-cli/test/rule-list.test.ts",
           "anchor": "contract tests"
+        },
+        {
+          "path": "packages/omc-cli/test/rule-references.test.ts",
+          "anchor": "contract tests"
         }
       ],
       "lane": "B1-businessrule",
       "tools": [
         "rule.list",
-        "rule.get"
+        "rule.get",
+        "rule.references"
       ],
       "scopes": [
         "latest rule business-field listing",
-        "rule node route readback"
+        "rule node route readback",
+        "cross-rule reference search"
       ]
     },
     {

package/dist/call.js

@@ -7,6 +7,7 @@ import { redact } from "./redact.js";
 import { assertSafeInputPath } from "./artifacts.js";
 import { parseToolInput, ToolInputError } from "./tool-types.js";
 import { absencePointer } from "./capability-absences.js";
+import { attachRefusalRecovery } from "./refusal-guidance.js";
 export const CALL_EXIT_CODES = { ok: 0, failed: 1, unknownTool: 2, invalidInput: 10 };
 export const CLI_ARGS_MAX_BYTES = 1024 * 1024;
 function readBounded(fd, label) {
@@ -89,7 +90,7 @@ export async function runToolCall(toolName, options = {}) {
         args = parseToolInput(tool, args);
     }
     catch (error) {
-        const result = error instanceof ToolInputError ? error.payload : { status: "error", message: error instanceof Error ? error.message : String(error) };
+        const result = attachRefusalRecovery(error instanceof ToolInputError ? error.payload : { status: "error", message: error instanceof Error ? error.message : String(error) }, toolName, registry);
         print(redact(result, []));
         return { exitCode: CALL_EXIT_CODES.invalidInput, result };
     }
@@ -121,13 +122,17 @@ export async function runToolCall(toolName, options = {}) {
                     clearTimeout(timer);
             }
         })();
+    // r19 ticket 06 — 拒绝即教学：refused 结果在出口统一附加 recovery（同源配
+    // 方命令、正确形状、不要做什么）。一处附加，call/script/--args-list/组装器/
+    // intent 全部经过这里。已自带 recovery 的拒绝（write-lock-held）不覆盖。
+    const taught = attachRefusalRecovery(result, toolName, registry);
     // The stderr line is a human diagnostic, NOT a second copy of the result: the
     // stdout envelope is the single machine truth. Dumping the whole result here
     // doubled every call's payload on stderr (unbounded and un-sanitized — it also
     // leaked the raw `detailFile` path; live 2026-09-25). Print the short summary a
     // write already carries, or the (small) error payload; stay silent on a bare
     // successful read.
-    const humanLine = humanResultLine(result);
+    const humanLine = humanResultLine(taught);
     if (humanLine !== null)
         print(humanLine);
     const status = String(result?.status ?? "ok");
@@ -136,7 +141,7 @@ export async function runToolCall(toolName, options = {}) {
     // containing a dry-run line reported failure (found while adding --args-list,
     // r13 2026-10-24). Keep the two verdicts in agreement.
     const exitCode = status === "ok" || status === "dry-run" ? CALL_EXIT_CODES.ok : result?.blocker === "tool-input-invalid" ? CALL_EXIT_CODES.invalidInput : CALL_EXIT_CODES.failed;
-    return { exitCode, result };
+    return { exitCode, result: taught };
 }
 /**
  * The single stderr diagnostic line for a call result, or null when the result

package/dist/capability-overview.js

@@ -274,6 +274,18 @@ export const BOUNDARY_CUES = Object.freeze({
         cues: ["子表套子表", "嵌套子表", "多级子表"],
         note: "嵌套子表（子表套子表）在 W6-S27 为 blocked；一级子表可用，嵌套不可",
     },
+    /**
+     * r19 p14（2026-10-26 用户裁决：报表**暂不优先支持、先隐藏**，不是「平台
+     * 不支持」）：报表分两层——平台层 `/api/api/report/*`（树/改名/存在性）在
+     * 报表服务未启动时仍可用；BI 层 `/dashboard/v1/*`（详情/数据源/图表/配置）
+     * 需要独立报表服务（本机有、当前未启动，网关统一 502，p9 实证）。边界首答
+     * 让 agent 一轮转向；确需报表时先启动报表服务，不在 502 上重试。
+     */
+    "report-bi": {
+        status: "blocked",
+        cues: ["报表", "仪表盘", "dashboard", "图表数据", "数据源绑定"],
+        note: "报表能力暂不优先支持（2026-10-26 维护者裁决，先隐藏）：BI 层（/dashboard/v1/*：详情/数据源/图表/配置）需要报表服务（本机有、当前未启动，网关统一 502）——不要重试这些子面。平台层仍可用：report.tree / report.update / report.get 存在性判定；report.create 在服务未启动时半成功（平台层建行、BI 初始化失败）。确需报表：先启动报表服务再深进",
+    },
 });
 /** The first boundary category whose cue appears in the goal, if any. */
 export function boundaryOf(goal) {

package/dist/cli-contract.js

@@ -220,7 +220,11 @@ export function classifyResult(result) {
         return { status: "error", error: withNext({ code: "invalid-input", message: `unknown tool ${String(result.tool ?? "")}${suffix}`, retryable: false }), exitCode: CLI_EXIT_CODES.invalidInput };
     }
     if (result.blocker === "tool-input-invalid")
-        return { status: "error", error: withNext({ code: "invalid-input", message: String(result.message ?? "tool input is invalid"), retryable: false }), exitCode: CLI_EXIT_CODES.invalidInput };
+        return {
+            status: "error",
+            error: { ...withNext({ code: "invalid-input", message: String(result.message ?? "tool input is invalid"), retryable: false }), nextCommand: `omc describe ${String(result.tool ?? "<tool>")}` },
+            exitCode: CLI_EXIT_CODES.invalidInput,
+        };
     if (status === "uncertain")
         return { status, error: withNext({ code: "uncertain", message: String(result.message ?? result.reason ?? "outcome is uncertain"), retryable: true }), exitCode: CLI_EXIT_CODES.uncertain };
     if (status === "refused") {

package/dist/cli.js

@@ -27,19 +27,21 @@ import { acquireWriteLock } from "./write-lock.js";
 import { cmdCompute } from "./compute.js";
 import { cmdRuleWhen } from "./rule-when.js";
 import { cmdApprovalFlow } from "./approval-flow.js";
+import { runSubmitVerify, runRuleSaveEnable, runWorkflowUpdatePublish } from "./compound-writes.js";
 import { cmdFormDefault } from "./form-default.js";
 // --utf8：单次调用明文输出（等效 OMC_ASCII_STDOUT=0）。在 asciiStdout 缓存读取前生效。
 if (process.argv.includes("--utf8"))
     process.env.OMC_ASCII_STDOUT = "0";
-import { commandIndex, commandInventory, describeContract, describeContractFull, describeContractTool, describeExample, describeParam, describeSchemaOnly, describeTool, describeToolFull } from "./discovery.js";
+import { commandIndex, commandInventory, describeContract, describeContractFull, describeContractTool, describeExample, describeParam, describeSchemaOnly, describeTool, describeToolFull, filterTools } from "./discovery.js";
+import { closestMatches } from "./closest-match.js";
 import { repeatFullDescribe } from "./describe-cache.js";
-import { buildCapabilityOverview, capabilityDetail, compactCapabilities, executableCapabilityBundle, resolveCapabilityId, DISCOVERY_AUTHORITY } from "./capability-overview.js";
+import { buildCapabilityOverview, capabilityDetail, capabilityRouteIndex, compactCapabilities, executableCapabilityBundle, resolveCapabilityId, DISCOVERY_AUTHORITY } from "./capability-overview.js";
 import { goalRoute } from "./goal-routes.js";
 import { absencePointer } from "./capability-absences.js";
 import { intentConfigRoot, readIntentFile, validateIntentText } from "./intent/cli.js";
 import { intentSchemaBlock, intentExample, intentExampleIds } from "./intent/schema.js";
 import { planIntent, readbackIntent, applyIntent, intentWarnings } from "./intent/plan-apply.js";
-import { listSkills, readSkill, readSkillOutline, readSkillSection } from "./skills.js";
+import { listSkills, readSkill, readSkillOutline, readSkillSection, searchSkills } from "./skills.js";
 import { parseToolInput, ToolInputError } from "./tool-types.js";
 import { WireError, wireCall } from "./wire.js";
 import { ENDPOINTS } from "./endpoints.js";
@@ -778,20 +780,38 @@ function cmdDiscovery(kind, transport, value, options = {}) {
             return emitTransportResult({ status: "ok", ...result }, transport);
         }
         const inventory = commandInventory(registry, { compact: options.compact === true });
+        // r19 ticket 05: above this many hits a filter word is "broad" — the filtered
+        // face groups names by capability instead of shipping full rows (a 39-tool
+        // "数据" match was 8 KB; the grouped face keeps every name in ~1.5 KB).
+        const BROAD_FILTER_TOOL_THRESHOLD = 24;
+        /** A query that IS a capability id or lane id is precise intent, never "broad". */
+        function isCapabilityIdQuery(registryInput, query) {
+            const normalized = query.trim().toLowerCase().replace(/[._\s-]/g, "");
+            if (normalized.length === 0)
+                return false;
+            const index = capabilityRouteIndex(registryInput);
+            return index.routes.some((route) => route.id.toLowerCase() === normalized || String(route.lane).toLowerCase().replace(/[_\s-]/g, "") === normalized);
+        }
         // `commands --json` is the programmatic selection entry: filtering server-side
         // keeps the caller from pulling the whole >50 KB inventory to find one lane.
         if (options.filter !== undefined || options.lane !== undefined) {
             const tools = inventory.tools;
-            const keyword = options.filter?.toLowerCase();
+            // r19 ticket 05: semantic filter — capability language（聚合/字典/业务集成）
+            // must locate tools, not dead-end on a name-substring miss.
+            const semantic = options.filter !== undefined ? filterTools(registry, options.filter) : undefined;
+            const semanticByName = semantic ? new Map(semantic.map((hit) => [hit.name, hit.via])) : undefined;
             const matched = tools.filter((tool) => {
                 if (options.lane !== undefined && tool.lane !== options.lane)
                     return false;
-                if (keyword === undefined)
+                if (semanticByName === undefined)
                     return true;
-                return `${tool.name} ${tool.lane ?? ""} ${JSON.stringify(tool.capability ?? "")}`.toLowerCase().includes(keyword);
+                return semanticByName.has(String(tool.name));
             });
             inventory.filtered = { filter: options.filter ?? null, lane: options.lane ?? null, matched: matched.length, total: tools.length };
             inventory.tools = matched;
+            if (semanticByName !== undefined)
+                for (const tool of inventory.tools)
+                    tool.matchedVia = semanticByName.get(String(tool.name));
             // A filtered query wants tool rows, not the whole catalogue's discovery,
             // skills, and intent prose. Keep only the authoritative route pointer.
             delete inventory.skills;
@@ -799,6 +819,34 @@ function cmdDiscovery(kind, transport, value, options = {}) {
             const discovery = inventory.discovery;
             if (discovery)
                 inventory.discovery = { authoritative: discovery.authoritative, route: discovery.route };
+            // Zero hits: minimal envelope + up to three nearest candidates with an
+            // exact next command — NOT the full catalogue to re-read (r18: the empty
+            // match plus governance prose pushed the agent back to the 20 KB face).
+            if (matched.length === 0 && semantic !== undefined) {
+                delete inventory.governance;
+                inventory.filtered.candidates = closestMatches(options.filter ?? "", registry.map((tool) => tool.name), 3).map((candidate) => ({ ...candidate, next: `omc describe ${candidate.name}` }));
+                inventory.note = "零命中：换能力词再试（如 聚合/子表/字典/报表/业务集成/定时任务），或用 omc next \"<目标>\" 按任务路由；全量目录仍走 commands --json";
+            }
+            else if (matched.length > BROAD_FILTER_TOOL_THRESHOLD && !isCapabilityIdQuery(registry, options.filter ?? "")) {
+                // A broad word（"数据" 39 hits / 8 KB）is half a catalogue: keep every
+                // NAME (nothing is hidden) but group them by capability instead of
+                // shipping full rows — the agent narrows with a specific word or --lane
+                // and gets full rows then. Bounded output without losing tools.
+                // Exception: a query that IS a capability/lane id（"field"、"data"）is
+                // precise intent — the capability's full rows are the answer, not noise.
+                const groups = new Map();
+                for (const tool of matched) {
+                    const key = String(tool.capability ?? tool.lane ?? "other");
+                    const entry = groups.get(key) ?? { capability: key, lane: tool.lane ?? null, tools: [] };
+                    entry.tools.push(String(tool.name));
+                    groups.set(key, entry);
+                }
+                inventory.filtered.matchedAll = matched.length;
+                inventory.filtered.grouped = true;
+                inventory.tools = [];
+                inventory.groups = [...groups.values()].sort((left, right) => right.tools.length - left.tools.length);
+                inventory.note = `命中 ${matched.length} 个工具（宽词）：已按能力分组只列名字；加更具体的词或 --lane <lane> 取完整行（含 requiredArgs/recipes）`;
+            }
         }
         result = inventory;
     }
@@ -1028,14 +1076,93 @@ function cmdIntentSchema(transport, example, exampleRequested) {
     }
     return emitResult(intentSchemaBlock(), transport);
 }
+/**
+ * `omc help --search "<q>"` — cross-topic retrieval, not navigation.
+ *
+ * r18 (2026-10-26) spent 173.8 KB re-reading five whole topics twice to grep
+ * for `40000`; `omc help <topic>` is a bookshelf and there was no way to ask a
+ * question. Two rules keep this from becoming another two-call ritual:
+ *
+ *  1. a hit carries its section body, so search itself is the answer;
+ *  2. the hit names the exact `--section` command for the same bytes, so the
+ *     only follow-up (if any) is the last one.
+ *
+ * A miss is `ok` + `totalMatches:0`; only an empty query or a topic+search
+ * contradiction is invalid input. Excerpts are never presented as complete:
+ * `sectionComplete:false` + `truncated:true` say the body did not fit.
+ */
+function cmdHelpSearch(topic, query, transport, searchMode, limit) {
+    if (topic !== undefined)
+        return emitInvalid(transport, { message: `--search 与 topic 不能同时给：要么 omc help --search "<词>"（跨 topic 检索），要么 omc help <topic> --section "<标题>"（读一节）` });
+    const mode = searchMode === undefined ? "all" : searchMode;
+    if (mode !== "all" && mode !== "any")
+        return emitInvalid(transport, { message: `--search-mode 只能是 all 或 any（收到 "${mode}"）：all=同一节内包含全部词，any=包含任一` });
+    const rawLimit = limit === undefined ? 5 : Number(limit);
+    if (!Number.isSafeInteger(rawLimit) || rawLimit < 1 || rawLimit > 50)
+        return emitInvalid(transport, { message: `--limit 必须是 1–50 的整数（收到 "${limit ?? ""}"）` });
+    if (query.trim() === "")
+        return emitInvalid(transport, { message: `--search 需要一个非空查询词（例：omc help --search "40000"）` });
+    const result = searchSkills(query, { mode, limit: rawLimit });
+    // A hit bigger than this is a book, not an answer: inlining it would recreate
+    // the 12 KB sections agents already pay for. Name the exact `--section`
+    // command instead and say the body is not included.
+    const SEARCH_INLINE_SECTION_CEILING = 6_000;
+    const matches = result.matches.map((match) => {
+        const complete = match.sectionBytes <= SEARCH_INLINE_SECTION_CEILING;
+        return {
+            topic: match.topic,
+            heading: match.heading,
+            // Display-only position; `--section` takes the heading (or its leading
+            // ordinal embedded in the heading), never this index.
+            sectionOrdinal: match.sectionOrdinal,
+            matchLines: match.matchLines,
+            sectionBytes: match.sectionBytes,
+            sectionCommand: `omc help ${match.topic} --section "${match.heading}"`,
+            sectionComplete: complete,
+            ...(complete ? { sectionContent: match.section } : { inlineOmitted: `${match.sectionBytes}B 超过单节内联上限 ${SEARCH_INLINE_SECTION_CEILING}B；用 sectionCommand 精确取这一节` }),
+        };
+    });
+    // Keep the whole answer inside one budget: drop bodies from the tail (and say
+    // so) rather than letting the transport spill the envelope to an artifact —
+    // that would recreate the second call this feature removes.
+    const envelopeFor = (entries, truncated) => ({
+        status: "ok",
+        query: query.trim(),
+        mode,
+        totalMatches: result.total,
+        returnedMatches: entries.length,
+        truncated: truncated || entries.some((entry) => entry.sectionComplete === false),
+        matches: entries,
+        ...(result.total === 0 ? { message: "没有匹配章节；换更短的字面词（错误码、字段名、命令名）或加 --search-mode any" } : {}),
+        ...(result.total > 0 && entries.length === 0 ? { message: "命中存在但连指针都放不进预算；加 --limit 1 或换更短的查询" } : {}),
+    });
+    let truncating = false;
+    while (matches.length > 0 && Buffer.byteLength(JSON.stringify(envelopeFor(matches, truncating)), "utf8") > transport.maxOutputBytes) {
+        const last = matches[matches.length - 1];
+        if ("sectionContent" in last && last.sectionContent !== undefined) {
+            // Drop the body but keep the actionable pointer; the next call is then
+            // the last one because sectionCommand carries the exact heading.
+            last.sectionComplete = false;
+            delete last.sectionContent;
+            truncating = true;
+            continue;
+        }
+        matches.pop();
+        truncating = true;
+    }
+    const anyOmitted = matches.some((entry) => entry.sectionComplete === false);
+    console.error(`omc help --search "${query.trim()}"：${result.total} 节命中，返回 ${matches.length} 节${truncating || anyOmitted ? "（含未内联正文，见 sectionCommand）" : ""}`);
+    return emitTransportResult(envelopeFor(matches, truncating), transport);
+}
 /**
  * Ticket 122 — `omc help [topic]`: the methodology layer, reachable exactly
  * like `git help <concept>`. The command list is the "what"; these topics are
  * the "how".
- */
-function cmdHelp(topic, commandNames, transport, section, sections = false, all = false) {
+ */ function cmdHelp(topic, commandNames, transport, section, sections = false, all = false, search, searchMode, limit) {
     const topics = listSkills();
     const commands = [...commandNames].sort();
+    if (search !== undefined)
+        return cmdHelpSearch(topic, search, transport, searchMode, limit);
     // Several sections in one call: `--section a --section b` or `--section a,b`.
     // Round 15: bench60-62 each spent ~18 separate `help --section` round-trips
     // (one per heading the route listed). Fetching them together collapses those
@@ -1057,7 +1184,7 @@ function cmdHelp(topic, commandNames, transport, section, sections = false, all
                 : "")
         : "";
     if (topic === undefined) {
-        console.error("用法：omc help <topic>");
+        console.error("用法：omc help <topic>  |  omc help --search \"<词>\"（跨 topic 检索，命中节正文随结果返回）");
         console.error("权威路线：omc help omc-start-here（随包 skills/，不是分发镜像）");
         console.error("环境就绪：omc call discover_environment --env <env> --args '{}'");
         console.error(`命令：${commands.join("、")}`);
@@ -1169,7 +1296,7 @@ function cmdHelp(topic, commandNames, transport, section, sections = false, all
 function onboardingHelp() {
     return [
         "首次使用、或不确定从哪开始：omc help omc-start-here（随包权威 topic 路线）；被拒或状态异常：omc help omc-refusals。",
-        "方法论按需读：omc help <topic> 默认只回节索引（每节字节数）；用 --section \"<标题>\" 取正文（可重复），确需整篇才 --all。",
+        "方法论按需读：omc help <topic> 默认只回节索引（每节字节数）；用 --section \"<标题>\" 取正文（可重复），确需整篇才 --all。找具体事实（错误码/字段名/命令名）不要整篇 dump：omc help --search \"<词>\"（跨 topic，命中节正文随结果返回）。",
         "目标→工具一步定位：omc next \"<你要做什么>\"（离线、只读，给能力/说明/首批命令；不确定会明说并回退到 omc-requirement-analysis）。",
         "大结果取值一步到位：读面回 detailArtifactId 时，用 omc call <tool> … --jq <path>（可重复；`[]` 映射数组，如 items[].fields.planNo）或 --extract/--extract-keys，省掉再跑一次 omc artifact get；artifact get 正文超 8KB 默认也只回形状（--jq/--keys 定向取，--full 才整包）。批量形状预检用 --args-list … --preflight（零 wire、零写入，一次报全）。",
         "工具发现：omc commands --json（含 capability id/lane/recipes；加 --compact 只回工具行、无目录散文）· omc capabilities（能力 id/lane/aliases/tools/依赖顺序）· omc capability <id> --executable（单能力完整执行包）。",
@@ -1250,7 +1377,7 @@ async function main() {
         command.outputHelp();
         return CLI_EXIT_CODES.ok;
     }
-    command.command("help [topic]").option("--section [heading]", "按标题取该节内容；可重复或用逗号一次取多节：--section a --section b / --section a,b（不带值则列出该 topic 的节标题）", (value, previous) => [...previous, value], []).option("--sections").option("--all", "回整篇正文（默认只回节索引：标题 + 各节字节）").option("--max-output-bytes <bytes>").action(async (topic, options) => { commandExitCode = await withTransport(options, request, (transport) => cmdHelp(topic, command.commands.map((entry) => entry.name()), transport, options.section, options.sections === true, options.all === true)); });
+    command.command("help [topic]").option("--section [heading]", "按标题取该节内容；可重复或用逗号一次取多节：--section a --section b / --section a,b（不带值则列出该 topic 的节标题）").option("--sections").option("--all", "回整篇正文（默认只回节索引：标题 + 各节字节）").option("--search <query>", "跨 topic 全文检索（错误码/字段名/命令名）；命中节正文随结果返回，不需要再取一次").option("--search-mode <mode>", "all（默认，同一节包含全部词）或 any（包含任一）").option("--limit <n>", "检索最多返回几节（默认 5，1–50）").option("--max-output-bytes <bytes>").action(async (topic, options) => { commandExitCode = await withTransport(options, request, (transport) => cmdHelp(topic, command.commands.map((entry) => entry.name()), transport, options.section, options.sections === true, options.all === true, typeof options.search === "string" ? options.search : undefined, typeof options.searchMode === "string" ? options.searchMode : undefined, typeof options.limit === "string" ? options.limit : undefined)); });
     command.command("setup").option("--list").option("--edit <environment>").option("--remove <environment>").action(async (options) => {
         commandExitCode = await cmdSetup(new ConfigStore(defaultPaths()), [...(options.list ? ["--list"] : []), ...(options.edit ? ["--edit", options.edit] : []), ...(options.remove ? ["--remove", options.remove] : [])]);
     });
@@ -1324,7 +1451,7 @@ async function main() {
         .option("--env <environment>")
         .option("--environment <environment>")
         .option("--apply")
-        .addHelpText("after", "\n一条命令按依赖倒序清掉一个模型：列表视图 → 业务规则 → 计算规则 → 流程实例 → 流程 → 模型（字段/表单随模型级联）。默认 dry-run。\n")
+        .addHelpText("after", "\n一条命令按依赖倒序清掉一个模型：列表视图 → 业务规则 → 计算规则 → 流程实例 → 流程 → 模型（字段/表单随模型级联）。默认 dry-run。\n业务数据：--purge-instances 删流程实例；普通业务行（无流程）不会自动带走——先 data.delete 清（sweep-all-readback 配方），再 purge，否则留孤儿数据。\n")
         .action(async (options) => {
         const rest = ["model-purge",
             ...(options.code ? ["--code", options.code] : []),
@@ -1335,6 +1462,105 @@ async function main() {
             ...(options.apply ? ["--apply"] : [])];
         commandExitCode = await cmdModelPurge(rest);
     });
+    // r19 tickets 11–13 — 复合写命令：两步一调，两阶段各自回报，默认 dry-run。
+    const compoundEmit = (request) => (receipt, status) => {
+        writeEnvelope(envelope(status, receipt, request));
+    };
+    const parseJsonFlag = (request, label, raw) => {
+        if (raw === undefined)
+            return {};
+        try {
+            return { value: JSON.parse(raw) };
+        }
+        catch (error) {
+            writeEnvelope(envelope("error", {}, request, { code: "invalid-input", message: `${label} 不是合法 JSON：${error instanceof Error ? error.message : String(error)}`, retryable: false }));
+            return { error: CLI_EXIT_CODES.invalidInput };
+        }
+    };
+    command
+        .command("submit-verify")
+        .option("--schema <schemaCode>", "模型 code")
+        .option("--schema-code <schemaCode>")
+        .option("--rows <json>", "formData 的 JSON 数组（或单个对象）")
+        .option("--env <environment>")
+        .option("--environment <environment>")
+        .option("--apply", "执行（默认 dry-run 预览）")
+        .addHelpText("after", "\n提交并读回：--apply 逐条 data.submit → 用真实 bizObjectId data.load → 同一回执汇总差异。提交失败立即停（不重试、不降级）；读回差异是发现不是失败。批量提交不需要读回时用 omc call data.submit --args-list。\n")
+        .action(async (options) => {
+        const request = requestId();
+        const parsed = parseJsonFlag(request, "--rows", options.rows);
+        if (parsed.error !== undefined) {
+            commandExitCode = parsed.error;
+            return;
+        }
+        const raw = parsed.value;
+        const rows = Array.isArray(raw) ? raw : raw !== undefined ? [raw] : [];
+        commandExitCode = await runSubmitVerify({
+            schema: options.schema ?? options.schemaCode,
+            rows,
+            apply: options.apply === true,
+            environment: options.env ?? options.environment,
+            emit: compoundEmit(request),
+        });
+    });
+    command
+        .command("rule-save-enable")
+        .option("--schema <schemaCode>", "模型 code")
+        .option("--schema-code <schemaCode>")
+        .option("--rule-code <ruleCode>")
+        .option("--name <name>")
+        .option("--node-graph <json>", "规则图 {nodes,routes} JSON")
+        .option("--publish", "保存后同时发布规则版本")
+        .option("--env <environment>")
+        .option("--environment <environment>")
+        .option("--apply", "执行（默认 dry-run 预览）")
+        .addHelpText("after", "\n保存并启用规则：--apply 先 rule.save（upsert），保存成功才 rule.enable；启用失败如实报「已保存但未启用」。规则保存后默认禁用——不启用不会运行。\n")
+        .action(async (options) => {
+        const request = requestId();
+        const parsed = parseJsonFlag(request, "--node-graph", options.nodeGraph);
+        if (parsed.error !== undefined) {
+            commandExitCode = parsed.error;
+            return;
+        }
+        commandExitCode = await runRuleSaveEnable({
+            schema: options.schema ?? options.schemaCode,
+            ruleCode: options.ruleCode,
+            name: options.name,
+            nodeGraph: (parsed.value ?? {}),
+            publish: options.publish === true,
+            apply: options.apply === true,
+            environment: options.env ?? options.environment,
+            emit: compoundEmit(request),
+        });
+    });
+    command
+        .command("workflow-update-publish")
+        .option("--schema <schemaCode>", "模型 code")
+        .option("--schema-code <schemaCode>")
+        .option("--code <workflowCode>", "流程 code")
+        .option("--template <json>", "流程模板 JSON（至少 {activities}）")
+        .option("--confirm-replace", "确认替换：丢弃新模板未覆盖的旧节点（默认保留并在回执列明）")
+        .option("--env <environment>")
+        .option("--environment <environment>")
+        .option("--apply", "执行（默认 dry-run 合成预览）")
+        .addHelpText("after", "\n更新并发布流程：先读草稿显式合成最终模板（默认保留旧节点，--confirm-replace 才丢弃），--apply 走 workflow.update → workflow.publish；更新失败不发布，发布失败保留草稿。\n")
+        .action(async (options) => {
+        const request = requestId();
+        const parsed = parseJsonFlag(request, "--template", options.template);
+        if (parsed.error !== undefined) {
+            commandExitCode = parsed.error;
+            return;
+        }
+        commandExitCode = await runWorkflowUpdatePublish({
+            schema: options.schema ?? options.schemaCode,
+            code: options.code,
+            template: (parsed.value ?? {}),
+            confirmReplace: options.confirmReplace === true,
+            apply: options.apply === true,
+            environment: options.env ?? options.environment,
+            emit: compoundEmit(request),
+        });
+    });
     command
         .command("model-scaffold")
         .option("--code <schemaCode>", "模型 code")

package/dist/closest-match.js

@@ -47,4 +47,38 @@ function editDistance(a, b) {
     }
     return row[b.length];
 }
+/**
+ * r19 ticket 05 — the zero-hit `commands --filter` candidates. Up to `limit`
+ * names ranked by the same acceptance shapes as `closestMatch` (containment,
+ * small edit distance, proportional distance), each with its reason so the
+ * caller sees WHY it was offered instead of the miss.
+ */
+export function closestMatches(input, candidates, limit = 3) {
+    const wanted = input.toUpperCase().replace(/[\s._-]/g, "");
+    if (wanted.length < 2)
+        return [];
+    const scored = [];
+    const everything = [];
+    for (const name of candidates) {
+        const candidate = name.toUpperCase().replace(/[\s._-]/g, "");
+        const distance = editDistance(wanted, candidate);
+        everything.push({ name, distance });
+        if (candidate.includes(wanted)) {
+            scored.push({ name, reason: `名称包含 "${input.trim()}"（分隔符归一后）`, distance: 0 });
+            continue;
+        }
+        const sharedPrefix = commonPrefixLength(wanted, candidate);
+        const proportional = sharedPrefix >= 3 && wanted.length >= 5 && distance / Math.max(wanted.length, candidate.length) <= 0.58;
+        if (distance <= 3 || proportional)
+            scored.push({ name, reason: `与 "${input.trim()}" 编辑距离最近（≈${distance}）`, distance });
+    }
+    // Fallback: a query that matches NO acceptance shape still gets the least-bad
+    // names with their real distance — an honest "did you mean" beats an empty
+    // envelope that sends the caller back to the full catalogue (r19 ticket 05).
+    if (scored.length === 0) {
+        return everything.sort((left, right) => left.distance - right.distance || left.name.localeCompare(right.name)).slice(0, limit)
+            .map(({ name, distance }) => ({ name, reason: `与 "${input.trim()}" 编辑距离最接近（≈${distance}，可能不相关）` }));
+    }
+    return scored.sort((left, right) => left.distance - right.distance || left.name.localeCompare(right.name)).slice(0, limit).map(({ name, reason }) => ({ name, reason }));
+}
 //# sourceMappingURL=closest-match.js.map