@stalfh233/omc-cli 0.6.12 → 0.6.14

package/coverage/m1-coverage-manifest-v1.json

@@ -48,6 +48,7 @@
         "dictionary.save",
         "dictionary.status",
         "dictionary.usage",
+        "dictionary.references",
         "dictionary.classes",
         "dictionary.class.save",
         "dictionary.class.delete"
@@ -62,6 +63,7 @@
         "dictionary save",
         "dictionary status",
         "dictionary record usage",
+        "dictionary refs",
         "dictionary classes",
         "dictionary class save",
         "dictionary class delete"

package/dist/approval-flow.js

@@ -20,15 +20,64 @@ import { runToolCall } from "./call.js";
 import { envelope, requestId, classifyResult, CLI_EXIT_CODES } from "./cli-contract.js";
 import { writeEnvelope } from "./cli-output.js";
 import { argvValue } from "./args.js";
+/**
+ * r31c F20: participant object arrays only accept `{code,corpId,id,name,type}`.
+ * Intuitive keys (`participantType`/`roleId`/`participantName`) are silently
+ * dropped by the platform → readback `[{}]`, validate still valid, publish only
+ * warns. Refuse here so the composer never emits a broken shape.
+ */
+export function assertParticipantShape(participant, at) {
+    if (participant === undefined || participant === null)
+        return;
+    if (typeof participant === "string") {
+        const trimmed = participant.trim();
+        if (trimmed === "{Originator}")
+            return;
+        if (/^FindUserByRole\s*\(/.test(trimmed))
+            return;
+        if (trimmed.startsWith("[")) {
+            let parsed;
+            try {
+                parsed = JSON.parse(trimmed);
+            }
+            catch {
+                throw new Error(`${at}: participant JSON 解析失败；对象数组形如 [{"code":"<角色code>","corpId":"other","id":"<roleId>","name":"<名>","type":2}]`);
+            }
+            assertParticipantShape(parsed, at);
+            return;
+        }
+        throw new Error(`${at}: participant 自由文本「${trimmed}」不可解析（不生成待办）。用 {Originator} / FindUserByRole(...) / 对象数组 {code,corpId,id,name,type}`);
+    }
+    if (!Array.isArray(participant)) {
+        throw new Error(`${at}: participant 必须是字符串或对象数组`);
+    }
+    for (const [index, entry] of participant.entries()) {
+        if (entry === null || typeof entry !== "object" || Array.isArray(entry)) {
+            throw new Error(`${at}[${index}]: 参与者条目必须是对象`);
+        }
+        const record = entry;
+        const badKeys = ["participantType", "roleId", "participantName", "userId"].filter((key) => key in record);
+        if (badKeys.length > 0) {
+            throw new Error(`${at}[${index}]: 不认 ${badKeys.join("/")}——平台会静默丢掉，读回变成 [{}]。正确键：code/corpId/id/name/type（type 2=角色 3=用户）`);
+        }
+        if (record.code === undefined || record.type === undefined) {
+            throw new Error(`${at}[${index}]: 参与者对象缺 code/type（必填）。正确形状：{"code":"<角色或用户code>","corpId":"other","id":"<id>","name":"<名>","type":2}`);
+        }
+    }
+}
 /** 解析步骤 DSL 为 {name, participant}（导出供测试）。 */
 export function parseStep(raw) {
     const match = /^(.+?)@(role|user):([A-Za-z0-9_.:-]+)$/.exec(raw.trim());
     if (!match)
         throw new Error(`--steps "${raw}" 解析失败：形如 名称@role:<角色code> 或 名称@user:<用户id>（自由文本角色名能发布但解析不到人、不生成待办）`);
     const [, name, kind, code] = match;
+    // Role steps stay on FindUserByRole (department-scoped). User steps emit the
+    // canonical object array — never participantType/roleId.
     if (kind === "role")
         return { name: name.trim(), participant: `FindUserByRole({Originator.OU},"${code}","random")` };
-    return { name: name.trim(), participant: JSON.stringify([{ code, corpId: "other", id: code, name: name.trim(), type: 3 }]) };
+    const participant = JSON.stringify([{ code, corpId: "other", id: code, name: name.trim(), type: 3 }]);
+    assertParticipantShape(participant, `--steps ${name}`);
+    return { name: name.trim(), participant };
 }
 /** 编译完整模板（recipe 验证形状）。 */
 export function composeApprovalTemplate(options) {
@@ -44,6 +93,7 @@ export function composeApprovalTemplate(options) {
     }
     for (const raw of options.steps) {
         const { name, participant } = parseStep(raw);
+        assertParticipantShape(participant, `steps[${name}]`);
         activities.push({
             activityCode: `Activity${n}`, activityType: "PARTICIPANT", activityName: name, i18nMessage: name,
             participant,
@@ -74,13 +124,26 @@ export async function cmdApprovalFlow(args) {
     const apply = args.includes("--apply");
     const originatorNode = !args.includes("--no-originator-node");
     const rejectToStart = !args.includes("--no-reject-to-start");
-    const usage = '用法：omc approval-flow --schema <模型> --steps "节点名@role:<角色code>" [--steps ...多级] [--no-originator-node] [--no-reject-to-start] [--apply]\n步骤也可用 名称@user:<用户id> 绑定具体审批人。默认 dry-run（编译模板预览）；--apply 建/改流程+字段权限+发布。';
+    // r31c F5：本拼装器只做线性审批。条件分支必须退回 workflow.update；行级数据
+    // 可见范围当前工具面不支持——别把「申请人只看自己」误当成 permissions。
+    const usage = [
+        '用法：omc approval-flow --schema <模型> --steps "节点名@role:<角色code>" [--steps ...多级] [--no-originator-node] [--no-reject-to-start] [--apply]',
+        "步骤也可用 名称@user:<用户id> 绑定具体审批人。默认 dry-run（编译模板预览）；--apply 建/改流程+字段权限+发布。",
+        "⚠️ 本工具只做线性流程（START→填写→N 级审批→END），没有 --condition。",
+        "条件分支请用：omc describe workflow.update --example workflow-conditional-branch",
+        '最小条件流示例：routes 上加 ruleConditionGroup:[[{currentDataItem:"amount",bizPropertyType:2,conditionType:"GT",value:"50000"}]]，兜底线加 utilizeElse:true。',
+        "⚠️ workflow.permissions / org.role.setUserScope 都不是行级数据权限；「申请人只能看自己的单据」当前工具面不支持。",
+    ].join("\n");
     const invalid = (message) => {
         writeEnvelope(envelope("error", {}, request, { code: "invalid-input", message: `${message}\n${usage}`, retryable: false }));
         return CLI_EXIT_CODES.invalidInput;
     };
     if (!schema)
         return invalid("--schema 必填");
+    // Explicit refuse of a flag we do not implement, so callers do not assume silent ignore.
+    if (args.includes("--condition") || args.includes("--branch") || args.some((arg) => arg.startsWith("--condition=") || arg.startsWith("--branch="))) {
+        return invalid("本工具不支持 --condition/--branch（只做线性审批）。条件分流请：omc describe workflow.update --example workflow-conditional-branch");
+    }
     let compiled;
     try {
         compiled = composeApprovalTemplate({ schema, steps, originatorNode, rejectToStart, environment, apply });
@@ -90,8 +153,26 @@ export async function cmdApprovalFlow(args) {
     }
     // F1（r27）：边界前置——成功回执就标出跨账号审批在单会话 CLI 内不可用。
     const crossAccountApproval = "unsupported: single-session CLI";
+    const linearOnlyNote = "本工具只做线性审批；条件分支用 omc describe workflow.update --example workflow-conditional-branch。" +
+        "workflow.permissions 只设谁能发起，不是行级可见范围（行级数据权限当前工具面不支持）。";
     if (!apply) {
-        writeEnvelope(envelope("ok", { schemaCode: schema, ...compiled, dryRun: true, crossAccountApproval, note: "dry-run 仅编译预览；--apply 执行 workflow.create(无流程时)→update(模板+字段权限)→publish。边界：非发起人身份的审批无法在单会话 CLI 内推进（单 token）；若要验跨账号审批，用第二账号另建环境，或把参与人设为 {Originator}" }, request));
+        writeEnvelope(envelope("ok", {
+            schemaCode: schema,
+            ...compiled,
+            dryRun: true,
+            crossAccountApproval,
+            linearOnly: true,
+            rowLevelDataPermission: "unsupported",
+            note: `dry-run 仅编译预览；--apply 执行 workflow.create(无流程时)→update(模板+字段权限)→publish。边界：非发起人身份的审批无法在单会话 CLI 内推进（单 token）；若要验跨账号审批，用第二账号另建环境，或把参与人设为 {Originator}。${linearOnlyNote}`,
+            conditionExample: {
+                tool: "workflow.update",
+                example: "workflow-conditional-branch",
+                routesSnippet: [
+                    { preNode: "A2", postNode: "A3", ruleConditionGroup: [[{ currentDataItem: "amount", bizPropertyType: 2, conditionType: "GT", value: "50000" }]] },
+                    { preNode: "A2", postNode: "A4", utilizeElse: true },
+                ],
+            },
+        }, request));
         return 0;
     }
     // 1) 确保流程存在（一个模型只能有一个：已存在则直接 update）

package/dist/batch-call.js

@@ -76,6 +76,29 @@ export async function runBatchCall(options) {
     }));
     const executed = entries.length;
     const skipped = options.argsList.length - executed;
+    // 2026-11-05（r30c F3/F10/F13）：全成功时旧回执只有 4 个计数，调用方拿不到
+    // **每条的 id**——想确认「这 5 条到底进没进库」必须再发一次 data.list，而批量
+    // 存在的理由正是省掉那一次往返。反过来把 8 份完整信封塞回来又会重建本命令要
+    // 消除的那堵墙。折中：**每条一行摘要**（几十字节），超过阈值才截断。
+    const ENTRIES_INLINE_LIMIT = 20;
+    const entriesSummary = entries.map((entry) => {
+        const readback = entry.result.readback;
+        const performed = entry.result.performed;
+        const bizObjectId = typeof performed?.bizObjectId === "string"
+            ? String(performed.bizObjectId)
+            : typeof readback?.authoritative?.id === "string"
+                ? String(readback.authoritative.id)
+                : undefined;
+        const skippedMarker = performed?.skipped;
+        return {
+            index: entry.index,
+            ok: entry.status === "ok",
+            ...(bizObjectId !== undefined ? { bizObjectId } : {}),
+            ...(entry.status === "ok" ? {} : { status: String(entry.result.status ?? "failed"), blocker: entry.result.blocker ?? null }),
+            ...(skippedMarker !== undefined ? { skipped: String(skippedMarker) } : {}),
+        };
+    });
+    const entriesInline = entriesSummary.slice(0, ENTRIES_INLINE_LIMIT);
     return {
         exitCode: failed > 0 ? 1 : 0,
         result: {
@@ -86,8 +109,15 @@ export async function runBatchCall(options) {
             succeeded,
             failed,
             ...(skipped > 0 ? { notExecuted: skipped } : {}),
-            // Only failures carry per-entry detail: echoing 8 full success envelopes
-            // would rebuild exactly the wall of text this command exists to remove.
+            // 每条一行摘要（index/ok/bizObjectId）——不是完整信封，但足以回答
+            // 「第 3 条建成了吗、它的 id 是什么」。失败项另有 failures 带完整原因。
+            entries: entriesInline,
+            ...(entries.length > entriesInline.length
+                ? { entriesOmitted: entries.length - entriesInline.length, entriesHint: `条目超过 ${ENTRIES_INLINE_LIMIT} 条，只内联前 ${ENTRIES_INLINE_LIMIT} 条摘要；完整结果走 detailArtifactId / omc artifact get` }
+                : {}),
+            // Only failures carry full per-entry detail: echoing 8 full success
+            // envelopes would rebuild exactly the wall of text this command exists
+            // to remove.
             ...(failures.length > 0 ? { failures } : {}),
             ...(skipped > 0 ? { notExecutedNote: "未执行的条目通常是因为解析阶段就失败（如缺少必填参数）；先修 failures 里的第一条" } : {}),
         },

package/dist/bench/call-face-eval.js

@@ -163,8 +163,8 @@ export const CALL_FACE_TASKS = [
             ok(replay.code === 0 && replay.envelope.result?.status === "ok" && replay.envelope.result?.replay === "already-completed", `replay=${JSON.stringify(replay.envelope).slice(0, 260)}`);
             ok(server.fake.bodiesFor("/api/api/app/bizmodels/create").length === 1, "replay must not send a second create wire");
             const diverged = await agent.run(["call", "model.create", "--env", "eval", "--args", JSON.stringify({ name: "幂等模型2", code: "eval_idem2" }), "--request-id", "eval-idem-1"]);
-            ok(diverged.code === 0 && diverged.envelope.result?.status === "ok", "same requestId with diverged args must execute as a new request");
-            ok(server.fake.bodiesFor("/api/api/app/bizmodels/create").length === 2, "diverged args must not replay the first request");
+            ok(diverged.code === 12 && diverged.envelope.result?.blocker === "request-id-args-mismatch", `diverged args must refuse mismatch, got ${JSON.stringify(diverged.envelope).slice(0, 260)}`);
+            ok(server.fake.bodiesFor("/api/api/app/bizmodels/create").length === 1, "diverged args must not write a second create");
         },
     },
     {

package/dist/call.js

@@ -9,6 +9,7 @@ import { parseToolInput, ToolInputError } from "./tool-types.js";
 import { absencePointer } from "./capability-absences.js";
 import { closestMatches } from "./closest-match.js";
 import { attachRefusalRecovery } from "./refusal-guidance.js";
+import { lockOwner } from "./write-lock.js";
 export const CALL_EXIT_CODES = { ok: 0, failed: 1, unknownTool: 2, invalidInput: 10 };
 export const CLI_ARGS_MAX_BYTES = 1024 * 1024;
 function readBounded(fd, label) {
@@ -168,7 +169,33 @@ export async function runToolCall(toolName, options = {}) {
             try {
                 return await Promise.race([
                     invoke(),
-                    new Promise((resolve) => { timer = setTimeout(() => resolve({ status: "uncertain", blocker: "cli-timeout", nextAction: "read back the requestId before retrying; retry only after the outcome is established", retryable: true }), options.timeoutMs); }),
+                    new Promise((resolve) => {
+                        timer = setTimeout(() => {
+                            // r30a F4/F5: lock is deliberately kept on cli-timeout (cli.ts),
+                            // so retryable must NOT claim "retry now". Put lock state into
+                            // the JSON envelope and give a pasteable request.status command.
+                            const envName = typeof args.environment === "string" && args.environment.length > 0 ? args.environment : options.environment;
+                            const lockHeldBy = typeof envName === "string" && envName.length > 0 ? lockOwner(envName) : null;
+                            const requestId = typeof args.requestId === "string" ? args.requestId : options.requestId;
+                            const envFlag = typeof envName === "string" && envName.length > 0 ? ` --env ${envName}` : "";
+                            const statusCmd = typeof requestId === "string" && requestId.length > 0
+                                ? `omc call request.status${envFlag} --args '{"requestId":"${requestId}"}'`
+                                : `omc call request.status${envFlag} --args '{"requestId":"<本次 requestId>"}'`;
+                            resolve({
+                                status: "uncertain",
+                                blocker: "cli-timeout",
+                                frozen: true,
+                                // Lock still held by this process until exit → not immediately retryable.
+                                retryable: false,
+                                retryableAfter: "process-exit",
+                                retryAfter: lockHeldBy?.pid !== undefined ? `pid ${lockHeldBy.pid} exits` : "current process exits (stale lock auto-recovers)",
+                                lockHeldBy,
+                                nextAction: `${statusCmd}；确认结果后再决定是否换 requestId 重试（锁未放前立刻重试会撞 write-lock-held）`,
+                                nextCommand: statusCmd,
+                                message: "outcome is uncertain: cli-timeout；写可能仍在飞，环境写锁故意未释放",
+                            });
+                        }, options.timeoutMs);
+                    }),
                 ]);
             }
             finally {
@@ -209,9 +236,15 @@ export async function runToolCall(toolName, options = {}) {
  * one raw + one escaped, read as "奇奇怪怪的乱码").
  */
 function humanResultLine(result) {
+    const status = String(result?.status ?? "ok");
+    // dry-run 的正文（含 summary）已经完整在信封里，再往 stderr 印一行就是重复载荷
+    // ——这正是 2026-10-14 Windows 那次「两行 JSON、一行还被转义」的根因。
+    // 2026-11-05 回归：`model.create` 的会话级 dry-run 探测开始在顶层带 summary，
+    // 于是这一行又被印出来（round16 的「dry-run 不打印人话」断言失败）。
+    if (status === "dry-run")
+        return null;
     if (typeof result.summary === "string" && result.summary.trim().length > 0)
         return result.summary;
-    const status = String(result?.status ?? "ok");
     if (status === "ok" || status === "dry-run")
         return null;
     if (result?.blocker === undefined && status !== "error" && status !== "uncertain")

package/dist/capability-overview.js

@@ -24,7 +24,7 @@ const SURFACES = [
         operations: ["discover", "fingerprint"],
         requires: [],
         intent: { level: "none", note: "治理面，不进 intent；用 omc setup / discover_environment。" },
-        notes: "只读；写入开关与生产授权在 omc setup。",
+        notes: "只读；写入开关与生产授权在 omc setup。discover/fingerprint 回 detectedVersion/inAnchorFamily/versionSource（与 doctor 同源）。",
     },
     {
         id: "app",
@@ -88,6 +88,8 @@ const SURFACES = [
         description: "列表视图设计时表头与列生命周期。",
         operations: ["create", "configure", "delete"],
         intent: { level: "partial", note: "create/configure 与 delete（absent:true）已声明式。" },
+        // r30f F5：partial 不能只剩一个词——说清「哪一半可用 / 哪一半要实跑」。
+        notes: "coverage=partial：create/configure/get/list/delete 可用；1.1.x 上 delete/absent 与默认视图短路需实跑，勿当 full。",
     },
     {
         id: "datarule",
@@ -97,7 +99,7 @@ const SURFACES = [
         operations: ["create", "update", "delete"],
         requires: ["field"],
         intent: { level: "partial", note: "声明式支持字段级规则 create/update 与 delete（absent:true）；规则类型 1..5 与 options 按平台校验器闭环。" },
-        notes: "目标字段必须已发布。",
+        notes: "目标字段必须已发布。coverage=partial：list/create/update/delete 可用；type3/4/5 设计态行≠运行时 options（运行时优先 field.update）；跨版本请实跑。",
     },
     {
         id: "businessrule",
@@ -166,7 +168,7 @@ const SURFACES = [
         description: "报表页 + BI 图表：报表树/元数据读取、报表页建改删、BI dashboard 配置、图表增改删、图表数据查询、数据集读取/关联。",
         operations: ["tree", "get", "chartdata", "datasource", "create", "update", "delete", "configure"],
         intent: { level: "partial", note: "顶层 reports[] 声明式 create/update + dashboard configure（global/attributes/charts diff，removeUnlistedCharts 删未声明图表）；delete 走 omc call report.delete，datasource.link/chartdata 走 omc call。" },
-        notes: "报表页走平台通道 /api/api/report/*，BI dashboard/图表/数据走 /dashboard/v1/*（无 errcode 信封；body 必带 config:{token,reportCode,appCode}，缺则写操作静默 no-op）。BI 外层 corpId 是真实查询键（错值→dashboard.not.exist，空→corpid.empty），默认 \"a\"，可用 corpId 覆盖。",
+        notes: "coverage=partial：tree/get/create/update/configure/delete 与 datasource.link/chartdata 可用；BI(/dashboard/v1/*) 缺 config 会静默 no-op，跨版本请实跑。报表页走 /api/api/report/*；BI body 必带 config:{token,reportCode,appCode}。BI 外层 corpId 是真实查询键（错值→dashboard.not.exist，空→corpid.empty），默认 \"a\"，可用 corpId 覆盖。",
     },
     {
         id: "data",
@@ -297,6 +299,16 @@ export const BOUNDARY_CUES = Object.freeze({
         cues: ["子表套子表", "嵌套子表", "多级子表"],
         note: "嵌套子表（子表套子表）在 W6-S27 为 blocked；一级子表可用，嵌套不可",
     },
+    /**
+     * r31c F27: four near-synonyms for row-level data scope all returned 0 help
+     * hits. Surface as a boundary so `omc next "申请人只看自己的单据"` answers
+     * honestly instead of routing to workflow.permissions (who may originate).
+     */
+    "row-level-data-permission": {
+        status: "unsupported",
+        cues: ["只看自己", "只能看自己", "本人单据", "行级权限", "行级数据权限", "数据权限", "可见范围", "dataScope", "按登录人过滤"],
+        note: "行级数据权限 / 可见范围 / 申请人只看自己的单据不在工具覆盖内（没有按登录人动态过滤的读面/写面）。workflow.permissions 只管谁能发起；org.role.setUserScope 是角色成员部门管理范围；listview.conditions 是全局过滤。如实报告能力缺口，不要用发起权限/列表条件伪造",
+    },
     /**
      * r19 p14（2026-10-26 用户裁决：报表**暂不优先支持、先隐藏**，不是「平台
      * 不支持」）：报表分两层——平台层 `/api/api/report/*`（树/改名/存在性）在
@@ -322,15 +334,17 @@ export function boundaryOf(goal) {
 }
 const CAPABILITY_TOPICS = Object.freeze({
     environment: ["omc-start-here", "omc-write-hazards"],
-    app: ["omc-business-configuration", "omc-write-hazards"],
+    // r29a F4：应用参数矩阵挂 app-scope（合成 topic，见 skills.ts）。
+    app: ["app-scope", "omc-business-configuration", "omc-write-hazards"],
+    folder: ["app-scope", "omc-business-configuration"],
     dictionary: ["omc-business-configuration", "omc-tool-selection"],
-    model: ["omc-business-configuration", "omc-config-draft-review"],
+    model: ["app-scope", "omc-business-configuration", "omc-config-draft-review"],
     field: ["omc-business-configuration", "omc-tool-selection"],
     form: ["omc-business-configuration", "omc-config-draft-review"],
     listview: ["omc-business-configuration", "omc-tool-selection"],
     datarule: ["omc-business-configuration", "omc-refusals"],
-    businessrule: ["omc-business-configuration", "omc-refusals"],
-    "rule-lifecycle": ["omc-business-configuration", "omc-refusals"],
+    businessrule: ["app-scope", "omc-business-configuration", "omc-refusals"],
+    "rule-lifecycle": ["app-scope", "omc-business-configuration", "omc-refusals"],
     workflow: ["omc-business-configuration", "omc-refusals"],
     onlinejs: ["omc-business-configuration", "omc-write-hazards"],
     bizservice: ["omc-business-configuration", "omc-write-hazards"],

package/dist/cli-contract.js

@@ -264,10 +264,12 @@ export function nextCommandFor(result) {
  * accidents (0.6.6/0.6.7): `meta.get_status` → `"failed"`, `rollback apply` →
  * `"stopped"` both used to land in `internal` before they were added here.
  */
-export const RESULT_STATUSES = ["ok", "dry-run", "partial", "unknown-tool", "uncertain", "refused", "failed", "stopped", "blocked", "error"];
+export const RESULT_STATUSES = ["ok", "dry-run", "partial", "unknown-tool", "uncertain", "refused", "failed", "stopped", "blocked", "skipped", "error"];
 export const RESULT_STATUS_ROUTES = Object.freeze({
     ok: { kind: "success", envelopeStatus: "ok", exitCode: CLI_EXIT_CODES.ok },
     "dry-run": { kind: "success", envelopeStatus: "dry-run", exitCode: CLI_EXIT_CODES.ok },
+    // r30a F12: irreversible rollback apply is an expected answer, not an error.
+    skipped: { kind: "success", envelopeStatus: "skipped", exitCode: CLI_EXIT_CODES.ok },
     partial: { kind: "partial", envelopeStatus: "partial", code: "partial-batch", exitCode: 1 },
     "unknown-tool": { kind: "unknown-tool", envelopeStatus: "error", code: "invalid-input", exitCode: CLI_EXIT_CODES.invalidInput },
     uncertain: { kind: "uncertain", envelopeStatus: "uncertain", code: "uncertain", exitCode: CLI_EXIT_CODES.uncertain },
@@ -363,9 +365,13 @@ export function classifyResult(result) {
         };
     }
     if (route?.kind === "uncertain") {
+        // r30a F5: honour the producer's retryable flag (cli-timeout keeps the
+        // write lock → retryable:false). Default remains true for other uncertains
+        // that do not carry an explicit flag.
+        const retryable = result.retryable === false ? false : true;
         return {
             status: route.envelopeStatus,
-            error: withNext({ code: route.code, message: String(result.message ?? result.reason ?? "outcome is uncertain"), retryable: true }),
+            error: withNext({ code: route.code, message: String(result.message ?? result.reason ?? "outcome is uncertain"), retryable }),
             exitCode: route.exitCode,
         };
     }