weaver-work-cli 0.1.20 → 0.1.22

package/dist/shortcuts/meeting/operations/eb/task-progress.js

@@ -0,0 +1,123 @@
+/**
+ * 决议任务的**进度汇总**（供 `meeting.eb.decisionTask.list` 声明式挂载，见 catalog 的 `summarizeRows`）。
+ *
+ * 为什么需要（2026-09-21/22 真机确立的口径，三个坑每次手算都容易踩）：
+ * 1. **任务主表的 `decision_status` 恒为「未完成」** —— 既不随明细变化，也无法经接口写入，
+ *    所以"任务完成了没"**只能**从 `detail1`（执行人跟进记录）读；
+ * 2. **`executors` 可能是单对象也可能是数组**（1 人 = 对象，多人 = 数组），直接取 length 会得到 undefined；
+ * 3. **`detail1` 只有"已跟进过"的人才有记录** —— 没跟进的执行人不在里面，
+ *    若按 detail1 统计人数会漏人（表现为"1/1 完成"，其实还有个人没跟进）。
+ *
+ * 故这里统一：**以 `executors` 为人员基准，用 `detail1` 覆盖其状态，缺失的人补 `pending`**。
+ * 状态归一化成英文枚举便于程序判断；中文展示交给调用方翻译。
+ */
+function toText(value) {
+    return value === undefined || value === null ? '' : String(value);
+}
+/**
+ * `finish_status` 归一化。
+ *
+ * EB 在不同接口/配置下可能回**中文渲染值**（已完成 / 已延期 / 未完成）或**数字 id**（0/1/2），
+ * 两种都兼容；无法识别的一律按 `pending`（宁可少报完成，不夸大）。
+ */
+function normalizeFinishStatus(raw) {
+    const text = toText(raw).trim();
+    if (text === '')
+        return 'pending';
+    if (text === '1' || text.includes('已完成') || text === '完成')
+        return 'done';
+    if (text === '2' || text.includes('延期'))
+        return 'overdue';
+    return 'pending';
+}
+/** 人员字段（`executors` / `executor`）兼容"单对象 | 数组 | 纯 id 串"，统一成 `[{id,name}]`。 */
+function toPeople(raw) {
+    const list = raw === undefined || raw === null ? [] : (Array.isArray(raw) ? raw : [raw]);
+    const out = [];
+    const seen = new Set();
+    for (const item of list) {
+        if (item === undefined || item === null)
+            continue;
+        if (typeof item === 'object') {
+            const id = toText(item.id).trim();
+            if (id === '' || seen.has(id))
+                continue;
+            seen.add(id);
+            out.push({ id, name: toText(item.name) });
+        }
+        else {
+            const id = toText(item).trim();
+            if (id === '' || seen.has(id))
+                continue;
+            seen.add(id);
+            out.push({ id, name: '' });
+        }
+    }
+    return out;
+}
+/** 单行 → 任务进度。 */
+function summarizeRow(row) {
+    const main = (row?.mainTable ?? row ?? {});
+    const mt = (main.mt_id ?? {});
+    // detail1：只有已跟进的人才有记录 ⇒ 先建索引，再按 executors 对齐（缺的补 pending）。
+    const followed = new Map();
+    const details = Array.isArray(row?.detail1) ? row.detail1 : [];
+    for (const item of details) {
+        const who = toPeople(item?.executor)[0];
+        if (!who)
+            continue;
+        followed.set(who.id, {
+            status: normalizeFinishStatus(item?.finish_status),
+            finishDate: toText(item?.finish_date),
+        });
+    }
+    const members = toPeople(main.executors).map((person) => {
+        const hit = followed.get(person.id);
+        return {
+            executorId: person.id,
+            executorName: person.name,
+            status: hit ? hit.status : 'pending',
+            finishDate: hit ? hit.finishDate : '',
+        };
+    });
+    // 兜底：主表没带 executors 时退化为按跟进记录统计，避免显示 0/0 让人误判"没有执行人"。
+    if (members.length === 0) {
+        for (const [id, hit] of followed) {
+            members.push({ executorId: id, executorName: '', status: hit.status, finishDate: hit.finishDate });
+        }
+    }
+    const done = members.filter((item) => item.status === 'done').length;
+    const overdue = members.filter((item) => item.status === 'overdue').length;
+    const pending = members.length - done - overdue;
+    const status = members.length === 0
+        ? 'pending'
+        : done === members.length
+            ? 'done'
+            : overdue > 0
+                ? 'overdue'
+                : done > 0
+                    ? 'inProgress'
+                    : 'pending';
+    return {
+        id: toText(main.id),
+        title: toText(main.decision_title),
+        mtId: toText(mt.id),
+        mtName: toText(mt.name),
+        plan: { begin: toText(main.begin_datetime), end: toText(main.end_datetime) },
+        progress: { total: members.length, done, overdue, pending, status, members },
+    };
+}
+/** `decisionTask.list` 的结果后处理：原始 `rows` 原样保留，这里只额外给出 `progress`。 */
+export function summarizeTaskProgress(rows) {
+    const items = rows.map((row) => summarizeRow(row ?? {}));
+    return {
+        summary: {
+            total: items.length,
+            done: items.filter((item) => item.progress.status === 'done').length,
+            overdue: items.filter((item) => item.progress.status === 'overdue').length,
+            inProgress: items.filter((item) => item.progress.status === 'inProgress').length,
+            pending: items.filter((item) => item.progress.status === 'pending').length,
+        },
+        items,
+    };
+}

package/dist/shortcuts/meeting/operations/env.js

@@ -16,6 +16,13 @@ function stateRoot(ctx) {
         return resolve(configured, '..');
     return process.env.WEAVER_WORK_CLI_HOME || process.env.WORK_CLI_HOME || resolve(homedir(), '.weaver-work-cli');
 }
+/**
+ * 会议模块状态目录（`<stateRoot>/meeting`）：环境模式缓存、EB objid 缓存等落在这里。
+ * 导出供 link.ts 复用，避免各文件各自推导 stateRoot 导致缓存分裂。
+ */
+export function meetingStateDir(ctx) {
+    return resolve(stateRoot(ctx), 'meeting');
+}
 function cacheFile(ctx) {
     return resolve(stateRoot(ctx), 'meeting', 'env-mode.json');
 }
@@ -50,6 +57,74 @@ async function writeCache(ctx, baseUrl, mode, smokePath) {
         return `环境模式缓存写入失败（不影响本次结果，下次会重新冒烟）：${error instanceof Error ? error.message : String(error)}`;
     }
 }
+/**
+ * 解析当前环境的会议模式（EB / 标准版），供 `meeting.env.detect` 与 `meeting.link`
+ * 共用同一套缓存与冒烟逻辑（避免两处判定不一致导致链接模式选错）。
+ */
+export async function resolveMeetingEnvMode(host, ctx, options = {}) {
+    const session = await host.getSession();
+    // ① 默认先读缓存（按 baseUrl 固化）；refresh=true 才强制重新冒烟。
+    if (options.refresh !== true) {
+        const cache = await readCache(ctx);
+        const cached = cache.environments[session.baseUrl];
+        if (cached && (cached.mode === 'eb' || cached.mode === 'standard')) {
+            return {
+                mode: cached.mode,
+                smokePath: cached.smokePath,
+                fromCache: true,
+                detectedAt: cached.detectedAt,
+            };
+        }
+    }
+    // ② 第 1 步：EB 版冒烟（EB 优先）。接口 404/业务失败均视为「EB 未配置」。
+    let ebError;
+    try {
+        await host.request({
+            method: 'POST',
+            path: EB_SMOKE_PATH,
+            operation: 'meeting.env.detect',
+            // EB list 的 datajson 内必须出现 mainTable 节点（空对象即可）：缺失时服务端报
+            // “mainTable解析异常,请参照文档修正数据格式”，冒烟会**假失败**并把 EB 环境误判为
+            // 标准版（2026-09-20 真机复现）。
+            body: { datajson: { mainTable: {}, header: { operator: session.userId } } },
+            // EB 响应不含 code/status（形如 {datajson:{datas:[...]}}），默认的 isBusinessSuccess
+            // 会判为 false → 冒烟假失败 → EB 环境被误判为标准版。
+            acceptBusiness: ebBusinessSuccess,
+        });
+        const warning = await writeCache(ctx, session.baseUrl, 'eb', EB_SMOKE_PATH);
+        return { mode: 'eb', smokePath: EB_SMOKE_PATH, fromCache: false, warning };
+    }
+    catch (error) {
+        ebError = error;
+    }
+    // ③ 第 2 步：标准版冒烟（仅当 EB 冒烟未通过）。
+    try {
+        await host.request({
+            method: 'GET',
+            path: STD_CALENDAR_PATH,
+            operation: 'meeting.env.detect',
+        });
+        const ebDetail = ebError instanceof Error
+            ? `${ebError.type ?? 'api'}/${ebError.subtype ?? 'error'}: ${ebError.message}`
+            : String(ebError);
+        const warning = await writeCache(ctx, session.baseUrl, 'standard', STD_CALENDAR_PATH);
+        return {
+            mode: 'standard',
+            smokePath: STD_CALENDAR_PATH,
+            fromCache: false,
+            ebSmokeFailed: true,
+            ebSmokeError: ebDetail,
+            warning,
+        };
+    }
+    catch (stdError) {
+        // 两步都不通 → 不写缓存，提示接口未配置完整。
+        throw meetingValidationError('env_unavailable', '当前环境 EB 版与标准版会议接口冒烟均未通过，请确认会议应用已安装且接口已配置完整', {
+            eb: ebError instanceof Error ? ebError.message : String(ebError),
+            standard: stdError instanceof Error ? stdError.message : String(stdError),
+        });
+    }
+}
 const meetingEnvDetect = {
     name: 'meeting.env.detect',
     resource: 'env',
@@ -67,67 +142,9 @@ const meetingEnvDetect = {
         },
     },
     handler: async (args, { host, ctx }) => {
-        const session = await host.getSession();
-        // ① 默认先读缓存（按 baseUrl 固化）；refresh=true 才强制重新冒烟。
-        if (args.refresh !== true) {
-            const cache = await readCache(ctx);
-            const cached = cache.environments[session.baseUrl];
-            if (cached && (cached.mode === 'eb' || cached.mode === 'standard')) {
-                return meetingSuccess('meeting.env.detect', {
-                    mode: cached.mode,
-                    smokePath: cached.smokePath,
-                    fromCache: true,
-                    detectedAt: cached.detectedAt,
-                });
-            }
-        }
-        // ② 第 1 步：EB 版冒烟（EB 优先）。接口 404/业务失败均视为「EB 未配置」。
-        let ebError;
-        try {
-            await host.request({
-                method: 'POST',
-                path: EB_SMOKE_PATH,
-                operation: 'meeting.env.detect',
-                // EB list 的 datajson 内必须出现 mainTable 节点（空对象即可）：缺失时服务端报
-                // “mainTable解析异常,请参照文档修正数据格式”，冒烟会**假失败**并把 EB 环境误判为
-                // 标准版（2026-09-20 真机复现）。
-                body: { datajson: { mainTable: {}, header: { operator: session.userId } } },
-                // EB 响应不含 code/status（形如 {datajson:{datas:[...]}}），默认的 isBusinessSuccess
-                // 会判为 false → 冒烟假失败 → EB 环境被误判为标准版。
-                acceptBusiness: ebBusinessSuccess,
-            });
-            const warning = await writeCache(ctx, session.baseUrl, 'eb', EB_SMOKE_PATH);
-            return meetingSuccess('meeting.env.detect', { mode: 'eb', smokePath: EB_SMOKE_PATH, fromCache: false }, warning ? { warnings: [warning] } : undefined);
-        }
-        catch (error) {
-            ebError = error;
-        }
-        // ③ 第 2 步：标准版冒烟（仅当 EB 冒烟未通过）。
-        try {
-            await host.request({
-                method: 'GET',
-                path: STD_CALENDAR_PATH,
-                operation: 'meeting.env.detect',
-            });
-            const ebDetail = ebError instanceof Error
-                ? `${ebError.type ?? 'api'}/${ebError.subtype ?? 'error'}: ${ebError.message}`
-                : String(ebError);
-            const warning = await writeCache(ctx, session.baseUrl, 'standard', STD_CALENDAR_PATH);
-            return meetingSuccess('meeting.env.detect', {
-                mode: 'standard',
-                smokePath: STD_CALENDAR_PATH,
-                fromCache: false,
-                ebSmokeFailed: true,
-                ebSmokeError: ebDetail,
-            }, warning ? { warnings: [warning] } : undefined);
-        }
-        catch (stdError) {
-            // 两步都不通 → 不写缓存，提示接口未配置完整。
-            throw meetingValidationError('env_unavailable', '当前环境 EB 版与标准版会议接口冒烟均未通过，请确认会议应用已安装且接口已配置完整', {
-                eb: ebError instanceof Error ? ebError.message : String(ebError),
-                standard: stdError instanceof Error ? stdError.message : String(stdError),
-            });
-        }
+        const result = await resolveMeetingEnvMode(host, ctx, { refresh: args.refresh === true });
+        const { warning, ...data } = result;
+        return meetingSuccess('meeting.env.detect', data, warning ? { warnings: [warning] } : undefined);
     },
 };
 // ---------------------------------------------------------------------------

package/dist/shortcuts/meeting/operations/link.js

@@ -0,0 +1,125 @@
+import { meetingValidationError } from '../errors.js';
+import { meetingSuccess, schemaOf, SCHEMA_ID, SCHEMA_ID_LIST } from './types.js';
+import { resolveMeetingEnvMode } from './env.js';
+import { MEETING_EB_TAGS, STANDARD_NO_PAGE_TYPES, buildEbCardPath, buildStandardMeetingPath, meetingAbsoluteUrl, meetingMarkdownLink, resolveMeetingEbObjs, } from './eb/link.js';
+const EB_TYPES = Object.keys(MEETING_EB_TAGS);
+/**
+ * `meeting.link` —— 会议对象「打开链接」生成器（EB 版 + 标准版）。
+ *
+ * 为什么要单独一个 operation：链接地址随模式不同、且 EB 版需要按表 tag 动态解析 objid
+ * （objid 随环境变化、禁止硬编码，也不等于 formId），不能让 Agent 手工拼 URL。
+ * 解析失败只降级为「不附链接」并写 warnings，**不影响**主业务结果。
+ */
+const meetingLink = {
+    name: 'meeting.link',
+    resource: 'link',
+    method: 'resolve',
+    action: 'meeting.link',
+    summary: '生成对象详情页链接：EB 版 /sp/ebdfpage/card/0/{objid}/{dataid}（按 tag 解析 objid 并缓存）；标准版会议 /sp/meeting/meetingSingle?meetingId=（会议室/会议类型无单页，不附链接）',
+    capability: 'link',
+    risk: 'read',
+    inputSchema: schemaOf({
+        dataId: { ...SCHEMA_ID, description: '对象 id：标准版=会议 id；EB 版=表单数据 id（单条查询用）' },
+        dataIds: { ...SCHEMA_ID_LIST, description: '批量：一次为多条数据生成链接（列表输出用）' },
+        type: {
+            type: 'string',
+            enum: [...EB_TYPES],
+            description: '对象类别（默认 meeting）。映射 EB 表 tag，详见 references/meeting-eb.md 的链接章节',
+        },
+        tag: { type: 'string', description: '直接指定 EB 表 tag（如 uf_mt_detail），与 type 二选一，优先于 type' },
+        mode: {
+            type: 'string',
+            enum: ['auto', 'eb', 'standard'],
+            description: 'auto（默认）=按当前环境模式自动判定；也可显式指定',
+        },
+        name: { type: 'string', description: '链接显示名；传入后同时返回 markdown 内联链接' },
+        refresh: { type: 'boolean', description: 'true=强制重新解析 EB objid（忽略缓存）' },
+    }, { required: [] }),
+    handler: async (args, { host, ctx }) => {
+        const single = args.dataId !== undefined && args.dataId !== null && String(args.dataId).trim() !== '';
+        const batch = Array.isArray(args.dataIds)
+            ? args.dataIds.map((item) => String(item)).filter((item) => item.trim() !== '')
+            : [];
+        const dataIds = single ? [String(args.dataId)] : batch;
+        if (dataIds.length === 0) {
+            throw meetingValidationError('link_data_id_required', '生成链接必须提供 dataId（单条）或 dataIds（批量）');
+        }
+        const requestedType = args.type === undefined ? 'meeting' : String(args.type);
+        const tag = typeof args.tag === 'string' && args.tag.trim() !== ''
+            ? args.tag.trim()
+            : MEETING_EB_TAGS[requestedType];
+        if (!tag) {
+            throw meetingValidationError('link_type_invalid', `未知对象类别：${requestedType}（可用：${EB_TYPES.join(' / ')}，或用 tag 直接指定表 tag）`);
+        }
+        const session = await host.getSession();
+        const warnings = [];
+        const requestedMode = args.mode === undefined ? 'auto' : String(args.mode);
+        let mode;
+        if (requestedMode === 'eb' || requestedMode === 'standard') {
+            mode = requestedMode;
+        }
+        else {
+            const detected = await resolveMeetingEnvMode(host, ctx, {});
+            mode = detected.mode;
+            if (detected.warning)
+                warnings.push(detected.warning);
+        }
+        let objId = null;
+        let appId = null;
+        let fromCache = false;
+        if (mode === 'standard') {
+            // 标准版：只有会议详情有单页；会议室 / 会议类型明确无单页（standalone 口径）。
+            if (STANDARD_NO_PAGE_TYPES.includes(requestedType)) {
+                warnings.push(`标准版「${requestedType}」没有单页地址，按口径只输出数据、不附链接`);
+            }
+            else if (requestedType !== 'meeting') {
+                warnings.push(`标准版未记录「${requestedType}」的单页地址，已跳过链接生成`);
+            }
+        }
+        else {
+            const resolved = await resolveMeetingEbObjs(host, ctx, { tags: [tag], refresh: args.refresh === true });
+            objId = resolved.objs[tag]?.objId ?? null;
+            appId = resolved.appId;
+            fromCache = resolved.fromCache;
+            warnings.push(...resolved.warnings);
+            if (!objId)
+                warnings.push(`未解析到 tag=${tag} 的 objid，本次不附链接`);
+        }
+        const noStdPage = mode === 'standard' && requestedType !== 'meeting';
+        const items = dataIds.map((dataId) => {
+            const path = mode === 'eb'
+                ? (objId ? buildEbCardPath(objId, dataId) : null)
+                : (noStdPage ? null : buildStandardMeetingPath(dataId));
+            const url = meetingAbsoluteUrl(session.baseUrl, path);
+            const item = { dataId, path, url };
+            const markdown = typeof args.name === 'string' && args.name.trim() !== ''
+                ? meetingMarkdownLink(args.name, url)
+                : undefined;
+            if (markdown)
+                item.markdown = markdown;
+            return item;
+        });
+        // source：objid 的来源（cache/dynamic）；标准版不需要 objid ⇒ none。
+        const source = mode === 'eb' ? (objId ? (fromCache ? 'cache' : 'dynamic') : 'none') : 'none';
+        const data = {
+            mode,
+            type: requestedType,
+            // 标准版不涉及 EB 表 tag，返回 null 避免误用。
+            tag: mode === 'eb' ? tag : null,
+            baseUrl: session.baseUrl,
+            appId,
+            objId,
+            source,
+            items,
+        };
+        if (single) {
+            const [first] = items;
+            data.path = first.path;
+            data.url = first.url;
+            if (first.markdown)
+                data.markdown = first.markdown;
+        }
+        return meetingSuccess('meeting.link', data, warnings.length ? { warnings } : {});
+    },
+};
+export const meetingLinkOperations = [meetingLink];

package/dist/shortcuts/meeting/operations/registry.js

@@ -9,6 +9,7 @@ import { meetingCreateOperations } from './create.js';
 import { meetingLifecycleOperations } from './lifecycle.js';
 import { meetingReceiptOperations } from './receipts.js';
 import { meetingSignOperations } from './signs.js';
+import { meetingLinkOperations } from './link.js';
 import { meetingEbOperations } from './eb/index.js';
 function buildRegistry() {
     const registry = new Map();
@@ -23,6 +24,7 @@ function buildRegistry() {
         ...meetingChangeOperations,
         ...meetingReceiptOperations,
         ...meetingSignOperations,
+        ...meetingLinkOperations,
         ...meetingEbOperations,
     ];
     for (const definition of definitions) {

package/dist/shortcuts/meeting/operations/shared.js

@@ -29,6 +29,19 @@ export function assertDateTimeMinute(value, label) {
     }
     return value;
 }
+/**
+ * 校验 `yyyy-MM-dd HH:mm:ss`（**带秒**）—— EB 部分字段要求带秒。
+ *
+ * 2026-09-21 真机实测：决议任务的 `finish_date` 只接受带秒格式，传 `2026-09-21 18:30`
+ * 会被服务端拒绝（「不满足传入格式yyyy-MM-dd HH:mm:ss」）。而决议明细的
+ * `begin_datetime`/`end_datetime` 是不带秒的 —— **同一应用里两种格式并存**，故分别校验。
+ */
+export function assertDateTimeSecond(value, label) {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(value)) {
+        throw meetingValidationError('datetime_invalid', `${label} 必须是 yyyy-MM-dd HH:mm:ss 格式（带秒）`);
+    }
+    return value;
+}
 /** 校验 yyyy-MM-dd，返回原串。 */
 export function assertDate(value, label) {
     if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)) {

package/dist/shortcuts/workflow/host.js

@@ -124,7 +124,8 @@ function loginExpiredMessage() {
 export function createWorkflowHost(ctx, dependencies = {}) {
     let session = null;
     let sessionContext = null;
-    const requireSession = dependencies.requireSession || requireE10Session;
+    const requireSession = dependencies.requireSession
+        || ((innerCtx) => requireE10Session(innerCtx, { skipProfileEnrichment: true }));
     async function ensureSession() {
         if (!session) {
             session = await requireSession(ctx);
@@ -153,6 +154,9 @@ export function createWorkflowHost(ctx, dependencies = {}) {
         const runtime = createE10RequestRuntime(ctx, await ensureSession(), {
             interceptors: dependencies.interceptors,
             fetch: dependencies.fetch,
+            // 流程侧是唯一开启"请求带上网关会话票据（ZT_SESSION）"的调用方：登录时已把票存进 auth
+            // （`ztSession`），带上可让网关不再为每个请求重发票。没有票或票已过期时不附加，请求头与从前一致。
+            attachSessionTicket: true,
         });
         let response;
         try {

package/dist/shortcuts/workflow/operations/form.js

@@ -1290,8 +1290,11 @@ async function resolveCreateWorkflow(rawWorkflow, env) {
             return { id: String(exact[0].id), name: String(exact[0].workflowname ?? ''), source: 'exactName' };
         }
         const list = exact.length ? exact : picked;
-        throw workflowClarificationError('workflow', queryText, `「${queryText}」匹配到 ${list.length} 个可发起的工作流，且其中没有与所写名称完全一致的，`
-            + '请确认要发起的具体工作流。', list.slice(0, 10).map((item, index) => ({
+        // `clarificationQuestion` 是**用户口径**：它会被 `note` 要求「原样交给用户确认」，因此
+        // 只能写"发生了什么 + 要用户做什么"。**禁止**把本机判定依据（如"其中没有与所写名称完全
+        // 一致的"）写进这句——那属于 CLI 内部实现，外传会让用户在确认卡片上看到与己无关的判据
+        // 解释（2026-09-24 用户实拍）。模型侧的护栏是「不要再换词试探」，由 skill 的行为指令承担。
+        throw workflowClarificationError('workflow', queryText, `「${queryText}」匹配到 ${list.length} 个可发起的工作流，请确认要发起的具体工作流。`, list.slice(0, 10).map((item, index) => ({
             index: index + 1,
             id: String(item.id),
             name: String(item.workflowname ?? ''),
@@ -3622,11 +3625,15 @@ async function commandCreateRequest(args, env) {
         });
         // parseCreateResponse 需读外层 status/code 并向下遍历 data/result，必须传原始响应
         created = parseCreateResponse(createResponse, context.runtime.request_id);
-        // flow/create 已返回成功：阶段推进到 committed。若进程在"回写成功结果"之前被中止，
-        // 重放可据此报幂等成功（ALREADY_APPLIED + requestId），而不是只报一句"已使用"让人反查。
-        await env.continuation
-            .markStage(token, 'committed', { requestId: context.runtime.request_id })
-            .catch(() => undefined);
+        if (created.outcome === 'created') {
+            // flow/create 已返回成功：阶段推进到 committed。若进程在"回写成功结果"之前被中止，
+            // 重放可据此报幂等成功（ALREADY_APPLIED + requestId），而不是只报一句"已使用"让人反查。
+            await env.continuation
+                .markStage(token, 'committed', { requestId: context.runtime.request_id })
+                .catch(() => undefined);
+        }
+        // outcome === 'rejected' 时**不**标 committed：服务端并没有给"成功回执"，
+        // 标了会让后续重放报出"上一次已成功"的假消息。结果照常由 settle() 收尾。
     }
     catch (error) {
         if (isNetworkError(error)) {
@@ -3643,8 +3650,8 @@ async function commandCreateRequest(args, env) {
         requestId,
         requestName: prepared.requestName,
         requestId_alt: requestId,
-        requestMark: created.requestMark || null,
-        requestName_alt: created.requestName || prepared.requestName,
+        requestMark: (created.outcome === 'created' && created.requestMark) || null,
+        requestName_alt: (created.outcome === 'created' && created.requestName) || prepared.requestName,
         workflow: context.workflow,
         url: `${baseUrl}/sp/workflow/flowpage/view/${requestId}?operResultType=SUCCESS_RELOAD_CURRENT_PAGE&userSpecifiedNodeId=0&autoMaxDisplay=0`,
         linkageResult,
@@ -3657,7 +3664,18 @@ async function commandCreateRequest(args, env) {
         previewDetails: prepared.previewDetails,
     };
     if (submitIntent) {
-        if (verification.blocked) {
+        if (created.outcome === 'rejected' && createSrc === 'submit') {
+            // 服务端明确拒绝提交，但**表单数据已落库、流程以草稿形态存在**（真机实测：被拒后该
+            // requestId 在 workflow.detail 里查得到，flowStatus=草稿）。故按"完成 + 提交结果失败"
+            // 返回，而不是抛错——抛错会让模型以为"什么都没做成"而重发，一路堆积重复草稿。
+            // 所有"成功时会给的创建信息"这里一个都不少，只是提交结果是失败。
+            result.status = 'CREATED_SUBMIT_FAILED';
+            result.message = `流程已创建为草稿，但提交被服务端拒绝（未进入审批）。原因：${created.reason}`;
+            result.submitResult = 'failed';
+            result.submitFailReason = created.reason;
+            result.verification = verification;
+        }
+        else if (verification.blocked) {
             result.message = '流程已创建，但因节点字段校验未通过未提交审批，请调整后重新提交。';
             result.verification = verification;
         }
@@ -3670,6 +3688,7 @@ async function commandCreateRequest(args, env) {
         else {
             result.status = 'CREATED_SUBMITTED';
             result.message = '流程已发起并提交审批。';
+            result.submitResult = 'success';
             result.verification = verification;
         }
     }
@@ -3685,6 +3704,12 @@ async function commandCreateRequest(args, env) {
                     : '。');
         }
     }
+    // 非"本次真发起提交"的路径（action=draft，或被节点校验拦下、未真正提交）里 flow/create 也被拒：
+    // 不改这些分支的状态语义（它们本就描述"未提交审批"），但把服务端给的原因附上，避免信息静默丢失。
+    if (created.outcome === 'rejected' && !(submitIntent && createSrc === 'submit')) {
+        result.createRejectedReason = created.reason;
+        result.message = `${result.message}（服务端在创建时返回：${created.reason}）`;
+    }
     // 必填字段的本次取值 → 该工作流的发起偏好（CLI 内部完成、**静默**，见下方调用点注释）
     const requiredFieldIds = new Set();
     for (const field of fields) {
@@ -3824,11 +3849,69 @@ function parseSaveResponse(response) {
     }
     return values;
 }
+/**
+ * `flow/create` 的**明确拒绝**判定——把「服务端说不」与「结果不确定」分开。
+ *
+ * 2026-09-24 真机实测（发起「泛微请假流程」提交）：
+ *   `POST /api/workflow/core/flow/create` → HTTP 200
+ *   `{"status":false,"resultType":"FAIL_SHOW_ERROR_MSG","resultMessage":"监听事件触发异常",
+ *     "exceptionFlowLog":{"flowExMainPrompt":{"listenerOriginalMsg":"考勤校验失败:请假天数不能小于0"}}}`
+ * 服务端**已经明确表态"不提交"并给出原因**，但 host 层的业务错误提取只认
+ * `msg/message/error/errorMsg`（不认 `resultMessage`），漏判后落到本函数，
+ * 原实现把这句"确定失败"抛成 `partial/write_uncertain`（语义＝"可能已生效、禁止重试、先回查"）。
+ * 模型读到 `write_uncertain` 无法分辨"被拒了"与"断线了"，只能把草稿说成"可能已提交"。
+ *
+ * 因此按**失败信号是否显式**分流（V11.3 基线 `e10_workflow_create.py:4822` 同样只有
+ * `PARTIAL_SAVED` 一档，属继承缺陷，此处为有意偏离）：
+ *   - 显式拒绝（本函数命中）→ 确定失败，原因+草稿 requestId 原样带出；
+ *   - 形态不明（无任何成功/失败标志）→ 仍按 `partial/write_uncertain` 处理。
+ */
+function isCreateRejected(response) {
+    if (response.fail === true)
+        return true;
+    if (response.status === false)
+        return true;
+    if (response.flowIsCreateSuccess === false)
+        return true;
+    return String(response.resultType ?? '').trim().toUpperCase().startsWith('FAIL');
+}
+/**
+ * 从 `flow/create` 的拒绝响应里挑出**最可执行**的原因文案。
+ *
+ * `resultMessage` 常是泛化壳文案（真机是「监听事件触发异常」），真正能指导用户的是
+ * `exceptionFlowLog.flowExMainPrompt` 里的 `listenerOriginalMsg`/`msgTitle`
+ * （真机是「考勤校验失败:请假天数不能小于0」）。故按"越具体越优先"排序取第一个非空值。
+ */
+function pickCreateRejectReason(response) {
+    const prompt = (response.exceptionFlowLog ?? {}).flowExMainPrompt ?? {};
+    const candidates = [
+        prompt.listenerOriginalMsg,
+        response.msgTitle,
+        prompt.listenerExMsgs,
+        response.resultMessage,
+        response.msg,
+        response.message,
+    ];
+    for (const candidate of candidates) {
+        const text = typeof candidate === 'string' ? candidate.trim() : '';
+        if (text)
+            return text;
+    }
+    return '服务端未给出原因';
+}
 function parseCreateResponse(response, expectedRequestId) {
     if (!response || typeof response !== 'object')
         throw workflowPartialError('flow/create 返回格式错误，禁止自动重试', { stage: 'flow/create' });
+    if (isCreateRejected(response)) {
+        return {
+            outcome: 'rejected',
+            reason: pickCreateRejectReason(response),
+            resultType: String(response.resultType ?? '').trim(),
+            requestId: String(response.requestId ?? response.requestid ?? expectedRequestId).trim() || expectedRequestId,
+        };
+    }
     const success = response.status === true || [0, 200, '0', '200'].includes(response.code) || [0, 200, '0', '200'].includes(response.status);
-    if (!success || response.flowIsCreateSuccess === false || response.fail === true) {
+    if (!success) {
         throw workflowPartialError(String(response.resultMessage ?? response.msg ?? 'flow/create 未确认成功'), { stage: 'flow/create' });
     }
     const sources = [response];
@@ -3856,6 +3939,7 @@ function parseCreateResponse(response, expectedRequestId) {
         throw workflowPartialError('flow/create 返回了不同的 requestId，禁止自动重试', { stage: 'flow/create' });
     }
     return {
+        outcome: 'created',
         requestId: returnedId || expectedRequestId,
         requestMark: firstText('requestMark', 'requestmark', 'requestCode'),
         requestName: firstText('requestName', 'requestname'),