@stalfh233/omc-cli 0.6.16 → 0.6.18

package/dist/mcp-graph.js

@@ -58,24 +58,27 @@ const EXPLORE_TOOL = {
     name: "omc_graph_explore",
     description: [
         "一次查全一个目标的引用与影响面（本地索引，毫秒级）。",
-        "输入 query=字段/模型/服务的 code（或规则检索词）；kind 可选 field|model|service，不给则三种都查。",
-        "返回 {index(freshness), references:{kind:[{schemaCode,ruleCode,nodeCode,nodeType,via}]}, impact:{kind:totals}, search:{rules}}。",
+        "输入 query 可为业务名（实体 name+code 子串）或规则 code+name 词首；也可直接给字段/模型/服务 code。kind 可选 field|model|service，不给则三种都查。",
+        "返回 {index(freshness), references:{kind:[{schemaCode,ruleCode,nodeCode,nodeType,via}]}, impact:{kind:totals}, search:{matches:{model,field,service},rules}}。",
+        "references/impact 支持 offset+limit 分页；truncated 时按返回的 nextOffset 继续调用。",
         "改/删/重命名任何字段、模型、服务之前必查；找\"关于 X 的规则\"拿 code 也走这里。",
         "索引不含规则条件叶子与流程绑定；freshness=partial 时命中可能不完整（答案里有 gapWarning）。",
     ].join(" "),
     inputSchema: {
         type: "object",
         properties: {
-            query: { type: "string", description: "字段/模型/服务的 code，或规则检索词（code+name 词首匹配）" },
+            query: { type: "string", description: "业务名（实体 name+code 子串）、字段/模型/服务 code，或规则检索词（规则 code+name 词首匹配）" },
             kind: { type: "string", enum: [...KINDS], description: "限定一种引用种类；省略则 field/model/service 全查" },
             env: { type: "string", description: "期望的环境名；与索引所属环境不一致时会拒绝（防跨环境误答）" },
+            offset: { type: "integer", minimum: 0, description: "引用/实体结果起始偏移；truncated 时使用 nextOffset" },
+            limit: { type: "integer", minimum: 1, maximum: MATCH_CAP, description: "每类结果最多返回多少条（默认 50）" },
         },
         required: ["query"],
     },
 };
 const STATUS_TOOL = {
     name: "omc_graph_status",
-    description: "索引完整性与新鲜度：environmentName、freshness(complete|partial)、模型/规则计数、pulledAtIso、gaps。回答前先看一眼，索引缺失会给出 pull 指引。",
+    description: "索引完整性与新鲜度：environmentName、freshness(complete|partial)、模型/规则计数、pulledAtIso、ageMinutes、staleAfterMinutes、dbPath、coverage.applicationCodes、gaps。超过阈值会给 warning；回答前先看一眼，索引缺失会给出 pull 指引。",
     inputSchema: { type: "object", properties: {} },
 };
 export function graphToolDefinitions() {
@@ -87,8 +90,9 @@ function toolResult(payload, isError = false) {
 function toolError(message) {
     return toolResult({ status: "error", message }, true);
 }
-function cap(rows) {
-    return { rows: rows.slice(0, MATCH_CAP), truncated: rows.length > MATCH_CAP };
+function cap(rows, offset = 0, limit = MATCH_CAP) {
+    const page = rows.slice(offset, offset + limit);
+    return { rows: page, truncated: offset + page.length < rows.length, offset, limit, ...(offset + page.length < rows.length ? { nextOffset: offset + page.length } : {}), total: rows.length };
 }
 /** Shared handler core — exported so tests drive it without a stdio pair. */
 export async function executeGraphTool(name, rawArgs) {
@@ -111,33 +115,59 @@ export async function executeGraphTool(name, rawArgs) {
                 return toolError(`索引属于环境「${index.environmentName}」；要查「${args.env.trim()}」请先 omc graph pull --env ${args.env.trim()} 重建索引`);
             }
             const kinds = kind === undefined ? [...KINDS] : [kind];
+            const offset = typeof args.offset === "number" && Number.isSafeInteger(args.offset) && args.offset >= 0 ? args.offset : 0;
+            const limit = typeof args.limit === "number" && Number.isSafeInteger(args.limit) && args.limit > 0 && args.limit <= MATCH_CAP ? args.limit : MATCH_CAP;
             const references = {};
             const impact = {};
             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 } : {}) };
+                const capped = cap(ref.matches, offset, limit);
+                // r35a-F4c（真机 2026-11-06）：**MCP 面是第三个消费者**——CLI 的 references
+                // 与 impact 都带 coverage 了，这里若不显式透传，MCP 用户看到的仍是
+                // 「matches:[] + 一句旧 note」，照样会把「表单没扫」误读成「没人引用」。
+                references[one] = {
+                    count: ref.matches.length,
+                    rows: capped.rows,
+                    offset: capped.offset,
+                    limit: capped.limit,
+                    ...(capped.truncated ? { truncated: true, nextOffset: capped.nextOffset, note: `共 ${capped.total} 条，已给 ${capped.rows.length} 条，offset=${capped.offset} 取下一段（调用时传 offset=${capped.nextOffset}、limit=${capped.limit}）` } : {}),
+                    ...(ref.coverage ? { coverage: ref.coverage } : {}),
+                    ...(ref.gapWarning ? { gapWarning: ref.gapWarning } : {}),
+                };
                 if (ref.matches.length > 0 || kind !== undefined) {
                     const imp = impactGraph(one, query);
                     impact[one] = {
                         totals: imp.totals,
-                        rules: cap(imp.rules),
-                        datarules: cap(imp.datarules),
-                        listviews: cap(imp.listviews),
+                        rules: cap(imp.rules, offset, limit),
+                        datarules: cap(imp.datarules, offset, limit),
+                        listviews: cap(imp.listviews, offset, limit),
+                        ...(imp.coverage ? { coverage: imp.coverage } : {}),
                     };
                 }
             }
-            const search = searchGraphRules(query);
+            const search = searchGraphRules(query, limit, offset);
+            const resolvedEntity = search.matches.model.items[0] ? { kind: "model", schemaCode: search.matches.model.items[0].schemaCode, code: search.matches.model.items[0].schemaCode } :
+                search.matches.field.items[0] ? { kind: "field", schemaCode: search.matches.field.items[0].schemaCode, code: search.matches.field.items[0].code } :
+                    search.matches.service.items[0] ? { kind: "service", schemaCode: "", code: search.matches.service.items[0].code } :
+                        search.rules[0] ? { kind: "rule", schemaCode: search.rules[0].schemaCode, code: search.rules[0].ruleCode } : undefined;
+            const searchNote = "实体检索：业务名/实体 name+code 使用子串匹配。\n规则检索：规则 code+name 使用词首匹配（中文子串不命中）。";
+            const entityTruncated = Object.values(search.matches).some((match) => match.truncated === true);
+            const paginationNote = entityTruncated ? `\n结果已截断：共 N 条时请使用对应 match 的 nextOffset，并在下一次调用传 offset=nextOffset、limit=${limit} 取下一段。` : "";
             return toolResult({
                 status: "ok",
                 query,
+                found: resolvedEntity !== undefined,
+                ...(resolvedEntity ? { resolved: resolvedEntity } : {}),
                 ...(kind !== undefined ? { kind } : {}),
                 index,
                 references,
                 impact,
-                search: { count: search.rules.length, rules: search.rules },
-                ...(search.note ? { searchNote: search.note } : {}),
-                note: "索引不含规则条件叶子与流程绑定；改这些面仍需平台侧核查",
+                search: { count: search.rules.length, rules: search.rules, matches: search.matches, coverage: search.coverage },
+                searchNote: `${searchNote}${paginationNote}`,
+                ...(search.note ? { searchNote: `${searchNote}\n${search.note}` } : {}),
+                // 旧句「索引不含规则条件叶子与流程绑定」漏了表单与流程权限（r35a-F4 实证
+                // 探针据此差点误删被表单引用的字段）。改为指向结构化 coverage，不再靠散文。
+                note: `零命中只代表 references[].coverage.scanned 面没有命中；本索引覆盖应用：${index.coverage.applicationCodes.join("、") || "（未知）"}，不代表其他应用没有结果；notScanned 面（尤其 form 与 workflow.permissions）未扫描，不可据此判定可安全删除或无影响`,
             });
         }
         return toolError(`未知工具：${name}`);

package/dist/programming-workflow.js

@@ -17,6 +17,7 @@ import { wireCall, WireError, wireRows } from "./wire.js";
  * endpoint — see .scratch/backend-online-coding/recon.md §8).
  *
  * Commands:
+ *   ⚠ test  会 publish 并切编码模式（不可逆）
  *   pull    remote → tree + manifest (environment-stamped)
  *   status  local edits vs manifest, plus optional remote drift (--deep)
  *   apply   changed files → programming.save (→ --publish)
@@ -801,18 +802,30 @@ export async function cmdProgrammingTest(options) {
         const targetSchema = String(dataSpec.schema ?? schemaCode);
         const filter = (dataSpec.filter ?? {});
         const expect = (dataSpec.expect ?? {});
+        // data.list is only a locator here. Its projection is intentionally not
+        // used as evidence: omitted columns are returned as null and used to turn
+        // a correct rule into a false failure (F11).
         const listed = await callTool("data.list", {
             environment: session.environmentName,
             schemaCode: targetSchema,
             ...filterOf(filter),
-            displayFields: Object.keys(expect),
+            displayFields: ["bizObjectId", "id"],
         }, context);
         const rows = (listed.rows ?? listed.items ?? []);
-        const matched = rows.filter((row) => matchExpectation(row, expect).ok);
+        const loadedRows = [];
+        for (const row of rows) {
+            const id = String(row.bizObjectId ?? row.id ?? "");
+            if (!id)
+                continue;
+            const loaded = await callTool("data.load", { environment: session.environmentName, schemaCode: targetSchema, bizObjectId: id, full: true }, context);
+            if (loaded.exists === true && loaded.data && typeof loaded.data === "object")
+                loadedRows.push(loaded.data);
+        }
+        const matched = loadedRows.filter((row) => matchExpectation(row, expect).ok);
         const ok = matched.length > 0;
         if (!ok)
             assertsFailed += 1;
-        assertReports.push({ schema: targetSchema, filter, expect, rows: rows.length, ok, ...(ok ? {} : { sample: rows.slice(0, 3) }) });
+        assertReports.push({ schema: targetSchema, filter, expect, rows: loadedRows.length, ok, ...(ok ? {} : { sample: loadedRows.slice(0, 3) }) });
     }
     report.asserts = assertReports;
     // 5. Cleanup — only rows the fixture names (seed filter), never a blanket key.

package/dist/read-shapes.js

@@ -71,7 +71,7 @@ const READ_SHAPES = {
         keys: ["bizObjectId", "exists", "data:{...}"],
     },
     "app.list": {
-        keys: ["applications:array<{code,name,groupId?}>", "applicationsCount", "omitted"],
+        keys: ["applications:array<{code,name,groupId?,modelCount}>", "applicationsCount", "omitted"],
         notes: ["applicationsCount + omitted 与 discover 同构；omitted:false 表示内联即全集"],
     },
     "model.list": {
@@ -85,8 +85,8 @@ const READ_SHAPES = {
     },
     "model.inspect": {
         // Slim/compact face (window diet): field inventory is `fieldCodes`, not fields[].
-        keys: ["schemaCode", "fieldCodes", "form", "listview", "ruleCodes", "datarules", "workflow", "hint"],
-        notes: ["slim 面键是 fieldCodes（不是 fields[].code）"],
+        keys: ["schemaCode", "applicationCode", "fieldCodes", "form", "listview", "ruleCodes", "datarules", "workflow", "hint"],
+        notes: ["slim 面键是 fieldCodes（不是 fields[].code）；all:true 时 fields/artifact 行含 options"],
     },
     "field.list": {
         keys: ["fields:array<{code,name,type,...}>", "modelPresent?"],

package/dist/rollback.js

@@ -8,6 +8,7 @@ import { readJournal, resolveJournalEntry, laterWritesOnTarget } from "./journal
 import { canonicalForVerify, deepDiff, pruneNullish } from "./rollback-spec.js";
 import { sha256 } from "./support.js";
 import { emitTransportResult } from "./command-transport.js";
+import { acquireWriteLock } from "./write-lock.js";
 /** Pure runtime assembly: an injected context (tests) or the default one. */
 function runtime(context) {
     return context ?? makeToolContext({ sessions: new SessionManager(new ConfigStore(defaultPaths())) });
@@ -191,25 +192,53 @@ export async function applyRollback(ref, options, context) {
         };
     }
     const results = [];
-    for (const [index, call] of plan.inverse.calls.entries()) {
-        const { exitCode, result } = await runToolCall(call.tool, {
-            args: { ...call.args, environment: entry.environment, ...(options.confirmProduction ? { confirmProduction: true } : {}) },
-            requestId: `omc-rollback-${entry.seq}-${index + 1}`,
-            context: ctx,
-            print: () => undefined,
-        });
-        results.push({
-            tool: call.tool,
-            exitCode,
-            status: result.status,
-            ...(result.deliveryState ? { deliveryState: result.deliveryState } : {}),
-            ...(result.summary ? { summary: result.summary } : {}),
-            // r55: exit-code-only results hid the reason a restore call failed
-            // (input-invalid showed as a bare "status=error"). Surface the shape.
-            ...(exitCode === 0 ? {} : { blocker: result.blocker ?? null, message: result.message ?? null, ...(result.issues !== undefined ? { issues: result.issues } : {}), ...(result.diagnostic !== undefined ? { diagnostic: result.diagnostic } : {}) }),
-        });
-        if (exitCode !== 0)
-            return { status: "stopped", rollbackOf: { seq: entry.seq, tool: entry.tool }, step: index + 1, results, message: `恢复调用 ${call.tool} 未成功（status=${result.status}）；已执行的调用已各自记 journal，可对已完成步骤再 plan` };
+    // The inverse plan is intentionally kept as the seam for future inverse
+    // extensions (for example onlinejs.compose remove:true): all new restore
+    // shapes still become governed calls here, without changing the evidence
+    // or lock protocol.
+    const waitMs = options.waitMs ?? 0;
+    const deadline = Date.now() + waitMs;
+    let lock;
+    for (;;) {
+        lock = await acquireWriteLock(entry.environment);
+        if (lock.held)
+            break;
+        if (Date.now() >= deadline) {
+            return {
+                status: "refused",
+                blocker: "write-lock-held",
+                rollbackOf: { seq: entry.seq, tool: entry.tool },
+                waitMs,
+                lockOwner: lock.owner ?? null,
+                message: `回滚写锁被占用；已等待 ${waitMs}ms。可用 --wait <ms> 有界排队后重试`,
+            };
+        }
+        await new Promise((resolve) => setTimeout(resolve, Math.min(200, Math.max(0, deadline - Date.now()))));
+    }
+    try {
+        for (const [index, call] of plan.inverse.calls.entries()) {
+            const { exitCode, result } = await runToolCall(call.tool, {
+                args: { ...call.args, environment: entry.environment, ...(options.confirmProduction ? { confirmProduction: true } : {}) },
+                requestId: `omc-rollback-${entry.seq}-${index + 1}`,
+                context: ctx,
+                print: () => undefined,
+            });
+            results.push({
+                tool: call.tool,
+                exitCode,
+                status: result.status,
+                ...(result.deliveryState ? { deliveryState: result.deliveryState } : {}),
+                ...(result.summary ? { summary: result.summary } : {}),
+                // r55: exit-code-only results hid the reason a restore call failed
+                // (input-invalid showed as a bare "status=error"). Surface the shape.
+                ...(exitCode === 0 ? {} : { blocker: result.blocker ?? null, message: result.message ?? null, ...(result.issues !== undefined ? { issues: result.issues } : {}), ...(result.diagnostic !== undefined ? { diagnostic: result.diagnostic } : {}) }),
+            });
+            if (exitCode !== 0)
+                return { status: "stopped", rollbackOf: { seq: entry.seq, tool: entry.tool }, step: index + 1, results, message: `恢复调用 ${call.tool} 未成功（status=${result.status}）；已执行的调用已各自记 journal，可对已完成步骤再 plan` };
+        }
+    }
+    finally {
+        await lock.release();
     }
     // Authoritative verify: re-read the target and compare against the
     // canonicalized before. "restored" tolerates the write pipeline
@@ -232,6 +261,12 @@ export async function applyRollback(ref, options, context) {
         rollbackOf: { seq: entry.seq, tool: entry.tool, target: entry.target },
         calls: results,
         verify,
+        // Stable evidence is present on both the restored and mismatch paths.
+        // `recoveredTo` deliberately identifies the original journal target; the
+        // replay writes are separately journaled and can be rolled back again.
+        restoredSha256: restoredSha,
+        matchesBefore: verify === "restored",
+        recoveredTo: { seq: entry.seq, ts: entry.ts },
         ...(verify === "mismatch" ? { beforeSha, restoredSha, message: "恢复调用已完成但读回与 before 存在值冲突（非默认显式化）：立即人工核对目标现态（omc rollback plan <seq> 的 diff 可复看差异）" } : {}),
         hint: "本次恢复的每次调用都走了完整写闸门并已记 journal；恢复本身可再回滚（rollback plan <新 seq>）",
     };

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

@@ -109,7 +109,7 @@ const SYNTHETIC_SKILLS = Object.freeze({
             "# 批量写",
             "",
             "通用批量入口是 `omc call <tool> --args-list '<json数组>'`，逐条执行且默认不中断。",
-            "先做零写入形状校验：`omc call data.save --args-list '<file|stdin>' --preflight`；回执 `shapeOnly:true`，只校验 JSON 形状与 schema 必填键，不做业务语义校验；业务校验要真写一次才知道。",
+            "先做零写入形状校验：`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` 等业务标识。",
             "",

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/dist/write.js

@@ -143,7 +143,7 @@ async function governedWrite(ctx, tool, args, execute, dryRunPayload, readOnlyEs
             const artifactRef = writeArtifact(ctx, `${tool.name}-${randomUUID().slice(0, 8)}.json`, artifact);
             return { status: executed.status, steps: executed.steps, failedStep: executed.failedStep, ...executed.envelope, ...(args.requestId ? { requestId: args.requestId } : {}), artifactFingerprint: artifactRef.detailSha256 };
         }
-        const { performed, readback, steps, halfSuccess, irreversible } = executed;
+        const { performed, readback, steps, halfSuccess, irreversible, rollbackReceipt, runtimeVerification } = executed;
         // Readback gate (live 2026-10-17): a tool that reports `readback.present:false`
         // has NOT proven its own write — the platform accepted the request but the
         // object is absent from the authoritative face. "Called without error" must
@@ -204,17 +204,21 @@ async function governedWrite(ctx, tool, args, execute, dryRunPayload, readOnlyEs
         return {
             status: "ok",
             deliveryState,
+            ...((typeof performed.applicationCode === "string" ? { applicationCode: performed.applicationCode } : typeof readback.applicationCode === "string" ? { applicationCode: readback.applicationCode } : {})),
             ...(readOnlyEscapeNote !== undefined ? { readOnlyEscape: readOnlyEscapeNote } : {}),
             performed,
             readback,
             ...(readbackWarning ? { readbackWarning } : {}),
             ...(steps !== undefined ? { steps } : {}),
             ...(halfSuccess !== undefined ? { halfSuccess } : {}),
+            ...(runtimeVerification !== undefined ? { runtimeVerification } : {}),
             ...(typeof irreversible === "string" ? { irreversible } : {}),
             // r30a F1: first write → replay:"none"; duplicate only on true replay.
             ...(args.requestId ? { requestId: args.requestId, idempotency: idempotencyDeclaration(tool.name, "none") } : {}),
             ...(productionConfirmed ? { productionConfirmed: true } : {}),
-            ...(rollbackRef ? { rollback: rollbackRef } : {}),
+            ...(rollbackRef
+                ? { rollback: { ...(rollbackReceipt ?? {}), seq: rollbackRef.seq, ...(rollbackReceipt ? {} : { hint: rollbackRef.hint }) } }
+                : {}),
             summary: writeSummary(tool.name, args, { performed, readback }, "done"),
             detailFile: artifactRef.detailFile,
             detailSha256: artifactRef.detailSha256,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stalfh233/omc-cli",
-  "version": "0.6.16",
+  "version": "0.6.18",
   "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.16",
+    "omc-core": "0.6.18",
     "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.16"
+    "@stalfh233/omc-fake-platform": "0.6.18"
   }
 }