@stalfh233/omc-cli 0.4.86 → 0.4.87

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.86）
+## 近期能力（0.4.74 → 0.4.87）
 
 | 版本 | 新增 / 修复 |
 |---|---|
+| 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 被判失败 |
 | 0.4.83 | **r12 真机探针修正（最重要：文档纠错）**：字段计算规则（`datarule` type2）**由服务端在 `data.submit`/`data.update` 时计算并回填，且覆盖传入值**——此前 skills/describe 六处写的「API 不回填、服务端聚合需二开」是错的（旧证据只覆盖 `FORMULA(100)` 字段）。另：`omc compute` 新增 `--where "<子列> = <值>"`（编译 COUNTIF/SUMIF）并**拒绝无条件子表聚合**（`--allow-unfiltered` 显式放行）；`model.delete` 把「孤儿模型」死锁变成一次明确回答——先复查读缓存，仍存在则回 `model-orphaned-record` 并给平台侧出路 |

package/dist/endpoints.js

@@ -165,6 +165,18 @@ export const ENDPOINTS = {
     workflowCreatePermission: "/api/api/workflow/create_permission",
     workflowDeletePermission: "/api/api/workflow/delete_permission",
     workflowSearchWorkItems: "/api/api/runtime/workflow/search_workitems",
+    /**
+     * The JPA-spec work-item query (WorkflowInstanceController.listWorkItems).
+     *
+     * Distinct from `search_workitems` in a way that matters: search resolves each
+     * hit's workflow template (`buildTempEntity`) and NPEs the WHOLE page when one
+     * work item points at a template row that no longer exists (r14 live: a stale
+     * `inspHazardFlow` reference made every unscoped `workitem.list` answer 50000,
+     * eight times in a row). This endpoint builds a WorkItemQuerySpec and queries
+     * the table directly — no template resolution — and it accepts `participant`,
+     * so it can answer "what is pending for user X", not only "for me".
+     */
+    workflowListWorkItems: "/api/api/runtime/workflow/list_workitems",
     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

@@ -353,7 +353,9 @@ const COMPOSER_ROUTES = Object.freeze([
     },
     {
         id: "rule-when",
-        command: "omc rule-when --schema <模型code> --rule <规则code> --when '<条件>' --then '<动作>'",
+        // `--on` is the trigger (Create/Update/…), not `--rule`: r14's template
+        // invented a flag, and the new template-vs---help test caught it offline.
+        command: "omc rule-when --schema <模型code> --on Create --when '<条件>' --then 'set:<字段code>=<值>'",
         usage: "omc rule-when --help",
         summary: "条件→动作规则一条命令（BRANCH + 赋值节点拼装），替代手拼 nodeGraph",
         groups: [["规则", "条件"], ["如果", "当", "满足", "时"], ["更新", "赋值", "改为", "设为", "动作"]],
@@ -362,7 +364,10 @@ const COMPOSER_ROUTES = Object.freeze([
     },
     {
         id: "form-default",
-        command: "omc form-default --schema <模型code> --field <字段code> --value <值>",
+        // The flag is `--default`, not `--value` (r14: the template was wrong and the
+        // probe's copy-paste failed with `unknown option '--value'`). Composers must
+        // emit commands that actually parse — a wrong skeleton is worse than none.
+        command: "omc form-default --schema <模型code> --field <字段code> --default <值> --apply",
         usage: "omc form-default --help",
         summary: "表单字段默认值一条命令（建表单/复用已有表单 + 写默认值），无需手改 options",
         groups: [["默认值", "默认"], ["表单", "字段"]],
@@ -370,6 +375,8 @@ const COMPOSER_ROUTES = Object.freeze([
         topics: ["omc-business-configuration"],
     },
 ]);
+/** Test seam: the composer registry, so a template typo can be caught offline. */
+export const COMPOSER_ROUTES_FOR_TEST = COMPOSER_ROUTES;
 function matchComposer(goal, mode) {
     // A composer is a WRITE path: reads and scouting asks must keep their ladder.
     if (mode !== "build" && mode !== "modify")

package/dist/lanes/model.js

@@ -17,6 +17,32 @@ import { wireCall, wireRows, WireError } from "../wire.js";
 import { MODEL_CREATE_BODY_DEFAULTS, MODEL_LANE_CONTRACT } from "./model-contract.js";
 const MODEL_LANE = MODEL_LANE_CONTRACT.lane;
 const MODEL_TOOLS = MODEL_LANE_CONTRACT.tools;
+/**
+ * Pending work items for every workflow attached to this model.
+ *
+ * Best-effort (empty on any failure) — it exists to warn before a cascade that
+ * orphans todos, never to block the delete.
+ */
+async function pendingWorkflowItems(session, schemaCode) {
+    try {
+        const isWorkflow = (await wireCall(session, { path: ENDPOINTS.workflowIsWorkflow, query: { schemaCode } })).data === true;
+        if (!isWorkflow)
+            return [];
+        const template = (await wireCall(session, { path: ENDPOINTS.workflowGetBySchema, query: { schemaCode } })).data;
+        const workflowCode = template && typeof template.workflowCode === "string" ? template.workflowCode : "";
+        if (!workflowCode)
+            return [];
+        const data = (await wireCall(session, {
+            path: ENDPOINTS.workflowListWorkItems,
+            query: { workflowCode, status: "PENDING", page: "0", size: "1" },
+        })).data;
+        const total = Number(data?.totalElements ?? 0);
+        return Number.isFinite(total) && total > 0 ? [{ workflowCode, pending: total }] : [];
+    }
+    catch {
+        return [];
+    }
+}
 function modelRollbackSpec(toolName) {
     return {
         target: (args) => `model:${String(args.schemaCode ?? args.code ?? "")}`,
@@ -586,6 +612,12 @@ export function registerModelLane(tools) {
                 message: `${args.schemaCode} 被模型 ${referencingModels.map((model) => model.schemaCode).join("、")} 的关联字段引用，不能删除（服务端 deleteFunctions 的异步拒绝已提前到调用时）。依赖倒序清理：先删引用方模型（或先删其关联字段），再删被引用模型；引用方物理删除的逐列异步级联需 40-60s，完成后再删本模型。`,
             });
         }
+        // Model deletion CASCADES the workflow template away but leaves
+        // `biz_workitem` rows pointing at it. The platform's global todo search
+        // resolves every hit's template, so ONE orphan NPEs the whole page for
+        // everyone (r14 live: 8 consecutive 50000s; cleanup needed a maintainer
+        // with DB access). Warn while it is still actionable.
+        const liveWorkflows = await pendingWorkflowItems(session, args.schemaCode);
         const performed = await wireCall(session, {
             path: ENDPOINTS.appPackagePhysicallyDelete,
             method: "POST",
@@ -608,6 +640,18 @@ export function registerModelLane(tools) {
             readback: {
                 absent,
                 treeNodePending,
+                ...(liveWorkflows.length > 0
+                    ? {
+                        workflowWarning: {
+                            code: "model-deleted-with-pending-work-items",
+                            severity: "warning",
+                            workflows: liveWorkflows,
+                            message: `删除前该模型的流程还有未完结待办（${liveWorkflows.map((row) => `${row.workflowCode}:${row.pending}`).join("、")}）。` +
+                                `模型删除会级联掉流程模板，但**不会**清掉这些待办；它们从此指向空模板，而平台全局待办搜索会给每条待办解析模板 —— **一条缺失就整页 NPE（50000），所有用户的待办列表一起坏掉**（r14 实测 8 连击，只能靠维护者清库恢复）。` +
+                                `若 now 已经删了：用 workitem.list 的 \`workflowCode\` 或 \`participant\` 参数绕开全局搜索，并请维护者清理这些脏待办。下次请先完结实例再删模型。`,
+                        },
+                    }
+                    : {}),
                 ...(absent
                     ? {}
                     : {

package/dist/lanes/workflow.js

@@ -8,7 +8,7 @@ import { registerPackageTool } from "../package-tool.js";
 import { writeSummary } from "../human-summary.js";
 import { defineTool, ToolInputError } from "../tool-types.js";
 import { wireCall, wireRows, WireError } from "../wire.js";
-import { diagnoseInstanceActivity, getInstanceBaseInfo, listInstanceActivities, resolveBizObjectIdByInstance, searchWorkItems, wireString } from "../workflow-support.js";
+import { diagnoseInstanceActivity, getInstanceBaseInfo, listInstanceActivities, listWorkItemsByParticipant, resolveBizObjectIdByInstance, searchWorkItems, wireString } from "../workflow-support.js";
 import { readSchemaFormButtons } from "../form-support.js";
 import { WORKFLOW_EVENT_HANDLER_FIELDS, WORKFLOW_NODE_EVENT_HANDLER_FIELDS, WORKFLOW_LANE_CONTRACT, workflowTemplateArg } from "./workflow-contract.js";
 import { PLATFORM_TRIGGER_RULE_CODES } from "./rule-graph.js";
@@ -1646,6 +1646,25 @@ function workflowRollbackSpec(toolName) {
         },
     };
 }
+/**
+ * How many workflow instances for this model are still unfinished.
+ *
+ * Best-effort (0 on any failure): it exists to WARN before a delete that would
+ * orphan todos, never to block one.
+ */
+async function countPendingWorkItems(session, workflowCode) {
+    try {
+        const data = (await wireCall(session, {
+            path: ENDPOINTS.workflowListWorkItems,
+            query: { workflowCode, status: "PENDING", page: "0", size: "1" },
+        })).data;
+        const total = Number(data?.totalElements ?? 0);
+        return Number.isFinite(total) && total > 0 ? total : 0;
+    }
+    catch {
+        return 0;
+    }
+}
 async function mergedTemplateBody(session, schemaCode, code, template, merge = false) {
     const draft = await getWorkflowDraftOrNull(session, code);
     if (draft == null)
@@ -2518,11 +2537,29 @@ export function registerWorkflowLane(tools) {
         };
     }, undefined, undefined, workflowRollbackSpec("workflow.update"));
     writeTool(tools, "workflow.delete", WORKFLOW_LANE, WORKFLOW_TOOLS["workflow.delete"].scope, WORKFLOW_TOOLS["workflow.delete"].description, { schemaCode: z.string().min(1), code: z.string().min(1) }, async (session, args) => {
-        const performed = await wireCall(session, {
-            path: ENDPOINTS.workflowDelete,
-            method: "POST",
-            query: { workflowCode: args.code },
-        });
+        let performed;
+        try {
+            performed = await wireCall(session, { path: ENDPOINTS.workflowDelete, method: "POST", query: { workflowCode: args.code } });
+        }
+        catch (error) {
+            // 402508 流程实例已存在 — the platform refuses on purpose. Previously it
+            // arrived as a bare wire code, so the caller's next move was to delete the
+            // MODEL instead (which cascades the template away and leaves orphan todos
+            // pointing at nothing — r14's 8× 50000). Name the order.
+            if (error instanceof WireError && error.kind === "business" && error.errcode === 402508) {
+                const pending = await countPendingWorkItems(session, args.code);
+                throw new ToolRefusalError({
+                    status: "refused",
+                    blocker: "workflow-has-instances",
+                    workflowCode: args.code,
+                    ...(pending > 0 ? { pendingWorkItems: pending } : {}),
+                    message: `流程 ${args.code} 还有流程实例，平台拒绝删除（402508）。**不要改用 model.delete 绕过**——那会把流程模板级联删掉，` +
+                        `留下指向空模板的待办，而平台全局待办搜索会给每条待办解析模板，**一条缺失就整页 NPE（50000），所有用户的待办列表一起坏掉**（r14 实测 8 连击，需维护者清库）。` +
+                        `正确顺序：① 先完结/清理实例的待办（workitem.list --workflowCode ${args.code} 看还有哪些在办）；② 再 workflow.delete；③ 最后才 model.delete。`,
+                });
+            }
+            throw error;
+        }
         const header = await wireCall(session, { path: ENDPOINTS.workflowGetHeader, query: { workflowCode: args.code } }).catch(() => ({ data: null }));
         return { performed: { errcode: performed.errcode }, readback: { workflowCode: args.code, absent: header.data === null || header.data === undefined } };
     }, undefined, undefined, workflowRollbackSpec("workflow.delete"));
@@ -2607,6 +2644,14 @@ export function registerWorkflowLane(tools) {
                 .describe("exact-match client-side filter on the returned items' instanceId (the server filterWorkflowInstanceId field is a NOT-equal exclusion, so it is not used)"),
             workflowCode: z.string().optional(),
             schemaCode: z.string().optional(),
+            participant: z
+                .string()
+                .optional()
+                .describe("按**指定用户**的待办查询（用户 id）。省略=当前登录人。用它查别人名下的待办——全局搜索会按登录人过滤，查不到别人的（审批走不通时的第一个诊断手段）"),
+            state: z
+                .enum(["PENDING", "NOTSTARTED", "INPROGRESS", "DRAFT", "PAUSE", "FINISHED"])
+                .optional()
+                .describe("待办状态，配合 participant 使用；默认 PENDING（在办）"),
             // r35: an agent sent page:1 expecting the first page and read
             // `total:1 / count:0` as a contradiction — the page index is ZERO-based
             // (like data.list). Say so at the parameter itself.
@@ -2621,13 +2666,53 @@ export function registerWorkflowLane(tools) {
             capability: capabilityArg,
         },
         handler: async (ctx, args, self) => governedRead(ctx, self, args, async (session) => {
-            const page = await searchWorkItems(session, {
-                ...(args.workflowInstanceId ? { instanceId: args.workflowInstanceId } : {}),
-                ...(args.workflowCode ? { workflowCode: args.workflowCode } : {}),
-                ...(args.schemaCode ? { schemaCode: args.schemaCode } : {}),
-                page: args.page ?? 0,
-                size: args.size ?? (args.workflowInstanceId ? 200 : 20),
-            });
+            // `participant` takes the JPA-spec endpoint: it can answer "what is
+            // pending for user X" and it does not resolve templates, so a dangling
+            // reference elsewhere cannot take it down.
+            let page;
+            if (args.participant !== undefined) {
+                page = await listWorkItemsByParticipant(session, {
+                    participant: args.participant,
+                    ...(args.state !== undefined ? { status: args.state } : {}),
+                    ...(args.workflowCode !== undefined ? { workflowCode: args.workflowCode } : {}),
+                    page: args.page ?? 0,
+                    size: args.size ?? 20,
+                });
+            }
+            else {
+                try {
+                    page = await searchWorkItems(session, {
+                        ...(args.workflowInstanceId ? { instanceId: args.workflowInstanceId } : {}),
+                        ...(args.workflowCode ? { workflowCode: args.workflowCode } : {}),
+                        ...(args.schemaCode ? { schemaCode: args.schemaCode } : {}),
+                        page: args.page ?? 0,
+                        size: args.size ?? (args.workflowInstanceId ? 200 : 20),
+                    });
+                }
+                catch (error) {
+                    // r14: one work item pointing at a missing workflow-template row makes
+                    // the WHOLE search NPE (buildTempEntity → BeanUtils.copyProperties
+                    // (null,…)). The probe hit this eight times consecutively because the
+                    // message said only "50000 服务异常". Name the cause and the way round
+                    // it instead of leaving a dead end.
+                    if (!(error instanceof WireError) || error.kind !== "business" || error.errcode !== 50000)
+                        throw error;
+                    throw new ToolRefusalError({
+                        status: "refused",
+                        blocker: "workitem-search-unavailable",
+                        retryable: false,
+                        cause: "平台全局待办搜索会给每条待办解析流程模板（buildTempEntity）；只要有一条待办指向已删除的 h_workflow_template 行，整页查询就抛 NPE → 50000。这是平台侧脏引用，不是本工具的入参问题。",
+                        workaround: [
+                            "① 按流程收窄（这一步不解析模板，最可靠）：omc call workitem.list --env <env> --args '{\"workflowCode\":\"<流程code>\"}'",
+                            "② 按人查（能查别人名下的待办）：omc call workitem.list --env <env> --args '{\"participant\":\"<用户id>\"}'",
+                            "③ 只看某实例走到哪：omc call workflow.instanceActivity --env <env> --args '{\"workflowInstanceId\":\"<实例id>\"}'",
+                        ],
+                        message: "平台全局待办搜索当前不可用（50000）：有一条待办指向已删除的流程模板，整页解析直接 NPE——**与你传的参数无关，重试不会变好**。" +
+                            "改用带范围的查询：按 `workflowCode` 收窄，或按 `participant` 查某人的待办（这两条走 JPA 查询，不做模板解析）。" +
+                            "若要彻底恢复全局搜索，需要维护者清掉那条脏待办（平台侧数据修复）。",
+                    });
+                }
+            }
             const selected = page.items;
             // Resolve the in-flight bizObject id per distinct instance. Authoritative
             // source: getBizObjectByWfInstanceId -> BizObjectCreatedModel.id/schemaCode.
@@ -2667,10 +2752,12 @@ export function registerWorkflowLane(tools) {
                 : undefined;
             return {
                 total: page.total,
-                totalPages: page.totalPages,
+                // The JPA-spec path reports no page count; only emit it when known.
+                ...("totalPages" in page && page.totalPages !== undefined ? { totalPages: page.totalPages } : {}),
                 count: items.length,
                 ...(purposeHint ? { purposeHint } : {}),
-                ...(page.unfilteredTotal !== undefined ? { unfilteredTotal: page.unfilteredTotal } : {}),
+                ...(args.participant !== undefined ? { participant: args.participant, state: args.state ?? "PENDING", source: "list_workitems" } : {}),
+                ...("unfilteredTotal" in page && page.unfilteredTotal !== undefined ? { unfilteredTotal: page.unfilteredTotal } : {}),
                 items,
             };
         }),

package/dist/model-scaffold.js

@@ -227,7 +227,18 @@ export async function cmdModelScaffold(args) {
             steps.push({ step: "child:attach", status: "failed", detail: { parent: code, child: child.code, message: reason } });
             continue;
         }
-        steps.push({ step: "child:attach", status: parentOutcome.ok ? "ok" : "skipped", detail: { parent: code, child: child.code } });
+        steps.push({
+            step: "child:attach",
+            status: parentOutcome.ok ? "ok" : "skipped",
+            // r14: `skipped` on both the attach and the child columns read as "the
+            // sub-columns never got created", when in fact attaching the parent
+            // CHILD_TABLE creates them. Say so on the step itself.
+            detail: {
+                parent: code,
+                child: child.code,
+                note: parentOutcome.ok ? "子表字段与子列在这一次 attach 中一起建立；随后的 child:field.create 返回 already-present 是正常的" : "子表已存在（含子列），跳过",
+            },
+        });
         await createFields(child.code, scaffoldChildrenOf(child), "child");
     }
     // 4) 发布字段：半成品不发布（比不发布更难查）。

package/dist/workflow-support.js

@@ -182,4 +182,38 @@ export function diagnoseInstanceActivity(input) {
         warnings: fallbackSuspect ? ["participant-fallback-to-originator"] : [],
     };
 }
+/**
+ * Work items for a SPECIFIC participant, from the JPA-spec endpoint.
+ *
+ * Two jobs the global search cannot do (r14, 2026-10-24):
+ *   1. survive a dangling template reference — `search_workitems` resolves each
+ *      hit's template and NPEs the entire page when one is missing (a stale
+ *      `inspHazardFlow` made every unscoped call answer 50000, 8× in a row);
+ *   2. answer "what is pending for user X". `search_workitems` filters to the
+ *      logged-in user server-side, so an approval held by someone else is
+ *      invisible — which is exactly the question the approval flow needs.
+ */
+export async function listWorkItemsByParticipant(session, filter) {
+    const query = {
+        participant: filter.participant,
+        status: filter.status ?? "PENDING",
+        page: String(filter.page ?? 0),
+        size: String(filter.size ?? 200),
+        participantUnitType: "3",
+    };
+    if (filter.workflowCode)
+        query.workflowCode = filter.workflowCode;
+    const data = (await wireCall(session, { path: ENDPOINTS.workflowListWorkItems, query })).data;
+    const page = data?.content !== undefined ? data : data;
+    const rows = Array.isArray(page?.content)
+        ? page.content
+        : wireRows(page);
+    const total = Number(data?.totalElements ?? page?.totalElements ?? rows.length);
+    const totalPages = Number(data?.totalPages ?? page?.totalPages);
+    return {
+        total: Number.isFinite(total) ? total : rows.length,
+        ...(Number.isFinite(totalPages) ? { totalPages } : {}),
+        items: rows,
+    };
+}
 //# sourceMappingURL=workflow-support.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stalfh233/omc-cli",
-  "version": "0.4.86",
+  "version": "0.4.87",
   "description": "CloudPivot 8.6 configuration capability CLI — governed, fail-closed, coverage-manifest bounded.",
   "type": "module",
   "bin": {
@@ -50,9 +50,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@stalfh233/omc-fake-platform": "0.4.86",
+    "@stalfh233/omc-fake-platform": "0.4.87",
     "commander": "14.0.3",
-    "omc-core": "0.4.86",
+    "omc-core": "0.4.87",
     "proper-lockfile": "4.1.2",
     "write-file-atomic": "6.0.0",
     "zod": "^3.23.8",