@stalfh233/omc-cli 0.4.85 → 0.4.87

package/README.md

@@ -130,10 +130,12 @@ omc call discover_environment --env <env> --args '{}'   # 环境就绪（真实
 - **intent**：`partial` 表示该能力可声明式（`omc intent`）覆盖一部分——通常 create/update；
   `none` 表示只走 `omc call`。删除类、方法面、分类/连接池等仍走 `omc call` 逃生舱。
 
-## 近期能力（0.4.74 → 0.4.84）
+## 近期能力（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` 并给平台侧出路 |
 | 0.4.82 | **流程发起权限（40009）**：新增 `workflow.permissions` / `workflow.addPermission` / `workflow.removePermission`（`/workflow/list_permission`、`create_permission`、`delete_permission`，unitType 线上为枚举序号 1=部门 2=角色 3=用户）。`data.submit`/`data.save+workflowCode` 的 40009 现在直接回 `workflow-start-permission-denied`：带上该流程的权限行现状、两种成因（无权限行 / 发起人部门记录已失效）与可粘贴的修复命令，不再是「流程发起权限不足」五个字 |

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

@@ -321,7 +321,75 @@ function orderedCapabilities(ids, index) {
  * runtime/exact patches), not a second main path.
  */
 const WHOLE_PACKAGE_CAPABILITIES = ["model", "field", "form", "listview", "datarule", "businessrule", "workflow", "onlinejs"];
-/** A whole-package ask (build OR modify) is a declarative-intent candidate. */
+const COMPOSER_ROUTES = Object.freeze([
+    {
+        id: "model-scaffold",
+        command: "omc model-scaffold --code <模型code> --name <模型名> --fields '<JSON数组>' --apply",
+        usage: "omc model-scaffold --help",
+        summary: "一条命令建模型：模型 → N 字段（subFields 子表+子列）→ 发布字段 → 发布表单；apply 前逐字段 dry-run 预检、零写入",
+        // (build verb) × (model noun) × (field/child-table noun)
+        groups: [["建", "创建", "新建", "搭建", "从零"], ["模型"], ["字段", "子表", "列", "属性", "明细"]],
+        avoid: ["嵌套子表", "子表套子表"],
+        topics: ["omc-business-configuration"],
+    },
+    {
+        id: "approval-flow",
+        command: "omc approval-flow --schema <模型code> --steps '<节点名>@role:<角色code>' --apply",
+        usage: "omc approval-flow --help",
+        summary: "线性审批流一条命令：建流程 → 模板+字段只读权限 → 发布（多级用重复 --steps）",
+        groups: [["审批", "流程"], ["建", "创建", "新建", "配置", "加", "搭"]],
+        // Branching / countersign shapes are NOT this composer's business.
+        avoid: ["条件分支", "分支", "会签", "并行", "或签", "网关", "子流程", "动态审批人"],
+        topics: ["omc-five-piece-flow"],
+    },
+    {
+        id: "compute",
+        command: "omc compute --schema <模型code> --target <目标字段> --formula '<公式>' [--where '<子列> = <值>'] --apply",
+        usage: "omc compute --help",
+        summary: "字段计算规则一条命令（datarule type2）：普通表达式、子表求和、条件计数 COUNTIF/SUMIF；服务端 submit/update 时回填",
+        groups: [["计算", "统计", "汇总", "求和", "聚合", "计数", "合计"], ["字段", "子表", "列", "回主表", "写入"]],
+        avoid: [],
+        topics: ["omc-write-hazards"],
+    },
+    {
+        id: "rule-when",
+        // `--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: [["规则", "条件"], ["如果", "当", "满足", "时"], ["更新", "赋值", "改为", "设为", "动作"]],
+        avoid: [],
+        topics: ["omc-business-configuration"],
+    },
+    {
+        id: "form-default",
+        // 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: [["默认值", "默认"], ["表单", "字段"]],
+        avoid: [],
+        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")
+        return undefined;
+    for (const composer of COMPOSER_ROUTES) {
+        if (composer.avoid?.some((phrase) => goal.includes(phrase)))
+            continue;
+        if (!composer.groups.every((group) => group.some((cue) => goal.includes(cue))))
+            continue;
+        return composer;
+    }
+    return undefined;
+}
 function isWholePackageWrite(mode, goal, capabilityCount) {
     return (mode === "build" || mode === "modify") && looksWholePackage(goal, capabilityCount);
 }
@@ -400,6 +468,33 @@ export function goalRoute(registry, goal) {
             route: { write: false, readback: false, firstCommands: ["omc capabilities", "omc capability <id>", "omc help omc-capability-scouting"] },
         };
     }
+    // Composer before the capability solver: a recurring write SHAPE has a single
+    // command that does the job with preflight + idempotency, which beats a ladder
+    // of atomic tools even when the ladder also matches (r13: 26 field.create).
+    const composer = matchComposer(goal, mode);
+    if (composer) {
+        const topics = (composer.topics ?? []).filter((topic) => availableTopics.has(topic));
+        return {
+            status: "ok",
+            goal,
+            confident: true,
+            mode,
+            write: true,
+            match: { kind: "composer", ref: composer.id, title: composer.summary, command: composer.command },
+            route: {
+                composer: composer.id,
+                command: composer.command,
+                summary: composer.summary,
+                // The composer IS the first step; readiness still comes first because
+                // the command needs a bound environment to run.
+                firstCommands: [DISCOVERY_AUTHORITY.readiness, composer.command, composer.usage],
+                write: true,
+                readback: true,
+                ...(topics.length > 0 ? { readCommands: topics.map((topic) => `omc help ${topic} --section "<节>"`), readHint: "只在 composer 的 --help 不够用时再读这些 topic 的对应节" } : {}),
+            },
+            ...(topics.length > 0 ? { topics } : {}),
+        };
+    }
     const scores = [...capabilityScores(registry, goal).entries()].sort((left, right) => right[1] - left[1]);
     const fallback = {
         status: "ok",

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/runtime-data.js

@@ -8,7 +8,7 @@ import { ToolInputError, ToolRefusalError } from "../tool-types.js";
 import { writeTool } from "../write.js";
 import { defineTool } from "../tool-types.js";
 import { wireCall, wireRows, WireError } from "../wire.js";
-import { CHILD_TABLE_PROPERTY_TYPE, runtimeWriteWithAppMapping } from "../runtime-support.js";
+import { CHILD_TABLE_PROPERTY_TYPE, diagnoseApprovalSubmitIdentity, runtimeWriteWithAppMapping } from "../runtime-support.js";
 import { getReplayToken, searchWorkItems, wireString } from "../workflow-support.js";
 import { ENGINE_OWNED_KEYS, RUNTIME_DATA_LANE_CONTRACT, RUNTIME_DATA_WIRE, runtimeFormDataArg, } from "./runtime-data-contract.js";
 import { SYSTEM_FIELD_CODES } from "../field-families.js";
@@ -1083,6 +1083,11 @@ export function registerRuntimeDataLane(tools) {
             payload.runMode = args.runMode;
         if (typeof args.isSimulative === "boolean")
             payload.isSimulative = args.isSimulative;
+        // Approval submits are resolved against the LOGGED-IN user (r13: six
+        // blind 40005s). Name the boundary before the write instead of letting the
+        // platform answer "权限不足", which reads like a misconfiguration.
+        if (hasWorkItem)
+            await diagnoseApprovalSubmitIdentity(session, { workflowInstanceId: args.workflowInstanceId, workItemId: args.workItemId });
         const performed = await runtimeWriteWithAppMapping(session, args.schemaCode, 50000, "data.submit 运行时提交稳定失败（50000）", () => wireCall(session, {
             path: ENDPOINTS.runtimeFormSubmit,
             method: "POST",

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/runtime-support.js

@@ -2,6 +2,7 @@ import { wireCall, wireRows, WireError } from "./wire.js";
 import { ENDPOINTS } from "./endpoints.js";
 import { ToolRefusalError } from "./tool-types.js";
 import { resolveModelTreeNode } from "./lanes/model.js";
+import { listInstanceActivities, wireString } from "./workflow-support.js";
 /**
  * Ticket 78 — map the two same-root-cause platform failures of an
  * UNPUBLISHED application to the explicit `app-not-published` blocker:
@@ -222,4 +223,94 @@ async function resolvePublishedWorkflowCodeQuiet(session, schemaCode) {
         return undefined;
     }
 }
+/**
+ * 40005 权限不足 on an APPROVAL submit — the caller is not a participant of the
+ * pending work item.
+ *
+ * r13 (2026-10-24, 1.1.25) could not verify "审批通过" at all: the todo existed,
+ * `workflow.instanceActivity` showed the node active with the right participant,
+ * and `data.submit` with `workItemId` + `agree:true` answered a bare
+ * `40005 权限不足`. Six attempts, plus two round trips spent trying to add an
+ * approval node as a workaround, before a control experiment (clearing the role
+ * membership so the participant fell back to the originator) proved the cause:
+ * **the platform submits as the logged-in user**, and OMC holds exactly one
+ * session, so an approval addressed to anyone else can never be driven from the
+ * CLI.
+ *
+ * This is a capability boundary, not a config defect — but a boundary the CLI
+ * must NAME, because "权限不足" reads like a permission misconfiguration. Fail
+ * open whenever the participant set is unknown (no active activity, empty
+ * participantors, or a read failure): a diagnosis must never invent a refusal.
+ */
+export async function diagnoseApprovalSubmitIdentity(session, args) {
+    const instanceId = typeof args.workflowInstanceId === "string" ? args.workflowInstanceId : "";
+    if (!instanceId)
+        return;
+    let activities;
+    let me;
+    try {
+        activities = await listInstanceActivities(session, instanceId);
+        // `organization/user/info` needs an `id`; resolve "me" from the login
+        // identity (the username the token was issued for) through user/search.
+        const identity = (await session.login()).accountIdentity;
+        me = null;
+        if (identity !== undefined && identity.length > 0) {
+            const searchData = (await wireCall(session, {
+                path: ENDPOINTS.organizationUserSearch,
+                method: "POST",
+                body: { wd: identity, page: 0, size: 20 },
+            })).data;
+            // user/search answers a page envelope ({content:[…]}), not a bare array —
+            // `wireRows` refuses that shape (same decode as `org.user.search`).
+            const found = Array.isArray(searchData?.content) ? searchData.content : wireRows(searchData);
+            const exact = found.find((row) => [row.username, row.userId, row.name].some((value) => String(value ?? "") === identity)) ?? found[0];
+            if (exact) {
+                const id = wireString(exact.id) ?? wireString(exact.userId);
+                if (id)
+                    me = (await wireCall(session, { path: ENDPOINTS.organizationUserInfo, query: { id } })).data;
+                if (!me && exact)
+                    me = exact;
+            }
+        }
+    }
+    catch {
+        return; // Unreadable faces: let the platform answer.
+    }
+    const myId = me ? wireString(me.id) ?? wireString(me.userId) : undefined;
+    if (!myId)
+        return;
+    const myName = me ? wireString(me.name) ?? myId : myId;
+    // Only an activity that currently HOLDS tasks can be submitted against.
+    const active = activities.filter((row) => String(row.status ?? "") === "1");
+    if (active.length === 0)
+        return;
+    const participantIds = (row) => {
+        const list = Array.isArray(row.participantors) ? row.participantors : [];
+        return list.map((person) => wireString(person.id) ?? wireString(person.userId) ?? "").filter((id) => id.length > 0);
+    };
+    const known = active.filter((row) => participantIds(row).length > 0);
+    // Nobody publishes a participant list (auto/service tasks): stay silent.
+    if (known.length === 0)
+        return;
+    if (known.some((row) => participantIds(row).includes(myId)))
+        return;
+    const awaiting = known
+        .map((row) => ({ activityName: wireString(row.activityName) ?? null, activityCode: wireString(row.activityCode) ?? null, participants: participantIds(row) }))
+        .filter((row) => row.participants.length > 0);
+    throw new ToolRefusalError({
+        status: "refused",
+        blocker: "submit-workitem-not-mine",
+        workflowInstanceId: instanceId,
+        ...(typeof args.workItemId === "string" ? { workItemId: args.workItemId } : {}),
+        currentUser: { id: myId, name: myName },
+        awaiting,
+        message: `当前登录人 ${myName}（${myId}）不是该实例待办节点的参与者，平台会以 **40005 权限不足** 拒绝这次提交。` +
+            `待办持有者：${awaiting.map((row) => `${row.activityName ?? row.activityCode ?? "?"} → ${row.participants.join("/")}`).join("；")}。` +
+            `**这是 OMC 的能力边界**：平台按登录态鉴权，而 OMC 一次只持有一个会话（一份 token 缓存），` +
+            `因此「非发起人身份的审批」无法在 CLI 内推进。可选做法：① 由该参与人自己在门户审批；` +
+            `② 用该参与人的账号另建一个环境（omc env add）再执行同一条 data.submit；` +
+            `③ 若只是为了验证流程能走通，把该节点参与人临时改为发起人（org.role.addUsers / workflow.update），验证后改回。` +
+            `不要重复盲试——同一个 workItemId 会一直回 40005。`,
+    });
+}
 //# sourceMappingURL=runtime-support.js.map

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.85",
+  "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.85",
+    "@stalfh233/omc-fake-platform": "0.4.87",
     "commander": "14.0.3",
-    "omc-core": "0.4.85",
+    "omc-core": "0.4.87",
     "proper-lockfile": "4.1.2",
     "write-file-atomic": "6.0.0",
     "zod": "^3.23.8",