@stalfh233/omc-cli 0.4.87 → 0.4.90

package/README.md

@@ -130,10 +130,11 @@ omc call discover_environment --env <env> --args '{}'   # 环境就绪（真实
 - **intent**：`partial` 表示该能力可声明式（`omc intent`）覆盖一部分——通常 create/update；
   `none` 表示只走 `omc call`。删除类、方法面、分类/连接池等仍走 `omc call` 逃生舱。
 
-## 近期能力（0.4.74 → 0.4.87）
+## 近期能力（0.4.74 → 0.4.88）
 
 | 版本 | 新增 / 修复 |
 |---|---|
+| 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 猜 |
 | 0.4.84 | **回合数优化（从省字节转向省往返）**：新增 `omc model-scaffold`（一条命令建模型+N 字段+子表+发布+表单，先 dry-run 预检零写入）与 `omc call <tool> --args-list`（同工具 N 次、逐条执行、回汇总）。修三个真 bug：键名提示自相矛盾（`workflow.delete` 两边互指）、`--dry-run` 与真写对 NUMERICAL 判定不一致（两套真相）、`runToolCall` 的 dry-run 被判失败 |
@@ -236,6 +237,7 @@ omc intent readback intent.yaml --env <env>  # 解码回 intent 形状做等价
 | `omc bench [--live-sample] [--env <env>]` | 工具面/wire 面的双面埋点跑分（离线 fake 或 live 采样） |
 | `omc model-scaffold --code <c> --name <n> --fields '<json>'` | 一条命令建模型：模型 → N 字段（含 `subFields` 子表）→ 发布字段 → 发布表单。**先对每个字段跑 dry-run 预检**（零写入），有错一次报全；执行期幂等（已存在记 skipped） |
 | `omc call <tool> --args-list '<json array>'` | 同一工具跑 N 次、一个进程：逐条执行、默认不中断，回 `succeeded`/`failed` 汇总；失败只列 `failures[]`（带 index），成功不回包。省掉手写 ndjson |
+| `omc model-purge --code <c> [--purge-instances] --apply` | 一条命令按依赖倒序清掉模型：**流程实例 → model.delete 级联带走**流程模板/列表视图/字段/表单/规则。默认 dry-run；有实例不删时会 `blocked` 并说明为何不能改用 model.delete 绕过 |
 | `omc usage [--top <n>] [--records]` | 用量账本：默认只回汇总（调用数/字节/`redundancy` 重复浪费/`byTool` 排名/`estimatedTokens`≈字节/4）；`--records` 才回原始记录。数据源 `.omc/usage.jsonl`（每条 `omc` 调用一行，`omc script` 的每行工具调用另记 `script-call`，带 `parentId`） |
 | `npm run eval:discovery-cost --workspace omc-cli` | 三组离线 discovery 成本基线（调用次数、stdout 字节、拒绝/重试、CloudPivot 写入） |
 

package/dist/cli-contract.js

@@ -75,8 +75,83 @@ export function serializeEnvelope(value) {
 export function requestId() {
     return randomUUID();
 }
+/**
+ * Derive a runnable next command from a refusal payload. Tools that already
+ * carry a structured recovery (an explicit `nextCommand`, an artifact `fetch`
+ * hint, `recovery[].command`, command-shaped `checks`, or a prepared
+ * `nextSubmit`) do not need their prose parsed; everything else stays null
+ * rather than inventing a command that does not apply.
+ */
+export function nextCommandFor(result) {
+    const commandFrom = (text) => {
+        if (typeof text !== "string")
+            return undefined;
+        const trimmed = text.trim();
+        if (/^omc\s/.test(trimmed))
+            return trimmed;
+        // Recovery entries are often "① 按流程收窄（最可靠）：omc call …" — the
+        // command is there, just after a human marker.
+        const index = trimmed.indexOf("omc ");
+        return index > 0 ? trimmed.slice(index).trim() : undefined;
+    };
+    const explicit = result.nextCommand;
+    if (typeof explicit === "string" && explicit.trim().length > 0)
+        return explicit.trim();
+    const fromFetch = commandFrom(result.fetch);
+    if (fromFetch !== undefined)
+        return fromFetch;
+    const recovery = result.recovery;
+    if (Array.isArray(recovery)) {
+        for (const entry of recovery) {
+            if (entry === null || typeof entry !== "object")
+                continue;
+            const command = commandFrom(entry.command);
+            if (command !== undefined)
+                return command;
+        }
+    }
+    for (const list of [result.checks, result.workaround]) {
+        if (!Array.isArray(list))
+            continue;
+        for (const entry of list) {
+            const command = commandFrom(entry);
+            if (command !== undefined)
+                return command;
+        }
+    }
+    // A submit that advanced the flow already prepared the NEXT approval args —
+    // expose the command instead of making the caller reassemble JSON by hand.
+    const nextSubmit = result.nextSubmit;
+    if (nextSubmit !== null && typeof nextSubmit === "object" && !Array.isArray(nextSubmit)) {
+        const record = nextSubmit;
+        if (typeof record.schemaCode === "string" && typeof record.workItemId === "string") {
+            const args = {
+                schemaCode: record.schemaCode,
+                bizObjectId: record.bizObjectId ?? null,
+                workflowInstanceId: record.workflowInstanceId ?? null,
+                workItemId: record.workItemId,
+                agree: true,
+            };
+            return `omc call data.submit --args '${JSON.stringify(args)}'`;
+        }
+    }
+    const nextWorkItems = result.nextWorkItems;
+    if (Array.isArray(nextWorkItems) && nextWorkItems.length > 0 && typeof result.schemaCode === "string") {
+        const item = nextWorkItems[0];
+        if (item !== null && typeof item === "object") {
+            const workItemId = item.workItemId;
+            if (typeof workItemId === "string")
+                return `omc call data.submit --args '${JSON.stringify({ schemaCode: result.schemaCode, workItemId, agree: true })}'`;
+        }
+    }
+    return undefined;
+}
 export function classifyResult(result) {
     const status = String(result.status ?? "ok");
+    const withNext = (error) => {
+        const nextCommand = nextCommandFor(result);
+        return nextCommand === undefined ? error : { ...error, nextCommand };
+    };
     if (status === "ok")
         return { status, error: null, exitCode: CLI_EXIT_CODES.ok };
     if (status === "dry-run")
@@ -88,30 +163,45 @@ export function classifyResult(result) {
         const succeeded = Number(result.succeeded ?? 0);
         const requested = Number(result.requested ?? 0);
         const failed = Number(result.failed ?? 0);
+        // A `--preflight` batch shape-checks entries instead of executing them; the
+        // message must not claim "N 成功/失败" for calls that never ran.
+        // A step-chain command (model-purge) also answers `partial`, and the batch
+        // wording read "6/7 成功，0 失败" — meaningless for steps (r15).
+        const isBatch = typeof result.tool === "string";
+        const message = result.mode === "preflight"
+            ? `${failed}/${requested} 条未过写前校验（preflight：零 wire、零写入）；逐条原因见 failures[]`
+            : isBatch
+                ? `${succeeded}/${requested} 成功，${failed} 失败；逐条原因见 failures[] / failedSteps[]（--args-list 的 index 指向第几条）`
+                : `部分步骤失败：逐条原因见 steps[] 的 status/detail（已在失败处停下；幂等，修好后重跑同一条命令）`;
         return {
             status,
-            error: { code: "partial-batch", message: `${succeeded}/${requested} 成功，${failed} 失败；逐条原因见 failures[] / failedSteps[]（--args-list 的 index 指向第几条）`, retryable: false },
+            error: withNext({ code: "partial-batch", message, retryable: false }),
             exitCode: 1,
         };
     }
     if (status === "unknown-tool") {
         const candidates = Array.isArray(result.candidates) ? result.candidates : [];
         const suffix = candidates.length > 0 ? `；did you mean: ${candidates.join("、")}` : "；用 `omc commands --json --compact --lane <lane>` 或 `omc next` 定位工具";
-        return { status: "error", error: { code: "invalid-input", message: `unknown tool ${String(result.tool ?? "")}${suffix}`, retryable: false }, exitCode: CLI_EXIT_CODES.invalidInput };
+        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: { 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 }), exitCode: CLI_EXIT_CODES.invalidInput };
     if (status === "uncertain")
-        return { status, error: { code: "uncertain", message: String(result.message ?? result.reason ?? "outcome is uncertain"), retryable: true }, exitCode: CLI_EXIT_CODES.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") {
         if (result.blocker === "write-lock-held")
-            return { status, error: { code: "policy-refused", message: String(result.message ?? "write lock held"), retryable: true }, exitCode: CLI_EXIT_CODES.policyRefused };
+            return { status, error: withNext({ code: "policy-refused", message: String(result.message ?? "write lock held"), retryable: true }), exitCode: CLI_EXIT_CODES.policyRefused };
         const auth = String(result.blocker ?? "").startsWith("auth") || String(result.blocker ?? "").includes("credential");
-        return { status, error: { code: auth ? "auth-config" : "policy-refused", message: String(result.message ?? result.blocker ?? "operation refused"), retryable: false }, exitCode: auth ? CLI_EXIT_CODES.authConfig : CLI_EXIT_CODES.policyRefused };
+        // Every refusal gets a next step: a specific command when the tool knows
+        // one, otherwise the refusal router (`omc-refusals` explains which gate
+        // produced it — the documented path in omc-start-here).
+        const error = { code: auth ? "auth-config" : "policy-refused", message: String(result.message ?? result.blocker ?? "operation refused"), retryable: false };
+        const nextCommand = nextCommandFor(result) ?? (auth ? undefined : "omc help omc-refusals");
+        return { status, error: nextCommand === undefined ? error : { ...error, nextCommand }, exitCode: auth ? CLI_EXIT_CODES.authConfig : CLI_EXIT_CODES.policyRefused };
     }
     const message = String(result.message ?? "internal error");
     const auth = /credential|configuration|environment|login|authentication|auth/i.test(message);
-    return { status: "error", error: { code: auth ? "auth-config" : "internal", message, retryable: false }, exitCode: auth ? CLI_EXIT_CODES.authConfig : CLI_EXIT_CODES.internal };
+    return { status: "error", error: withNext({ code: auth ? "auth-config" : "internal", message, retryable: false }), exitCode: auth ? CLI_EXIT_CODES.authConfig : CLI_EXIT_CODES.internal };
 }
 export function errorEnvelope(error, code, exitCode, request) {
     const message = error instanceof Error ? error.message : String(error);

package/dist/cli.js

@@ -13,13 +13,14 @@ import { redactText } from "./redact.js";
 import { readArgsFile, readStdinArgs, runToolCall, validateAgentPaths } from "./call.js";
 import { BATCH_MAX_ENTRIES, runBatchCall } from "./batch-call.js";
 import { cmdModelScaffold } from "./model-scaffold.js";
+import { cmdModelPurge } from "./model-purge.js";
 import { environmentWritable, requiresProductionConfirmation } from "./environment-policy.js";
-import { CLI_EXIT_CODES, classifyResult, envelope, errorEnvelope, requestId } from "./cli-contract.js";
+import { CLI_EXIT_CODES, classifyResult, envelope, errorEnvelope, refusalText, requestId } from "./cli-contract.js";
 import { configureOutput, humanSummary, stripOutputFlags, writeEnvelope } from "./cli-output.js";
 import { beginUsage, completeUsage, ensureProjectIgnore, recordUsageOutput, usageReport } from "./usage-log.js";
 import { artifactFetchHint, artifactRoot, boundResult, emitInvalid, emitResult, emitTransportResult, outputBudget, readArtifact, withTransport, } from "./command-transport.js";
 import { CLI_DEFAULT_OUTPUT_BYTES, assertSafeOutputPath, pruneArtifacts } from "./artifacts.js";
-import { projectJsonPath, projectResultExtract } from "./path-projection.js";
+import { projectJsonPath, projectJsonPathFanout, projectResultExtract } from "./path-projection.js";
 import { basename, join, resolve } from "node:path";
 import { buildToolRegistry } from "./tools.js";
 import { acquireWriteLock } from "./write-lock.js";
@@ -318,6 +319,52 @@ async function cmdBatchCall(store, toolName, rawList, options) {
         }));
         return CLI_EXIT_CODES.invalidInput;
     }
+    // Whole-batch shape precheck (issue 2026-10-25 §6): `--args-list --dry-run`
+    // runs every entry through the full tool (reads included) to report N
+    // previews. When the caller only wants "will this batch be accepted", the
+    // per-tool semantic gate is the thing that refuses mis-shapes, and it is
+    // pure — no wire, no writes. Run it for every entry and report ALL failures
+    // in one envelope instead of N round-trips.
+    if (options.preflight === true) {
+        const registry = buildToolRegistry();
+        const tool = registry.find((definition) => definition.name === toolName);
+        if (!tool) {
+            writeEnvelope(envelope("error", {}, request, { code: "invalid-input", message: `unknown tool ${toolName}；用 omc next 或 omc commands --json --compact --lane <lane> 定位`, retryable: false }));
+            return CLI_EXIT_CODES.invalidInput;
+        }
+        const failures = [];
+        entries.forEach((entry, index) => {
+            try {
+                const parsedEntry = parseToolInput(tool, {
+                    ...entry,
+                    ...(options.environment !== undefined && entry.environment === undefined ? { environment: options.environment } : {}),
+                });
+                tool.writePreflight?.(parsedEntry);
+            }
+            catch (error) {
+                // ToolRefusalError carries the real payload (blocker/citation/validation);
+                // rebuild it only when the failure is a plain Error.
+                const carried = error.payload;
+                const payload = error instanceof ToolInputError ? error.payload : carried ?? { status: "refused", blocker: "tool-input-invalid", message: error instanceof Error ? error.message : String(error) };
+                failures.push({ index, blocker: payload.blocker ?? null, message: refusalText(payload), ...(Array.isArray(payload.validation) ? { validation: payload.validation } : {}), ...(payload.citation !== undefined ? { citation: payload.citation } : {}) });
+            }
+        });
+        const result = {
+            status: failures.length > 0 ? "partial" : "ok",
+            mode: "preflight",
+            tool: toolName,
+            requested: entries.length,
+            shapeChecked: entries.length,
+            failed: failures.length,
+            writes: 0,
+            // On failure the caller has to change the JSON first, so there is no
+            // runnable command yet; on success, hand over the exact execution command.
+            ...(failures.length > 0 ? { failures } : { nextCommand: `omc call ${toolName} --args-list ${JSON.stringify(JSON.stringify(entries))}` }),
+        };
+        const classified = classifyResult(result);
+        writeEnvelope(envelope(classified.status, result, request, classified.error));
+        return failures.length > 0 ? 1 : 0;
+    }
     const batched = await runBatchCall({
         tool: toolName,
         argsList: entries,
@@ -351,7 +398,7 @@ async function cmdCall(store, args) {
     const positional = args.filter((token, index) => !token.startsWith("--") && (index === 0 || !args[index - 1]?.startsWith("--env") && !args[index - 1]?.startsWith("--environment") && !args[index - 1]?.startsWith("--args")));
     const toolName = positional[0];
     if (!toolName || toolName === "help" || args.includes("--help")) {
-        console.error("用法：omc call <tool> [--env <环境>] [--args '<json>' | --args - (stdin) | --args-file <配置根内路径>] [--extract <path>]... [--extract-keys]");
+        console.error("用法：omc call <tool> [--env <环境>] [--args '<json>' | --args - (stdin) | --args-file <配置根内路径>] [--extract <path>]... [--jq [path]] [--extract-keys] [--args-list <json数组> [--preflight]]");
         console.error("写入：由环境 writable 决定（只读环境拒写）；生产环境的写必须在 args 里带 confirmProduction:true。");
         return emit(toolName && toolName !== "help" ? "error" : "ok", {}, toolName && toolName !== "help" ? CLI_EXIT_CODES.invalidInput : 0);
     }
@@ -360,14 +407,19 @@ async function cmdCall(store, args) {
     // Batch mode: the SAME tool N times, one process (r12: 36 field.create calls).
     const argsList = flag("--args-list");
     if (argsList !== undefined)
-        return cmdBatchCall(store, toolName, argsList, { environment, requestValue, args });
+        return cmdBatchCall(store, toolName, argsList, { environment, requestValue, args, preflight: args.includes("--preflight") });
     // 1.2 of issue 2026-10-23: read faces answer {detailArtifactId, sha256} and the
     // caller then needs a SECOND call to see one value (16 two-step chains in one
     // session; 15 more were pure --keys probes). `--extract <path>` (repeatable)
     // resolves the path inside the artifact of THIS result and returns only the
     // value; `--extract-keys` lists the artifact's top-level keys with sizes.
-    const extractPaths = argvValues(args, "--extract");
-    const extractKeys = args.includes("--extract-keys");
+    //
+    // issue 2026-10-25 §8: `artifact get` had `--jq` while `omc call` did not, so
+    // every list read that only wanted one column paid a second artifact round.
+    // `--jq` is the same path projection plus `[]` fan-out; a bare `--jq` is the
+    // key inventory (the same muscle memory as `artifact get <id> --jq`).
+    const extractPaths = [...argvValues(args, "--extract"), ...argvValues(args, "--jq")];
+    const extractKeys = args.includes("--extract-keys") || args.some((token, index) => token === "--jq" && (args[index + 1] === undefined || args[index + 1].startsWith("--")));
     const dryRun = args.includes("--dry-run");
     const waitValue = flag("--wait");
     let waitMs = 0;
@@ -546,6 +598,23 @@ function parseDurationMs(text) {
  * template re-read three times is 81 KB of the session.
  */
 const ARTIFACT_INLINE_CEILING_BYTES = 8192;
+/**
+ * `artifact get --jq`: one path walk, with `[]` fan-out (same syntax as
+ * `omc call --jq`). Returns the envelope fields so both the `--summary` and the
+ * plain branch stay identical.
+ */
+function projectArtifactPath(value, path) {
+    if (!path.includes("[]")) {
+        const projected = projectJsonPath(value, path);
+        return projected.missed
+            ? { missed: true, ...(projected.at !== undefined ? { at: projected.at } : {}), ...(projected.available !== undefined ? { available: projected.available } : {}) }
+            : { missed: false, content: projected.value ?? null };
+    }
+    const fanout = projectJsonPathFanout(value, path);
+    return fanout.missed
+        ? { missed: true, ...(fanout.at !== undefined ? { at: fanout.at } : {}), ...(fanout.available !== undefined ? { available: fanout.available } : {}) }
+        : { missed: false, content: fanout.values, mapped: fanout.values.length, ...(fanout.missedEntries > 0 ? { missedEntries: fanout.missedEntries } : {}) };
+}
 function formatBytes(bytes) {
     if (bytes < 1024)
         return `${bytes}B`;
@@ -578,10 +647,10 @@ async function cmdArtifactGet(id, transport, options = {}) {
             // this the caller had to spend one round on the shape and another on the
             // path (or pull the whole body); r5 hit that on 67 KB workflow templates.
             if (options.jq !== undefined) {
-                const projected = projectJsonPath(artifact.content.toString("utf8") === "" ? undefined : content, options.jq);
+                const projected = projectArtifactPath(artifact.content.toString("utf8") === "" ? undefined : content, options.jq);
                 return emitTransportResult(projected.missed
                     ? { status: "ok", artifactId: id, sha256: artifact.sha256, bytes: artifact.content.length, keys, projection: { path: options.jq, content: null, pathMiss: true, missedAt: projected.at, available: projected.available }, fetch: artifactFetchHint(id) }
-                    : { status: "ok", artifactId: id, sha256: artifact.sha256, bytes: artifact.content.length, keys, projection: { path: options.jq, content: projected.value ?? null } }, transport);
+                    : { status: "ok", artifactId: id, sha256: artifact.sha256, bytes: artifact.content.length, keys, projection: { path: options.jq, content: projected.content ?? null, ...(projected.mapped !== undefined ? { mapped: projected.mapped } : {}), ...(projected.missedEntries !== undefined ? { missedEntries: projected.missedEntries } : {}) } }, transport);
             }
             return emitTransportResult({ status: "ok", artifactId: id, sha256: artifact.sha256, bytes: artifact.content.length, keys, fetch: artifactFetchHint(id) }, transport);
         }
@@ -610,10 +679,10 @@ async function cmdArtifactGet(id, transport, options = {}) {
             return emitTransportResult(result, transport);
         }
         if (options.jq !== undefined) {
-            const projected = projectJsonPath(artifact.content.toString("utf8") === "" ? undefined : content, options.jq);
+            const projected = projectArtifactPath(artifact.content.toString("utf8") === "" ? undefined : content, options.jq);
             return emitTransportResult(projected.missed
-                ? { status: "ok", artifactId: id, sha256: artifact.sha256, path: options.jq, content: null, pathMiss: true, missedAt: projected.at, available: projected.available, hint: `路径未命中段 "${projected.at}"——available 是该层可用的键/范围；方括号下标（a[0]）与点式（a.0）等价` }
-                : { status: "ok", artifactId: id, sha256: artifact.sha256, path: options.jq, content: projected.value ?? null }, transport);
+                ? { status: "ok", artifactId: id, sha256: artifact.sha256, path: options.jq, content: null, pathMiss: true, missedAt: projected.at, available: projected.available, hint: `路径未命中段 "${projected.at}"——available 是该层可用的键/范围；方括号下标（a[0]）与点式（a.0）等价；[] 映射数组（items[].fields.x）` }
+                : { status: "ok", artifactId: id, sha256: artifact.sha256, path: options.jq, content: projected.content ?? null, ...(projected.mapped !== undefined ? { mapped: projected.mapped } : {}), ...(projected.missedEntries !== undefined ? { missedEntries: projected.missedEntries } : {}) }, transport);
         }
         // r6-onboarding 2026-10-21: 47 artifact fetches, 0 used a projection; the 10
         // large ones (up to 55 KB) pulled whole workflow templates just to read one
@@ -1089,7 +1158,7 @@ function onboardingHelp() {
         "首次使用、或不确定从哪开始：omc help omc-start-here（随包权威 topic 路线）；被拒或状态异常：omc help omc-refusals。",
         "方法论按需读：omc help <topic> 默认只回节索引（每节字节数）；用 --section \"<标题>\" 取正文（可重复），确需整篇才 --all。",
         "目标→工具一步定位：omc next \"<你要做什么>\"（离线、只读，给能力/说明/首批命令；不确定会明说并回退到 omc-requirement-analysis）。",
-        "大结果取值一步到位：读面回 detailArtifactId 时，用 omc call <tool> … --extract <path>（可重复）或 --extract-keys，省掉再跑一次 omc artifact get；artifact get 正文超 8KB 默认也只回形状（--jq/--keys 定向取，--full 才整包）。",
+        "大结果取值一步到位：读面回 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（单能力完整执行包）。",
         "单工具/契约：omc describe <tool>（schema+recipe+能力路由）· omc contract <lane>（wire 契约+能力路由）；环境就绪：omc call discover_environment --env <env> --args '{}'。",
         "写入两道门：对话层草稿确认（omc help omc-config-draft-review）+ 环境 writable 开关；生产环境每笔写需在 args 里带 confirmProduction:true。",
@@ -1213,8 +1282,8 @@ async function main() {
         commandExitCode = CLI_EXIT_CODES.ok;
     });
     command.command("doctor").option("--environment <environment>").option("--env <environment>").option("--service <serviceCode>", "可选：体检单个业务集成服务的鉴权参数形状（掩码/占位/全 0 检出，WARN 非致命）").action(async (options) => { commandExitCode = await cmdDoctor(new ConfigStore(defaultPaths()), options.environment ?? options.env, options.service); });
-    command.command("call <tool>").option("--env <environment>").option("--environment <environment>").option("--args <json>").option("--args-file <path>").option("--args-list <json-array>", '同一工具跑 N 次（JSON 数组，每条一个 args 对象）；逐条执行、默认不中断，最后回 succeeded/failed 汇总。适合批量建字段等').addOption(new Option("--extract <path>", "在本次结果的 artifact 内取一个路径的值（可重复；省掉一次 artifact get）").argParser((value, previous = []) => [...previous, value]).default([])).option("--extract-keys", "列出本次结果 artifact 的顶层键与体积（省掉一次 artifact get --keys）").option("--max-output-bytes <bytes>").option("--request-id <requestId>").option("--timeout-ms <milliseconds>").option("--wait <milliseconds>").option("--dry-run").addHelpText("after", `\n${onboardingHelp()}\n`).action(async (tool, options) => {
-        const rest = [tool, ...(options.env ? ["--env", options.env] : []), ...(options.environment ? ["--environment", options.environment] : []), ...(options.args !== undefined ? ["--args", options.args] : []), ...(options.argsFile !== undefined ? ["--args-file", options.argsFile] : []), ...(options.argsList !== undefined ? ["--args-list", options.argsList] : []), ...(Array.isArray(options.extract) ? options.extract.flatMap((path) => ["--extract", path]) : []), ...(options.extractKeys ? ["--extract-keys"] : []), ...(options.maxOutputBytes !== undefined ? ["--max-output-bytes", options.maxOutputBytes] : []), ...(options.requestId ? ["--request-id", options.requestId] : []), ...(options.timeoutMs !== undefined ? ["--timeout-ms", options.timeoutMs] : []), ...(options.wait !== undefined ? ["--wait", options.wait] : []), ...(options.dryRun ? ["--dry-run"] : [])];
+    command.command("call <tool>").option("--env <environment>").option("--environment <environment>").option("--args <json>").option("--args-file <path>").option("--args-list <json-array>", '同一工具跑 N 次（JSON 数组，每条一个 args 对象）；逐条执行、默认不中断，最后回 succeeded/failed 汇总。适合批量建字段等').option("--preflight", "与 --args-list 一起用：只跑参数校验 + 写前语义闸（零 wire、零写入），一次报全所有形状问题").addOption(new Option("--extract <path>", "在本次结果的 artifact 内取一个路径的值（可重复；省掉一次 artifact get）").argParser((value, previous = []) => [...previous, value]).default([])).addOption(new Option("--jq [path]", "同 --extract，并支持 [] 映射（如 items[].fields.planNo）；裸 --jq 列出结果的顶层键").argParser((value, previous = []) => [...previous, value]).default([])).option("--extract-keys", "列出本次结果 artifact 的顶层键与体积（省掉一次 artifact get --keys）").option("--max-output-bytes <bytes>").option("--request-id <requestId>").option("--timeout-ms <milliseconds>").option("--wait <milliseconds>").option("--dry-run").addHelpText("after", `\n${onboardingHelp()}\n`).action(async (tool, options) => {
+        const rest = [tool, ...(options.env ? ["--env", options.env] : []), ...(options.environment ? ["--environment", options.environment] : []), ...(options.args !== undefined ? ["--args", options.args] : []), ...(options.argsFile !== undefined ? ["--args-file", options.argsFile] : []), ...(options.argsList !== undefined ? ["--args-list", options.argsList] : []), ...(options.preflight ? ["--preflight"] : []), ...(Array.isArray(options.extract) ? options.extract.flatMap((path) => ["--extract", path]) : []), ...(Array.isArray(options.jq) ? options.jq.flatMap((path) => path === true ? ["--jq"] : ["--jq", path]) : []), ...(options.extractKeys ? ["--extract-keys"] : []), ...(options.maxOutputBytes !== undefined ? ["--max-output-bytes", options.maxOutputBytes] : []), ...(options.requestId ? ["--request-id", options.requestId] : []), ...(options.timeoutMs !== undefined ? ["--timeout-ms", options.timeoutMs] : []), ...(options.wait !== undefined ? ["--wait", options.wait] : []), ...(options.dryRun ? ["--dry-run"] : [])];
         commandExitCode = await cmdCall(new ConfigStore(defaultPaths()), rest);
     });
     command.command("compute").option("--schema <schemaCode>").option("--schema-code <schemaCode>").option("--target <propertyCode>").option("--property <propertyCode>").option("--formula <formula>").option("--where <condition>", "条件聚合：\"<子列code> = <值>\"，与 --formula \"{<子表code>.<子列code>}\" 配合编译为 COUNTIF/SUMIF").option("--aggregate <count|sum>", "条件聚合用哪种：count（默认，→COUNTIF）/ sum（→SUMIF）").option("--allow-unfiltered", "显式接受「对整个子表列无条件聚合」；不给则拒绝（会把不符合条件的行也算进去）").option("--name <name>").option("--env <environment>").option("--environment <environment>").option("--apply").addHelpText("after", "\n字段计算规则拼装器：公式 {字段} 引用 → datarule type2 完整形状（editorText/editorMark 自动生成）。默认 dry-run，--apply 写入。条件聚合用 --formula \"{子表.子列}\" --where \"子列 = 值\"。复杂场景（条件分支/跨模型）走 omc next 的 recipe 路径。\n").action(async (options) => {
@@ -1233,6 +1302,25 @@ async function main() {
         const rest = ["approval-flow", ...(options.schema ? ["--schema", options.schema] : []), ...(options.schemaCode ? ["--schema-code", options.schemaCode] : []), ...(Array.isArray(options.steps) ? options.steps.flatMap((s) => ["--steps", s]) : []), ...(options.env ? ["--env", options.env] : []), ...(options.environment ? ["--environment", options.environment] : []), ...(options.apply ? ["--apply"] : []), ...(options.originatorNode === false ? ["--no-originator-node"] : []), ...(options.rejectToStart === false ? ["--no-reject-to-start"] : [])];
         commandExitCode = await cmdApprovalFlow(rest);
     });
+    command
+        .command("model-purge")
+        .option("--code <schemaCode>", "模型 code")
+        .option("--schema <schemaCode>")
+        .option("--purge-instances", "连流程实例一起删（workflow.delete 遇到实例会 402508）")
+        .option("--env <environment>")
+        .option("--environment <environment>")
+        .option("--apply")
+        .addHelpText("after", "\n一条命令按依赖倒序清掉一个模型：列表视图 → 业务规则 → 计算规则 → 流程实例 → 流程 → 模型（字段/表单随模型级联）。默认 dry-run。\n")
+        .action(async (options) => {
+        const rest = ["model-purge",
+            ...(options.code ? ["--code", options.code] : []),
+            ...(options.schema ? ["--schema", options.schema] : []),
+            ...(options.purgeInstances ? ["--purge-instances"] : []),
+            ...(options.env ? ["--env", options.env] : []),
+            ...(options.environment ? ["--environment", options.environment] : []),
+            ...(options.apply ? ["--apply"] : [])];
+        commandExitCode = await cmdModelPurge(rest);
+    });
     command
         .command("model-scaffold")
         .option("--code <schemaCode>", "模型 code")
@@ -1404,7 +1492,7 @@ main().then((code) => {
     // envelope (or, for `env --json`, their own JSON) and were printing a second
     // empty envelope after it (live 2026-10-23: `omc rollback apply` answered two
     // lines, violating the one-envelope stdout contract).
-    const ownsStdout = ["call", "script", "artifact", "commands", "describe", "contract", "capabilities", "capability", "next", "usage", "intent", "help", "form-default", "compute", "rule-when", "approval-flow", "model-scaffold", "rollback", "env", "--version", "-V"];
+    const ownsStdout = ["call", "script", "artifact", "commands", "describe", "contract", "capabilities", "capability", "next", "usage", "intent", "help", "form-default", "compute", "rule-when", "approval-flow", "model-scaffold", "model-purge", "rollback", "env", "--version", "-V"];
     if (ownsStdout.includes(argv[2] ?? "")) {
         completeUsage(code);
         finish(code);

package/dist/endpoints.js

@@ -177,6 +177,16 @@ export const ENDPOINTS = {
      * so it can answer "what is pending for user X", not only "for me".
      */
     workflowListWorkItems: "/api/api/runtime/workflow/list_workitems",
+    /** Instances of a workflow (WorkflowInstanceController.list_instances). */
+    workflowListInstances: "/api/api/runtime/workflow/list_instances",
+    /**
+     * Delete one workflow instance (WorkflowInstanceController.delete_instance).
+     * Only workflowInstanceId is required — `userId` is taken from the login
+     * session, so an instance started by another user can be erased from a single
+     * admin session. Required before `workflow.delete`, which refuses (402508)
+     * while any instance exists.
+     */
+    workflowDeleteInstance: "/api/api/runtime/workflow/delete_instance",
     workflowGetBizObjectByWfInstanceId: "/api/api/runtime/workflow/getBizObjectByWfInstanceId",
     workflowListInstanceActivity: "/api/api/runtime/workflow/list_workflow_instance_activity",
     workflowListFinishedWorkItems: "/api/api/runtime/workflow/list_finished_workitems",

package/dist/goal-routes.js

@@ -113,13 +113,36 @@ function capabilityScores(registry, goal) {
     }
     return scores;
 }
+/**
+ * Default ladder examples (r15). A ladder step with no goal-matching recipe only
+ * got `omc commands --lane`, so "创建业务规则" handed the caller nothing runnable
+ * even though `rule.save` ships examples. These are the lane's canonical shapes,
+ * used ONLY when the goal does not match a specific recipe.
+ */
+const DEFAULT_LADDER_RECIPES = {
+    businessrule: { tool: "rule.save", recipe: "business-rule-branch-conditional" },
+    datarule: { tool: "datarule.create", recipe: "field-compute-rule" },
+};
+function defaultRecipeFor(registry, capabilityId, lane) {
+    const wanted = DEFAULT_LADDER_RECIPES[capabilityId];
+    if (!wanted)
+        return undefined;
+    for (const tool of registry) {
+        if (tool.name !== wanted.tool || tool.lane !== lane)
+            continue;
+        const recipe = (tool.executionMetadata?.recipes ?? []).find((entry) => entry.id === wanted.recipe);
+        if (recipe)
+            return { tool: tool.name, recipe: recipe.id, title: recipe.title };
+    }
+    return undefined;
+}
 function bestRecipe(registry, capabilityId, lane, goal, minScore = 3) {
     let best;
     for (const tool of registry) {
         if (tool.lane !== lane)
             continue;
         for (const recipe of tool.executionMetadata?.recipes ?? []) {
-            const score = overlap(goal, `${recipe.title} ${recipe.id}`);
+            const score = overlap(goal, `${recipe.title} ${recipe.id} ${(recipe.aliases ?? []).join(" ")}`);
             if (score >= minScore && (best === undefined || score > best.score))
                 best = { tool: tool.name, recipe: recipe.id, title: recipe.title, score };
         }
@@ -238,17 +261,27 @@ function sectionPointersFor(ids) {
     return pointers;
 }
 /**
- * Ready-to-run methodology reads, one per topic, that fetch ALL of that topic's
- * relevant sections in a single call. Round 15: bench60-62 fetched each
- * `readSections` entry separately (~18 round-trips); `--section` is repeatable
- * and comma-separated, so grouping by topic collapses them to ~3 without adding
- * any bytes (the outputs land in context either way — the saving is turns).
+ * Ready-to-run methodology reads.
+ *
+ * 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.
  */
-function batchReadCommands(pointers) {
+function splitReadCommands(pointers) {
     const byTopic = new Map();
     for (const pointer of pointers)
         byTopic.set(pointer.topic, [...(byTopic.get(pointer.topic) ?? []), pointer.section]);
-    return [...byTopic.entries()].map(([topic, sections]) => `omc help ${topic} ${sections.map((section) => `--section "${section}"`).join(" ")}`);
+    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 };
 }
 /**
  * The route's methodology-read surface: pointers (+ per-section bytes) +
@@ -279,14 +312,15 @@ function routeReads(readSections) {
             }
         }
     }
-    return { readSections: budgeted, readCommands: batchReadCommands(readSections), readHint: READ_HINT, ...(firstSection !== undefined ? { firstSection } : {}) };
+    const commands = splitReadCommands(readSections);
+    return { readSections: budgeted, readCommands: commands.readCommands, ...(commands.readMore.length > 0 ? { readMore: commands.readMore } : {}), 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 一次读完（每条命令用可重复的 `--section` 取该 topic 的所有相关节，等价于逐节 `omc help <topic> --section "<section>"` 但只花一次往返）；单节字节数见 readSectionBudget，按预算自选。`omc help <topic>` 默认只回节索引（每节带字节数，约 1KB），不要再用 `--all` 读整篇（5–14KB，读一次就留在后续每一轮）。';
+const READ_HINT = '先跑 readCommands（每个 topic 只取第一节，形状 `omc help <topic> --section "<section>"`，字节数见 readSections）；不够再按需补 readMore，不要一次全读。`omc help <topic>` 默认只回节索引（每节带字节数，约 1KB），不要再用 `--all` 读整篇（5–14KB，读一次就留在后续每一轮）。';
 function orderedCapabilities(ids, index) {
     const selected = new Set(ids);
     const nodes = [...index.nodeById.values()];
@@ -322,6 +356,18 @@ function orderedCapabilities(ids, index) {
  */
 const WHOLE_PACKAGE_CAPABILITIES = ["model", "field", "form", "listview", "datarule", "businessrule", "workflow", "onlinejs"];
 const COMPOSER_ROUTES = Object.freeze([
+    {
+        id: "model-purge",
+        command: "omc model-purge --code <模型code> --purge-instances --apply",
+        usage: "omc model-purge --help",
+        summary: "清理一个模型：先删流程实例，再 model.delete 级联带走流程模板/视图/字段/表单/规则；默认 dry-run，不可删的停滞实例会跳过并在结尾列出",
+        // r15: "清理本轮创建的模型和流程实例" matched approval-flow (流程 + 创建)
+        // and would have CREATED a workflow instead of removing one. Cleanup intents
+        // are their own composer, and this one comes first.
+        groups: [["清理", "删除", "移除", "回收", "清除", "purge", "teardown", "clean", "remove"], ["模型", "实例", "数据", "model", "instance", "data"]],
+        avoid: ["字段", "角色", "部门", "视图", "按钮", "规则图"],
+        topics: ["omc-write-hazards"],
+    },
     {
         id: "model-scaffold",
         command: "omc model-scaffold --code <模型code> --name <模型名> --fields '<JSON数组>' --apply",
@@ -339,7 +385,7 @@ const COMPOSER_ROUTES = Object.freeze([
         summary: "线性审批流一条命令：建流程 → 模板+字段只读权限 → 发布（多级用重复 --steps）",
         groups: [["审批", "流程"], ["建", "创建", "新建", "配置", "加", "搭"]],
         // Branching / countersign shapes are NOT this composer's business.
-        avoid: ["条件分支", "分支", "会签", "并行", "或签", "网关", "子流程", "动态审批人"],
+        avoid: ["条件分支", "分支", "会签", "并行", "或签", "网关", "子流程", "动态审批人", "清理", "删除", "移除", "purge", "teardown"],
         topics: ["omc-five-piece-flow"],
     },
     {
@@ -531,7 +577,7 @@ export function goalRoute(registry, goal) {
             if (readish) {
                 return { capability: id, lane: capability.lane, readTools: readToolsInLane(registry, capability.lane), firstCommand: `omc capability ${id}` };
             }
-            const recipe = bestRecipe(registry, id, capability.lane, goal);
+            const recipe = bestRecipe(registry, id, capability.lane, goal) ?? defaultRecipeFor(registry, id, capability.lane);
             return {
                 capability: id,
                 lane: capability.lane,
@@ -553,7 +599,21 @@ export function goalRoute(registry, goal) {
             confident: true,
             mode: whole ? "whole-package" : mode,
             match: { kind: readish ? "read-ladder" : "ladder", ref: ordered.join("→"), capabilities: ordered },
-            route: { ...(whole ? { primary: "intent", atomicSupplement } : { ladder }), ...routeReads(readSections), firstCommands: [DISCOVERY_AUTHORITY.readiness], write, ...(readish ? { readback: true } : {}) },
+            route: {
+                ...(whole ? { primary: "intent", atomicSupplement } : { ladder }),
+                ...routeReads(readSections),
+                // Each ladder step already carried a runnable recipe command, but it sat
+                // buried at `ladder[i].recipe.command` behind a readiness line — r14's
+                // probe reported "ladder 本身没给可直接跑的命令" and hand-built the rule
+                // 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] : []),
+                ],
+                write,
+                ...(readish ? { readback: true } : {}),
+            },
             write,
             ...(whole ? { intent: intentGuidance() } : {}),
         };