@stalfh233/omc-cli 0.4.98 → 0.4.100

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.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