@stalfh233/omc-cli 0.6.15 → 0.6.17

package/dist/lanes/workflow.js

@@ -19,6 +19,24 @@ const WORKFLOW_LANE = WORKFLOW_LANE_CONTRACT.lane;
 const WORKFLOW_TOOLS = WORKFLOW_LANE_CONTRACT.tools;
 const WORKFLOW_ACTIVITY_TYPES = new Set(["START", "END", "CONNECTION", "PARTICIPANT", "SUB_INSTANCE", "CIRCULATE", "SYSTEM_ACTIVITY", "AGENT_ACTIVITY"]);
 const WORKFLOW_POINT = /^-?\d+(?:\.\d+)?,\s-?\d+(?:\.\d+)?$/;
+/** Keep workitem.list's external envelope aligned with data.list. */
+export function workItemListCompactProjection(result) {
+    const compact = {};
+    for (const [key, value] of Object.entries(result)) {
+        if (key !== "items" || !Array.isArray(value)) {
+            if (key !== "ids" && key !== "itemsPreview" && key !== "listArtifactHint")
+                compact[key] = value;
+            continue;
+        }
+        const rows = value;
+        const ids = rows.map((row) => row.workItemId).filter((id) => typeof id === "string" && id.length > 0);
+        compact.itemsCount = rows.length;
+        compact.ids = ids;
+        compact.itemsPreview = ids.slice(0, 3).map((id) => ({ id }));
+        compact.listArtifactHint = "items 已外置（truncatedKeys/omittedKeys 含 items）：完整待办见 artifact；ids=本页全部 workItemId，itemsPreview=前 3 个 id 引用。";
+    }
+    return compact;
+}
 /**
  * Conditional branch lines (round7). `routes[]` maps to the platform `Rule`
  * DTO (Rule.java:28-59), which carries a structured branch condition
@@ -749,6 +767,18 @@ function participantReferenceWarnings(template) {
     }
     return warnings;
 }
+export function approvalByOriginatorWarnings(template) {
+    const activities = Array.isArray(template.activities) ? template.activities : [];
+    const participants = activities.filter((activity) => String(activity.activityType ?? "") === "PARTICIPANT");
+    if (participants.length === 0 || !participants.every((activity) => String(activity.participant ?? "").trim() === "{Originator}"))
+        return [];
+    const activityCodes = participants.map((activity) => String(activity.activityCode ?? "")).filter((code) => code.length > 0);
+    return [{
+            code: "approval-by-originator",
+            activityCodes,
+            message: `所有参与人节点（${activityCodes.join("、")}）都指向 {Originator}：该流程会由发起人自审自批；这是允许的单人流程，但请确认该行为符合业务意图。`,
+        }];
+}
 /**
  * Role participants are filtered by `ouScope ∩ originator's department chain`.
  * A role whose members all have an empty scope therefore resolves to NOBODY —
@@ -764,12 +794,15 @@ async function assertRoleParticipantScopes(session, body) {
             ? Object.values(body.activities)
             : [];
     const roles = [];
+    const functionRoles = [];
     for (const activity of rows) {
         if (String(activity.activityType ?? "") !== "PARTICIPANT")
             continue;
         const raw = activity.participant;
         if (typeof raw !== "string" || !raw.trim().startsWith("["))
             continue;
+        const activityCode = String(activity.activityCode ?? "");
+        const activityName = String(activity.activityName ?? activity.name ?? activityCode);
         for (const segment of raw.split("+")) {
             let parsed;
             try {
@@ -788,7 +821,86 @@ async function assertRoleParticipantScopes(session, body) {
                     continue;
                 const roleId = String(record.id ?? "");
                 if (roleId)
-                    roles.push({ activityCode: String(activity.activityCode ?? ""), roleId, roleName: String(record.name ?? roleId) });
+                    roles.push({ activityCode, activityName, roleId, roleName: String(record.name ?? roleId) });
+            }
+        }
+    }
+    for (const activity of rows) {
+        if (String(activity.activityType ?? "") !== "PARTICIPANT")
+            continue;
+        const participant = typeof activity.participant === "string" ? activity.participant.trim() : "";
+        const match = /^FindUserByRole\s*\(\s*[^,]+?\s*,\s*("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')\s*,\s*("(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')\s*\)\s*$/.exec(participant);
+        if (!match)
+            continue;
+        const quoted = match[1];
+        let roleCode;
+        try {
+            roleCode = quoted.startsWith('"') ? JSON.parse(quoted) : quoted.slice(1, -1).replace(/\\(['\\])/g, "$1");
+        }
+        catch {
+            continue;
+        }
+        if (roleCode.trim())
+            functionRoles.push({ activityCode: String(activity.activityCode ?? ""), activityName: String(activity.activityName ?? activity.name ?? activity.activityCode ?? ""), roleCode: roleCode.trim() });
+    }
+    if (functionRoles.length > 0) {
+        let listedRoles = [];
+        let roleListAvailable = false;
+        try {
+            const data = (await wireCall(session, { path: ENDPOINTS.organizationRoleList, query: { expandAll: "true" } })).data;
+            const flattened = flattenRoleTree(wireRows(data));
+            listedRoles = Array.isArray(flattened.roles) ? flattened.roles : [];
+            roleListAvailable = true;
+        }
+        catch {
+            // Role existence is advisory when the organization read face is unavailable.
+            // Do not turn a transient read failure into a blanket workflow write outage.
+            roleListAvailable = false;
+        }
+        if (roleListAvailable) {
+            const byCode = new Map(listedRoles
+                .map((role) => [String(role.code ?? ""), role])
+                .filter(([code]) => code.length > 0));
+            const missing = functionRoles.filter((role) => !byCode.has(role.roleCode));
+            if (missing.length > 0) {
+                const candidates = (needle) => {
+                    const lower = needle.toLowerCase();
+                    const distance = (left, right) => {
+                        const row = Array.from({ length: right.length + 1 }, (_, index) => index);
+                        for (let i = 1; i <= left.length; i++) {
+                            let diagonal = row[0];
+                            row[0] = i;
+                            for (let j = 1; j <= right.length; j++) {
+                                const prior = row[j];
+                                row[j] = left[i - 1] === right[j - 1] ? diagonal : Math.min(row[j] + 1, row[j - 1] + 1, diagonal + 1);
+                                diagonal = prior;
+                            }
+                        }
+                        return row[right.length];
+                    };
+                    return listedRoles
+                        .map((role) => {
+                        const code = String(role.code ?? "");
+                        const name = String(role.name ?? "");
+                        const haystack = `${code} ${name}`.toLowerCase();
+                        const substringRank = haystack.includes(lower) ? 0 : 1;
+                        const editRank = Math.min(distance(lower, code.toLowerCase()), distance(lower, name.toLowerCase()));
+                        return { code, name, substringRank, editRank };
+                    })
+                        .filter((role) => role.code.length > 0)
+                        .sort((left, right) => left.substringRank - right.substringRank || left.editRank - right.editRank || left.code.localeCompare(right.code))
+                        .slice(0, 5)
+                        .map(({ code, name }) => ({ code, name }));
+                };
+                const first = missing[0];
+                throw new ToolRefusalError({
+                    status: "refused",
+                    blocker: "workflow-participant-role-not-found",
+                    roles: missing,
+                    candidates: candidates(first.roleCode),
+                    nextCommand: "omc call org.role.list --args '{}'",
+                    message: `写前拒绝：节点 ${first.activityCode}（${first.activityName}）引用了不存在的角色 ${first.roleCode}。放行会导致待办静默回退给发起人（r9/r10/r15 真机）。请先用 org.role.list 确认真实 role code。`,
+                });
             }
         }
     }
@@ -2341,12 +2453,14 @@ export function registerWorkflowLane(tools) {
                 return { schemaCode: args.schemaCode, exists: false, note: "该模型没有流程可校验" };
             const template = (args.template ?? {});
             const body = await mergedTemplateBody(session, args.schemaCode ?? "", workflowCode, template, activitiesLackBoundaries(template));
+            await assertRoleParticipantScopes(session, body);
             const result = await wireCall(session, { path: ENDPOINTS.workflowValidate, method: "POST", body });
             const messages = Array.isArray(result.data) ? result.data : [];
             const errors = messages.filter((message) => message.errorLevel === "ERROR");
             const warnings = messages.filter((message) => message.errorLevel !== "ERROR");
             // r31c F23: local reachability / else-coverage — warning only, never flips valid.
             const reachability = workflowReachabilityWarnings(body);
+            const originatorWarnings = approvalByOriginatorWarnings(body);
             const allWarnings = [
                 ...warnings,
                 ...reachability.map((entry) => ({
@@ -2357,6 +2471,7 @@ export function registerWorkflowLane(tools) {
                     name: entry.name,
                     problem: entry.problem,
                 })),
+                ...originatorWarnings.map((entry) => ({ errorLevel: "WARNING", errCode: entry.code, errContent: entry.message, activityCodes: entry.activityCodes })),
             ];
             return {
                 workflowCode,
@@ -2366,6 +2481,7 @@ export function registerWorkflowLane(tools) {
                 errors,
                 warnings: allWarnings,
                 ...(reachability.length > 0 ? { reachabilityWarnings: reachability } : {}),
+                ...(originatorWarnings.length > 0 ? { approvalWarnings: originatorWarnings } : {}),
             };
         }, { target: `workflow.validate:${args.workflowCode ?? args.schemaCode}` }),
     }));
@@ -2468,6 +2584,7 @@ export function registerWorkflowLane(tools) {
             // Evaluate on `body` (post-backfill): the readback may drop the handler
             // keys, and the backfilled permittedAction is exactly what will run.
             const rejectWarnings = rejectToStartCancelWarnings(body);
+            const originatorWarnings = approvalByOriginatorWarnings(body);
             const renamedActivities = renamedActivityPairs(template, data);
             const renamedInPlace = inPlaceRenames(data);
             // Caller sent no routes at all: the draft's edges (branches included) are
@@ -2485,7 +2602,7 @@ export function registerWorkflowLane(tools) {
             const activityNames = Object.fromEntries(rawActivityRows
                 .map((row) => [String(row.activityCode ?? ""), effectiveActivityName(row)])
                 .filter(([code]) => code !== ""));
-            return { performed: { errcode: performed.errcode }, readback: { workflowCode: args.code, activities: Array.isArray(data.activities) ? data.activities.length : rawActivityRows.length, templateType: data.templateType ?? null, activityNames, rollbackHint: `本次改动的 before 快照已记录：omc rollback plan --target workflow:${args.schemaCode}/${args.code} 查看可回退项，omc rollback apply --target … --step <n> 执行（草稿回退后仍需 workflow.publish 才生效）`, ...(participantWarnings.length ? { participantWarnings } : {}), ...(rejectWarnings.length ? { workflowWarnings: rejectWarnings } : {}), ...(branchEdges.length ? { routesInherited: { edges: branchEdges, hint: "本次未传 routes/edges：以上分支边沿用草稿（含 else 兜底）。要改连线请显式回传完整 routes" } } : {}), ...(renamedInPlace.length ? { renamedInPlace, renamedInPlaceHint: "改名已同 code 原地生效（载体 name_i18n，displayName 才是当前名；activityName 是首建值，平台不再变更）" } : {}), ...(renamedActivities.length ? { renamedActivities, renamedHint: "类型变更铸了新码（上表 from→to）且旧码已失效——后续读写一律用 to；再用旧码 from 会被当作新节点追加" } : {}), workflowRenderCompat: workflowRenderCompat(data) } };
+            return { performed: { errcode: performed.errcode }, readback: { workflowCode: args.code, activities: Array.isArray(data.activities) ? data.activities.length : rawActivityRows.length, templateType: data.templateType ?? null, activityNames, rollbackHint: `本次改动的 before 快照已记录：omc rollback plan --target workflow:${args.schemaCode}/${args.code} 查看可回退项，omc rollback apply --target … --step <n> 执行（草稿回退后仍需 workflow.publish 才生效）`, ...(participantWarnings.length ? { participantWarnings } : {}), ...(rejectWarnings.length || originatorWarnings.length ? { workflowWarnings: [...rejectWarnings, ...originatorWarnings] } : {}), ...(branchEdges.length ? { routesInherited: { edges: branchEdges, hint: "本次未传 routes/edges：以上分支边沿用草稿（含 else 兜底）。要改连线请显式回传完整 routes" } } : {}), ...(renamedInPlace.length ? { renamedInPlace, renamedInPlaceHint: "改名已同 code 原地生效（载体 name_i18n，displayName 才是当前名；activityName 是首建值，平台不再变更）" } : {}), ...(renamedActivities.length ? { renamedActivities, renamedHint: "类型变更铸了新码（上表 from→to）且旧码已失效——后续读写一律用 to；再用旧码 from 会被当作新节点追加" } : {}), workflowRenderCompat: workflowRenderCompat(data) } };
         },
         preflight: (args) => {
             // Zero-wire refusal (ticket 77): fires in semanticGate BEFORE the
@@ -2574,6 +2691,7 @@ export function registerWorkflowLane(tools) {
             const body = await mergedTemplateBody(session, args.schemaCode, args.code, template, activitiesLackBoundaries(template));
             await backfillDesignerDefaults(session, args.schemaCode, body, template);
             assertFirstActivityIsOriginator(template, "workflow.publish", body);
+            await assertRoleParticipantScopes(session, body);
             const unregistered = unregisteredParticipantFunctions(body);
             if (unregistered.length > 0)
                 throw new ToolRefusalError({
@@ -2611,7 +2729,8 @@ export function registerWorkflowLane(tools) {
             validateWorkflowRender(data, "workflow.publish readback");
             const participantWarnings = participantReferenceWarnings(data);
             const rejectWarnings = rejectToStartCancelWarnings(data);
-            return { performed: { errcode: performed.errcode }, readback: { workflowCode: args.code, published: isPublished, workflowVersion: data.workflowVersion ?? null, ...(warnings.length ? { warnings } : {}), ...(participantWarnings.length ? { participantWarnings } : {}), ...(rejectWarnings.length ? { workflowWarnings: rejectWarnings } : {}), workflowRenderCompat: workflowRenderCompat(data) } };
+            const originatorWarnings = approvalByOriginatorWarnings(data);
+            return { performed: { errcode: performed.errcode }, readback: { workflowCode: args.code, published: isPublished, workflowVersion: data.workflowVersion ?? null, ...(warnings.length ? { warnings } : {}), ...(participantWarnings.length ? { participantWarnings } : {}), ...(rejectWarnings.length || originatorWarnings.length ? { workflowWarnings: [...rejectWarnings, ...originatorWarnings] } : {}), workflowRenderCompat: workflowRenderCompat(data) } };
         },
         preflight: (args) => {
             assertTemplateNotMinimal(args.template ?? {}, "workflow.publish");
@@ -3205,7 +3324,7 @@ export function registerWorkflowLane(tools) {
                 ...("unfilteredTotal" in page && page.unfilteredTotal !== undefined ? { unfilteredTotal: page.unfilteredTotal } : {}),
                 items,
             };
-        }),
+        }, { compact: workItemListCompactProjection }),
     }));
     tools.push(defineTool({
         name: "workflow.instanceActivity",

package/dist/mcp-graph.js

@@ -59,7 +59,7 @@ const EXPLORE_TOOL = {
     description: [
         "一次查全一个目标的引用与影响面（本地索引，毫秒级）。",
         "输入 query=字段/模型/服务的 code（或规则检索词）；kind 可选 field|model|service，不给则三种都查。",
-        "返回 {index(freshness), references:{kind:[{schemaCode,ruleCode,nodeCode,nodeType,via}]}, impact:{kind:totals}, search:{rules}}。",
+        "返回 {index(freshness), references:{kind:[{schemaCode,ruleCode,nodeCode,nodeType,via}]}, impact:{kind:totals}, search:{matches:{model,field,service},rules}}。",
         "改/删/重命名任何字段、模型、服务之前必查；找\"关于 X 的规则\"拿 code 也走这里。",
         "索引不含规则条件叶子与流程绑定；freshness=partial 时命中可能不完整（答案里有 gapWarning）。",
     ].join(" "),
@@ -116,7 +116,15 @@ export async function executeGraphTool(name, rawArgs) {
             for (const one of kinds) {
                 const ref = queryGraphReferences(one, query);
                 const capped = cap(ref.matches);
-                references[one] = { count: ref.matches.length, ...capped, ...(ref.gapWarning ? { gapWarning: ref.gapWarning } : {}) };
+                // r35a-F4c（真机 2026-11-06）：**MCP 面是第三个消费者**——CLI 的 references
+                // 与 impact 都带 coverage 了，这里若不显式透传，MCP 用户看到的仍是
+                // 「matches:[] + 一句旧 note」，照样会把「表单没扫」误读成「没人引用」。
+                references[one] = {
+                    count: ref.matches.length,
+                    ...capped,
+                    ...(ref.coverage ? { coverage: ref.coverage } : {}),
+                    ...(ref.gapWarning ? { gapWarning: ref.gapWarning } : {}),
+                };
                 if (ref.matches.length > 0 || kind !== undefined) {
                     const imp = impactGraph(one, query);
                     impact[one] = {
@@ -124,6 +132,7 @@ export async function executeGraphTool(name, rawArgs) {
                         rules: cap(imp.rules),
                         datarules: cap(imp.datarules),
                         listviews: cap(imp.listviews),
+                        ...(imp.coverage ? { coverage: imp.coverage } : {}),
                     };
                 }
             }
@@ -135,9 +144,11 @@ export async function executeGraphTool(name, rawArgs) {
                 index,
                 references,
                 impact,
-                search: { count: search.rules.length, rules: search.rules },
+                search: { count: search.rules.length, rules: search.rules, matches: search.matches, coverage: search.coverage },
                 ...(search.note ? { searchNote: search.note } : {}),
-                note: "索引不含规则条件叶子与流程绑定；改这些面仍需平台侧核查",
+                // 旧句「索引不含规则条件叶子与流程绑定」漏了表单与流程权限（r35a-F4 实证
+                // 探针据此差点误删被表单引用的字段）。改为指向结构化 coverage，不再靠散文。
+                note: "零命中只代表 references[].coverage.scanned 面没有命中；notScanned 面（尤其 form 与 workflow.permissions）未扫描，不可据此判定可安全删除或无影响",
             });
         }
         return toolError(`未知工具：${name}`);

package/dist/read-shapes.js

@@ -94,7 +94,10 @@ const READ_SHAPES = {
     },
     "workitem.list": {
         // Flat rows — no fields bag. Wire id is projected as workItemId.
-        keys: ["items:array<{workItemId,activityCode,...}>", "total", "count"],
+        // r34c-F4（真机 2026-11-06）：此前 `{workItemId,activityCode,...}` 的省略号让
+        // 探针必须实调一次才敢确定标题键叫 activityName（--full 也一样省略）。
+        // 展开真实键集（真机 item 实测）；外置信封的 ids/itemsPreview 由 F7 补。
+        keys: ["items:array<{workItemId,workflowInstanceId,workflowCode,activityCode,activityName,state,sequenceNo,originator,originatorName,participant,participantName,bizObjectId,schemaCode}>", "total", "count"],
         notes: ["待办 id 键是 workItemId，不是 id（平铺，不套 fields）"],
     },
     "rule.list": {

package/dist/read.js

@@ -121,7 +121,10 @@ function externalizedShapePlaceholders(result, dropped) {
     // 自相矛盾的标记会让调用方以为还得去 artifact 取。
     if (dropped.length === 0)
         return {};
-    const placeholders = { truncatedKeys: [...dropped], truncated: true };
+    // Keep the A1 empty/null placeholder shape, but explicitly distinguish it
+    // from a genuine empty payload. `omittedKeys` is the machine-readable face;
+    // `truncatedKeys` remains the legacy list of payload keys moved to artifact.
+    const placeholders = { truncatedKeys: [...dropped], omittedKeys: [...dropped], truncated: true };
     for (const key of dropped)
         placeholders[key] = Array.isArray(result[key]) ? [] : null;
     return placeholders;

package/dist/recipes/field.js

@@ -291,6 +291,44 @@ const formulaAggregationCrossModel = Object.freeze({
     requiresEnvironmentDerivedIds: true,
     prerequisiteData: { source: "field.list(published:true) ×2（来源模型 + 目标模型）", fields: ["source.model", "source.dataItemCode", "source.matchField", "target.matchField"] },
 });
+const formulaExpressionSameModel = Object.freeze({
+    id: "formula-expression-same-model",
+    title: "同模型基础公式字段：FORMULA + EXPRESSION（amount×2）",
+    aliases: ["同模型公式", "基础公式字段", "表达式字段", "公式字段", "amount*2"],
+    status: "offline-valid",
+    tool: "field.create",
+    args: {
+        environment,
+        schemaCode: model,
+        code: "total",
+        name: "合计",
+        propertyType: "FORMULA",
+        options: {
+            formulaConfig: JSON.stringify({
+                resultType: 2,
+                formulaType: "EXPRESSION",
+                expression: JSON.stringify({ formula: "{amount}*2" }),
+            }),
+            persistent: true,
+        },
+    },
+    preconditions: ["目标模型已存在；amount 是同一模型上已存在并已发布的数值字段；total 尚不存在"],
+    conditionalRequirements: [
+        "formulaConfig 是 JSON 字符串，内层 expression 仍是 JSON 字符串：CLI recipe 已代做两层序列化，直接把 args 传给 field.create，不要再手工转义。",
+        "这是同模型的基础 EXPRESSION；跨模型汇总请改用 formula-aggregation-cross-model。",
+    ],
+    priorToolReferences: [
+        { tool: "field.list", args: { environment, schemaCode: model, published: true }, purpose: "确认 amount 已发布并确认目标 code 未占用" },
+    ],
+    dryRun: { supported: true, command: `omc call field.create --env ${environment} --dry-run --args '<recipe.args>'`, notes: "dry-run 校验 FORMULA/EXPRESSION 序列化形状，不创建字段" },
+    expectedReadback: { readback: { fieldPresent: true, options: { formulaConfig: "<EXPRESSION: {amount}*2>" } }, next: ["field.publish", "form.draft", "form.publish"] },
+    refusalRecovery: [
+        { code: "duplicate-field", action: "字段已存在改用 field.update 或换 code" },
+        { code: "formula-expression-source-missing", action: "先创建并发布同模型的 amount 数值字段，再创建 total" },
+        ...commonRecovery,
+    ],
+    requiresEnvironmentDerivedIds: false,
+});
 /**
  * r29（2026-10-29 中冶终轮）+ 用户领域知识：外部数据（企查查/NC 等）在表单上
  * 「填表时即带出」的标准模式——两段式组合。此前三轮探针（r24/r28b/r29）都发明
@@ -346,6 +384,6 @@ const externalLookupModel = Object.freeze({
 });
 export const FIELD_METADATA = Object.freeze({
     "field.update": Object.freeze({ recipes: [fieldSerialNumber, formConditionalRequired, formAlwaysReadonly, formConditionalReadonly], relatedTools: ["field.list", "field.publish", "form.draft", "form.publish"] }),
-    "field.create": Object.freeze({ recipes: [numericTwoDecimals, dictionarySelection, dictionaryMultiSelection, childTable, businessModelDropdown, formulaAggregationCrossModel, externalLookupModel], relatedTools: ["dictionary.names", "dictionary.records", "discover_environment", "field.list", "field.publish", "form.draft", "configure_form", "form.publish"] }),
+    "field.create": Object.freeze({ recipes: [numericTwoDecimals, dictionarySelection, dictionaryMultiSelection, childTable, businessModelDropdown, formulaAggregationCrossModel, formulaExpressionSameModel, externalLookupModel], relatedTools: ["dictionary.names", "dictionary.records", "discover_environment", "field.list", "field.publish", "form.draft", "configure_form", "form.publish"] }),
 });
 //# sourceMappingURL=field.js.map

package/dist/rule-when.js

@@ -11,7 +11,8 @@
  * 编译目标只用**设计器验证过**的形状（前台生效约束，2026-10-16 用户裁决：后端
  * 接口大量不拦截，save/publish 通过≠门户生效）：
  * - 预置触发行 Create/Update（设计器原生行，非自定义）
- * - 单 UPDATE 节点：filterCondition（查找满足条件的主表数据）+ dataActions（赋值）
+ * - 单 UPDATE 节点：dataCondition（输入数据满足条件时执行）+
+ *   filterCondition（默认按当前输入行定位）+ dataActions（赋值）
  * - FIXED 字面量 / DYNAMIC 字段引用 / EXPRESSION 公式（含 DATEDIF 语法，均真机验证）
  * - 布局/路由交给 prepareRuleGraph 注入（points 画布兼容，Ticket 109）
  *
@@ -23,6 +24,16 @@ import { envelope, requestId, classifyResult, CLI_EXIT_CODES } from "./cli-contr
 import { writeEnvelope } from "./cli-output.js";
 import { argvValue } from "./args.js";
 const WHEN_OPS = { "=": "EQ", "==": "EQ", "!=": "NEQ", ">": "GT", "<": "LT", ">=": "GTEQ", "<=": "LTEQ", "~=": "CT", "!~": "NCT" };
+function parseWhen(raw) {
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)\s*(>=|<=|~=|!~|==|!=|=|>|<)\s*([\s\S]+)$/.exec(raw.trim());
+    if (!match)
+        throw new Error(`--when "${raw}" 解析失败：形如 字段=值 / 字段!=值 / 字段>=数字 / 字段~=文本（包含）`);
+    const [, field, op, rawValue] = match;
+    if (rawValue.startsWith("="))
+        throw new Error(`--when "${raw}" 疑似操作符手误（值以 = 开头）：检查是否多打了等号`);
+    const value = /^-?\d+(\.\d+)?$/.test(rawValue.trim()) ? Number(rawValue.trim()) : rawValue.trim();
+    return { field, op, value };
+}
 /** 编译 --when/--then DSL 为设计器验证形状的规则图（导出供测试断言）。 */
 export function composeRuleWhenGraph(options) {
     if (options.when.length === 0)
@@ -33,17 +44,14 @@ export function composeRuleWhenGraph(options) {
     for (const raw of options.when) {
         // 最长操作符优先：>= <= ~= !~ == != > <（操作符两侧允许空格——r34 探针
         // 实测 `dr_price > 1000` 因空格被拒，属于自然书写）
-        const match = /^([A-Za-z_][A-Za-z0-9_]*)\s*(>=|<=|~=|!~|==|!=|=|>|<)\s*([\s\S]+)$/.exec(raw.trim());
-        if (!match)
-            throw new Error(`--when "${raw}" 解析失败：形如 字段=值 / 字段!=值 / 字段>=数字 / 字段~=文本（包含）`);
-        const [, field, op, rawValue] = match;
-        if (rawValue.startsWith("="))
-            throw new Error(`--when "${raw}" 疑似操作符手误（值以 = 开头）：检查是否多打了等号`);
+        const { field, op, value } = parseWhen(raw);
         const opCode = WHEN_OPS[op];
         if (!opCode)
             throw new Error(`--when 操作符 "${op}" 不受支持`);
-        const value = /^-?\d+(\.\d+)?$/.test(rawValue.trim()) ? Number(rawValue.trim()) : rawValue.trim();
-        leaves.push({ targetSchemaDataItem: field, ruleConditionType: opCode, ruleValueType: "FIXED", value });
+        // DataCondition uses DataFilterCondition, not TableCondition:
+        // currentSchemaDataItem is the input field and the operator wire key is
+        // ruleDataConditionType (ruleConditionType is @JsonIgnore here).
+        leaves.push({ currentSchemaDataItem: field, ruleDataConditionType: opCode, ruleValueType: "FIXED", value });
     }
     const actions = [];
     for (const raw of options.then) {
@@ -70,7 +78,11 @@ export function composeRuleWhenGraph(options) {
             nodes: [
                 { nodeCode: "Start", nodeType: "START" },
                 { nodeCode: "UpdateData1", nodeType: "UPDATE", targetObjectCode: options.schema, inputParam: "_input",
-                    filterCondition: { mainConditions: [leaves], sheetConditions: [] },
+                    // UPDATE.filterCondition selects rows; it is not an execution gate.
+                    // Keep the trigger row as the default target and put --when on the
+                    // platform's real execution-gate field (dataCondition).
+                    dataCondition: { conditionGroup: [leaves] },
+                    filterCondition: { mainConditions: [[{ targetSchemaDataItem: "id", ruleConditionType: "EQ", ruleValueType: "DYNAMIC", currentSchemaDataItem: "id" }]], sheetConditions: [] },
                     dataActions: actions },
                 { nodeCode: "End", nodeType: "END" },
             ],
@@ -130,9 +142,27 @@ export async function cmdRuleWhen(args) {
     catch (error) {
         return invalid(error instanceof Error ? error.message : String(error));
     }
-    const { result, exitCode } = await runToolCall("rule.save", { args: createArgs, requestId: request, environment });
+    const rowScope = {
+        mode: "current-row",
+        matchedRows: null,
+        sampleIds: [],
+        note: "当前行由运行时 _input.id 确定；保存面没有具体行 id，无法预先 count，按 fail-open 继续保存",
+    };
+    // print: () => undefined —— stdout 必须恰好一个 JSON 信封（repo 契约）。默认 print 是
+    // console.log，会把工具进度行打到信封前面：任何按行解析 stdout 的管道（agent、
+    // 重放脚本）第一行就 json.loads 失败（0.6.17 重放 R8 真机撞上）。approval-flow
+    // 等 composer 都覆写了，这里漏了；compute.ts 同病同修。
+    const { result, exitCode } = await runToolCall("rule.save", { args: createArgs, requestId: request, environment, print: () => undefined });
+    // `rule.save` owns the wire write; enrich this high-level command's receipt
+    // with the impact face it can prove from the compiled graph. The generated
+    // id=id locator is current-row scope, so no count query is needed and the
+    // answer is fail-open rather than inventing a table-wide count.
+    const scopedResult = {
+        ...result,
+        rowScope,
+    };
     const classified = classifyResult(result);
-    writeEnvelope(envelope(classified.status, result, request, classified.error));
+    writeEnvelope(envelope(classified.status, scopedResult, request, classified.error));
     if (apply && classified.status === "ok")
         process.stderr.write("[omc] 前台生效验证清单（后端通过≠门户生效）：1) omc call rule.enable 启用；2) 造一条命中 --when 的测试数据提交；3) 门户打开该记录核对 --then 字段已变更；4) 再造一条不命中的数据确认不误改；5) 设计器打开本规则确认节点/条件显示正常。\n");
     return exitCode;

package/dist/skills.js

@@ -102,6 +102,19 @@ const SYNTHETIC_SKILLS = Object.freeze({
             "",
         ].join("\n"),
     },
+    "batch-write": {
+        name: "batch-write",
+        description: "批量运行数据写入、形状预检与逐条失败定位",
+        content: [
+            "# 批量写",
+            "",
+            "通用批量入口是 `omc call <tool> --args-list '<json数组>'`，逐条执行且默认不中断。",
+            "先做零写入形状校验：`omc call data.save --args-list '<json数组>' --preflight`；回执 `shapeOnly:true`，只校验 JSON 形状与 schema 必填键，不做业务语义校验；业务校验要真写一次才知道。大数组请用 shell 变量传入（`--args-list` 暂不读取文件或 stdin）。",
+            "支持 `data.save`、`data.delete`、`field.create` 等同一工具逐条批量调用；没有专用 `data.import`，导入数据就是逐条 `data.save`。",
+            "失败项回 `row`（1 基）、`index`（0 基）和尽力推断的字段/原因；成功项回输入中的 `code` 等业务标识。",
+            "",
+        ].join("\n"),
+    },
 });
 /** Every methodology topic exposed by `omc help`. */
 export function listSkills() {

package/dist/tool-types.js

@@ -171,6 +171,22 @@ function contextualClosestKey(toolName, key, schemaKeys) {
         return "bizObjectIds";
     return undefined;
 }
+/**
+ * r35a-F8（真机 2026-11-06）：`field.update` 传 `propertyType` 时，编辑距离
+ * 建议到 `propertyEmpty`（风马牛不相及）——探针要「改字段类型」却拿不到任何
+ * 可行动信息。字段 type/code 在平台设计态不可原地修改，只能删重建（且会波及
+ * 引用），所以这里给的是**替代路径**而不是一个错误参数名。
+ */
+const CONTEXTUAL_KEY_GUIDANCE = Object.freeze({
+    "field.update": Object.freeze({
+        propertyType: "平台不支持原地改字段类型：需 field.delete（先看其 impact）→ field.create；同名 code 的改 type 会丢该列存量值",
+        type: "同上：改类型需 field.delete → field.create；改名（显示名）用 name，改 code 无工具（等同删+建）",
+        code: "字段 code 不可改：只能 field.delete → field.create（引用面会断，先看 field.delete 的 impact）",
+    }),
+    "field.create": Object.freeze({
+        precision: "precision→options.scale（数值小数位，不是顶层 precision）",
+    }),
+});
 function closestSchemaKey(key, schemaKeys) {
     if (schemaKeys.has(key))
         return key;
@@ -218,6 +234,8 @@ export function parseToolInput(tool, input) {
         const unknown = Object.keys(normalized).filter((key) => !schemaKeys.has(key));
         if (unknown.length > 0) {
             const suggestions = unknown.map((key) => `${key}→${KEY_SEMANTIC_HINTS[key] ?? contextualClosestKey(tool.name, key, schemaKeys) ?? closestSchemaKey(key, schemaKeys) ?? "（无相近键，omc describe <tool> 看参数表）"}`);
+            // r35a-F8：有替代路径指引时单独列（不是「最接近的合法键」，而是「该走哪条路」）。
+            const guidanceLines = unknown.map((key) => CONTEXTUAL_KEY_GUIDANCE[tool.name]?.[key]).filter((hint) => typeof hint === "string" && hint.length > 0);
             // r25 实证：`publish→（无相近键）` 等于没说——配置与发布是两步，用户要的是
             // 另一个工具。有语义指引时优先给可执行的下一步。
             const twoStep = unknown
@@ -228,7 +246,7 @@ export function parseToolInput(tool, input) {
             // 漏掉发布指引（报告原文：「若用程序消费回执，会选 issues[]，就会漏掉」）。
             // 两条通道必须同源，否则等于修了一半。
             const issueHintFor = (key) => {
-                const guidance = TWO_STEP_GUIDANCE[tool.name]?.[key];
+                const guidance = TWO_STEP_GUIDANCE[tool.name]?.[key] ?? CONTEXTUAL_KEY_GUIDANCE[tool.name]?.[key];
                 if (guidance !== undefined)
                     return guidance;
                 const semantic = KEY_SEMANTIC_HINTS[key];
@@ -247,8 +265,8 @@ export function parseToolInput(tool, input) {
                 status: "error",
                 blocker: "tool-input-unknown-keys",
                 tool: tool.name,
-                message: `写面工具不接受未知键（会被静默丢弃）：${unknown.join("、")}。${twoStep.length > 0 ? twoStep.join(" ") : `最接近的合法键：${suggestions.join("；")}。参数表：${paramCommand}`}`,
-                ...(twoStep.length > 0 ? { nextCommand: `omc describe ${tool.name}` } : { nextCommand: paramCommand }),
+                message: `写面工具不接受未知键（会被静默丢弃）：${unknown.join("、")}。${twoStep.length > 0 ? twoStep.join(" ") : `${guidanceLines.length > 0 ? guidanceLines.join("；") : `最接近的合法键：${suggestions.join("；")}`}。参数表：${paramCommand}`}`,
+                ...(twoStep.length > 0 || guidanceLines.length > 0 ? { nextCommand: `omc describe ${tool.name}` } : { nextCommand: paramCommand }),
                 issues: unknown.map((key) => ({ path: [key], code: "unrecognized_key", message: issueHintFor(key) })),
             });
         }

package/dist/workflow-support.js

@@ -173,13 +173,14 @@ export function diagnoseInstanceActivity(input) {
     const originator = input.originator ?? null;
     const fallbackSuspect = originator !== null &&
         active.some((activity) => activity.participantCount > 0 && activity.participants.every((person) => person.id === originator));
+    const unresolved = active.filter((activity) => activity.activityType === "PARTICIPANT" && activity.participantCount === 0).map((activity) => activity.activityCode ?? "?");
     return {
         code: "has-active-activity",
         message: `当前激活节点：${active.map((activity) => `${activity.activityCode}(${activity.activityName ?? ""})`).join("、")}`,
         checks: fallbackSuspect
             ? ["若这些节点本应流转给角色或他人，现在却落在发起人身上：参与人解析为空时平台会退回发起人（1.1.25 实测），流程看似推进实为错派。核对参与人写法（参与者对象数组 / FindUserByRole(org, roleCode[, order])）与角色成员。"]
             : [],
-        warnings: fallbackSuspect ? ["participant-fallback-to-originator"] : [],
+        warnings: [...(fallbackSuspect ? ["participant-fallback-to-originator"] : []), ...unresolved.map((activityCode) => `participant-unresolved:${activityCode}`)],
     };
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stalfh233/omc-cli",
-  "version": "0.6.15",
+  "version": "0.6.17",
   "description": "CloudPivot 8.6 configuration capability CLI — governed, fail-closed, coverage-manifest bounded.",
   "type": "module",
   "bin": {
@@ -55,7 +55,7 @@
   },
   "dependencies": {
     "commander": "14.0.3",
-    "omc-core": "0.6.15",
+    "omc-core": "0.6.17",
     "proper-lockfile": "4.1.2",
     "write-file-atomic": "6.0.0",
     "zod": "^3.23.8",
@@ -73,6 +73,6 @@
     "directory": "packages/omc-cli"
   },
   "optionalDependencies": {
-    "@stalfh233/omc-fake-platform": "0.6.15"
+    "@stalfh233/omc-fake-platform": "0.6.17"
   }
 }