weaver-work-cli 0.1.20 → 0.1.21

package/dist/shortcuts/hrm/operations/resolve.js

@@ -0,0 +1,449 @@
+import { hrmValidationError } from '../errors.js';
+import { browserBaseBody, orgLink, } from './shared.js';
+import { READ, SCHEMA_ID, hrmSuccess, schemaOf, } from './types.js';
+const VIRTUAL_PATH = '/api/bs/hrm/companyVirtual/listCompanyVirtual';
+const ORG_DETAIL_PATH = '/api/bs/hrm/organization/getForm';
+const ORG_TYPES = ['department', 'subcompany'];
+const DEFAULT_MAX_CANDIDATES = 20;
+const MAX_CANDIDATES = 200;
+const MAX_SUGGESTIONS = 5;
+function text(value) {
+    return value === undefined || value === null ? '' : String(value).trim();
+}
+/** 名称匹配忽略大小写、全半角差异和多余空白。 */
+function normalizedName(value) {
+    return text(value).normalize('NFKC').replace(/\s+/gu, '').toLocaleLowerCase();
+}
+function normalizePath(value) {
+    return text(value)
+        .split(/[|/]+/u)
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .join('/');
+}
+function idValue(value, field) {
+    const valueText = text(value);
+    if (!/^\d+$/u.test(valueText)) {
+        throw hrmValidationError('id_invalid', `${field} 必须是数字 ID`);
+    }
+    return valueText;
+}
+function maxCandidatesValue(value) {
+    if (value === undefined || value === null || value === '')
+        return DEFAULT_MAX_CANDIDATES;
+    const numeric = Number(value);
+    if (!Number.isInteger(numeric) || numeric < 1 || numeric > MAX_CANDIDATES) {
+        throw hrmValidationError('number_invalid', `maxCandidates 必须是 1~${MAX_CANDIDATES} 的整数`);
+    }
+    return numeric;
+}
+function uniqueById(items) {
+    const seen = new Set();
+    return items.filter((item) => {
+        if (!item.id || seen.has(item.id))
+            return false;
+        seen.add(item.id);
+        return true;
+    });
+}
+function readVirtuals(response) {
+    const root = response?.data;
+    const rows = Array.isArray(root) ? root : Array.isArray(root?.data) ? root.data : [];
+    return uniqueById(rows
+        .map((row) => ({
+        id: text(row?.id ?? row?.value),
+        name: text(row?.content ?? row?.name ?? row?.label),
+    }))
+        .filter((item) => item.id && item.name));
+}
+function levenshtein(left, right) {
+    const a = [...left];
+    const b = [...right];
+    let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    for (let row = 1; row <= a.length; row += 1) {
+        const current = [row];
+        for (let column = 1; column <= b.length; column += 1) {
+            current[column] = Math.min(current[column - 1] + 1, previous[column] + 1, previous[column - 1] + (a[row - 1] === b[column - 1] ? 0 : 1));
+        }
+        previous = current;
+    }
+    return previous[b.length];
+}
+function similarity(left, right) {
+    const a = normalizedName(left);
+    const b = normalizedName(right);
+    const longest = Math.max([...a].length, [...b].length);
+    return longest === 0 ? 1 : 1 - levenshtein(a, b) / longest;
+}
+function nearVirtuals(keyword, virtuals) {
+    return virtuals
+        .map((item) => ({ item, score: similarity(keyword, item.name) }))
+        .filter(({ score }) => score >= 0.6 && score < 1)
+        .sort((left, right) => right.score - left.score)
+        .map(({ item }) => item)
+        .slice(0, MAX_SUGGESTIONS);
+}
+function orgPath(row, type) {
+    const direct = type === 'department' ? row.supDepartment : row.supSubDepartment;
+    if (text(direct))
+        return normalizePath(direct);
+    const title = text(row.title);
+    const name = text(row.name);
+    if (title && name && title.startsWith(`${name}|`)) {
+        return normalizePath(title.slice(name.length + 1));
+    }
+    return '';
+}
+function fullOrg(row, type, baseUrl, virtual) {
+    const id = text(row.id);
+    const name = text(row.name);
+    const parentPath = orgPath(row, type);
+    const rawFullPath = normalizePath(row.fullPath);
+    const fullPath = rawFullPath || (parentPath ? `${parentPath}/${name}` : name);
+    const virtualName = parentPath.split('/')[0] || virtual.name;
+    const parentId = text(row.parent?.id ?? row.parent);
+    const subcompanyId = text(row.subcompanyid ?? row.subcompanyId);
+    const virtualId = text(row.virtualid ?? row.virtualId) || virtual.id;
+    return {
+        id,
+        name,
+        type: text(row.type) || type,
+        ...(text(row.code) ? { code: text(row.code) } : {}),
+        fullPath,
+        ...(parentPath ? { parentPath } : {}),
+        ...(parentId ? { parentId } : {}),
+        ...(subcompanyId ? { subcompanyId } : {}),
+        virtualId,
+        virtualName,
+        ...(row.status !== undefined ? { status: row.status } : {}),
+        link: orgLink(baseUrl, id),
+    };
+}
+function orgCandidate(row, type, baseUrl, virtual) {
+    const item = fullOrg(row, type, baseUrl, virtual);
+    return {
+        id: item.id,
+        name: item.name,
+        type: item.type,
+        fullPath: item.fullPath,
+        ...(item.code ? { code: item.code } : {}),
+        link: item.link,
+    };
+}
+function browsePath(type) {
+    return type === 'department'
+        ? '/api/hrm/common/browser/data/department'
+        : '/api/hrm/common/browser/data/subcompany';
+}
+async function browseOrg(host, type, virtualId, keyword, condition, pageSize) {
+    const response = await host.request({
+        method: 'POST',
+        path: browsePath(type),
+        body: {
+            ...browserBaseBody(),
+            virtualType: 'ALL',
+            cmd: 'list',
+            current: 1,
+            pageSize,
+            companyId: virtualId,
+            formDatas: {
+                name: [{
+                        nameCondition: {
+                            id: condition,
+                            content: condition === 'eq' ? '等于' : '包含',
+                            disabled: false,
+                        },
+                        name: keyword,
+                    }],
+            },
+            quickSearchDatas: {},
+            type: 'and',
+            stopDepartment: false,
+        },
+    });
+    const data = response?.data ?? {};
+    const rows = Array.isArray(data.data) ? data.data : [];
+    const reportedTotal = Number(data.total);
+    return {
+        type,
+        rows,
+        total: Number.isFinite(reportedTotal) ? reportedTotal : rows.length,
+    };
+}
+async function browseTypes(host, types, virtualId, keyword, condition, pageSize) {
+    return Promise.all(types.map((type) => browseOrg(host, type, virtualId, keyword, condition, pageSize)));
+}
+function exactRows(results, keyword) {
+    const normalized = normalizedName(keyword);
+    return results.map((result) => {
+        const rows = result.rows.filter((row) => normalizedName(row.name) === normalized);
+        return { ...result, rows, total: rows.length };
+    });
+}
+function totalMatches(results) {
+    return results.reduce((sum, result) => sum + Math.max(result.total, result.rows.length), 0);
+}
+function allRows(results) {
+    return results.flatMap((result) => result.rows.map((row) => ({ type: result.type, row })));
+}
+function resolvedFromMatches(results, explicitType) {
+    if (explicitType) {
+        const result = results[0];
+        const count = Math.max(result.total, result.rows.length);
+        return {
+            selected: count === 1 && result.rows[0] ? { type: result.type, row: result.rows[0] } : undefined,
+            alternatives: [],
+            ambiguous: count > 1,
+        };
+    }
+    const department = results.find((result) => result.type === 'department');
+    const subcompany = results.find((result) => result.type === 'subcompany');
+    const departmentCount = department ? Math.max(department.total, department.rows.length) : 0;
+    const subcompanyCount = subcompany ? Math.max(subcompany.total, subcompany.rows.length) : 0;
+    if (departmentCount === 1 && department?.rows[0]) {
+        return {
+            selected: { type: 'department', row: department.rows[0] },
+            alternatives: (subcompany?.rows ?? []).map((row) => ({ type: 'subcompany', row })),
+            ambiguous: false,
+        };
+    }
+    if (departmentCount > 1)
+        return { alternatives: [], ambiguous: true };
+    if (subcompanyCount === 1 && subcompany?.rows[0]) {
+        return { selected: { type: 'subcompany', row: subcompany.rows[0] }, alternatives: [], ambiguous: false };
+    }
+    return { alternatives: [], ambiguous: subcompanyCount > 1 };
+}
+function truncatedCandidates(results, maxCandidates, baseUrl, virtual) {
+    const candidateTotal = totalMatches(results);
+    const candidates = allRows(results)
+        .slice(0, maxCandidates)
+        .map(({ type, row }) => orgCandidate(row, type, baseUrl, virtual));
+    return {
+        candidates,
+        candidateTotal,
+        truncated: candidateTotal > candidates.length,
+    };
+}
+async function resolveOrgId(host, orgId, baseUrl, virtual) {
+    const response = await host.request({
+        method: 'GET',
+        path: ORG_DETAIL_PATH,
+        query: { id: orgId, readOnly: true, includeSub: true, quote: true, isMobile: false },
+        headers: { Referer: `${baseUrl}/sp/hrm/orgCard/${orgId}` },
+    });
+    const raw = response?.data?.data ?? {};
+    const type = raw.type === 'subcompany' ? 'subcompany' : 'department';
+    const parentName = Array.isArray(raw.parent) ? text(raw.parent[0]?.name) : '';
+    const subcompanyName = Array.isArray(raw.subcompany) ? text(raw.subcompany[0]?.name) : '';
+    const fullPath = normalizePath(raw.fullPath);
+    const pathParts = fullPath.split('/').filter(Boolean);
+    return {
+        id: text(raw.id) || orgId,
+        name: text(raw.name),
+        type,
+        ...(text(raw.code) ? { code: text(raw.code) } : {}),
+        ...(fullPath ? { fullPath } : {}),
+        ...(pathParts.length > 1 ? { parentPath: pathParts.slice(0, -1).join('/') } : {}),
+        ...(parentName ? { parentName } : {}),
+        ...(subcompanyName ? { subcompanyName } : {}),
+        virtualId: virtual.id,
+        virtualName: virtual.name,
+        ...(raw.status !== undefined ? { status: raw.status } : {}),
+        link: orgLink(baseUrl, orgId),
+    };
+}
+function relaxedKeywords(name) {
+    const characters = [...text(name)];
+    if (characters.length <= 2)
+        return [characters.join('')].filter(Boolean);
+    const suffix = characters.slice(-2).join('');
+    const prefix = characters.slice(0, 2).join('');
+    return suffix === prefix ? [suffix] : [suffix, prefix];
+}
+async function nearOrgSuggestions(host, type, virtual, name, pageSize, baseUrl) {
+    const results = [];
+    const seen = new Set();
+    for (const keyword of relaxedKeywords(name)) {
+        const result = await browseOrg(host, type, virtual.id, keyword, 'in', pageSize);
+        for (const row of result.rows) {
+            const id = text(row.id);
+            if (!id || seen.has(id))
+                continue;
+            seen.add(id);
+            results.push(orgCandidate(row, type, baseUrl, virtual));
+        }
+    }
+    return results;
+}
+const orgResolve = {
+    name: 'hrm.org.resolve',
+    resource: 'org',
+    method: 'org.resolve',
+    action: 'hrm.org.resolve',
+    summary: '按多维名称与组织名称解析唯一部门/分部；歧义或近似名称只返回候选，不代替用户选择',
+    risk: READ,
+    inputSchema: schemaOf({
+        virtual: { type: 'string', minLength: 1, description: '多维名称；与 virtualId 至少传一个' },
+        virtualId: SCHEMA_ID,
+        name: { type: 'string', minLength: 1, description: '组织名称；与 orgId 至少传一个' },
+        orgId: SCHEMA_ID,
+        type: { type: 'string', enum: [...ORG_TYPES] },
+        maxCandidates: { type: 'integer', minimum: 1, maximum: MAX_CANDIDATES, default: DEFAULT_MAX_CANDIDATES },
+    }),
+    handler: async (args, { host }) => {
+        const virtualKeyword = text(args.virtual);
+        const name = text(args.name);
+        const virtualId = args.virtualId === undefined ? '' : idValue(args.virtualId, 'virtualId');
+        const orgId = args.orgId === undefined ? '' : idValue(args.orgId, 'orgId');
+        if (!virtualKeyword && !virtualId) {
+            throw hrmValidationError('virtual_required', 'virtual 或 virtualId 至少传一个');
+        }
+        if (!name && !orgId) {
+            throw hrmValidationError('name_required', 'name 或 orgId 至少传一个');
+        }
+        const explicitType = args.type !== undefined;
+        const requestedType = explicitType ? text(args.type) : '';
+        if (explicitType && !ORG_TYPES.includes(requestedType)) {
+            throw hrmValidationError('enum_invalid', `type 取值必须是 ${ORG_TYPES.join(' / ')} 之一`);
+        }
+        const types = explicitType
+            ? [requestedType]
+            : ['department', 'subcompany'];
+        const maxCandidates = maxCandidatesValue(args.maxCandidates);
+        const pageSize = Math.max(100, maxCandidates);
+        const virtualResponse = await host.request({ method: 'GET', path: VIRTUAL_PATH });
+        const virtuals = readVirtuals(virtualResponse);
+        let virtual;
+        let virtualMatchType = 'exact';
+        if (virtualId) {
+            virtual = virtuals.find((item) => item.id === virtualId);
+            virtualMatchType = 'id';
+        }
+        else {
+            const keyword = normalizedName(virtualKeyword);
+            const exact = virtuals.filter((item) => normalizedName(item.name) === keyword);
+            const matches = exact.length > 0
+                ? exact
+                : virtuals.filter((item) => normalizedName(item.name).includes(keyword));
+            virtualMatchType = exact.length > 0 ? 'exact' : 'fuzzy';
+            if (matches.length > 1) {
+                const candidates = matches.slice(0, maxCandidates);
+                return hrmSuccess('hrm.org.resolve', {
+                    status: 'ambiguous',
+                    stage: 'virtual',
+                    virtual: null,
+                    matchType: virtualMatchType,
+                    candidates,
+                    candidateTotal: matches.length,
+                    truncated: matches.length > candidates.length,
+                    message: `多维「${virtualKeyword}」匹配到 ${matches.length} 个候选，请确认后把候选 id 作为 virtualId 复调。`,
+                });
+            }
+            virtual = matches[0];
+        }
+        if (!virtual) {
+            const suggestions = virtualKeyword ? nearVirtuals(virtualKeyword, virtuals) : [];
+            const available = virtuals.map((item) => item.name).join('、');
+            const target = virtualId ? `ID ${virtualId}` : `「${virtualKeyword}」`;
+            const suggestionText = suggestions.length > 0
+                ? `；近似名称：${suggestions.map((item) => item.name).join('、')}。不要自行替换名称，请先让用户确认`
+                : '';
+            return hrmSuccess('hrm.org.resolve', {
+                status: 'not_found',
+                stage: 'virtual',
+                virtual: null,
+                matchType: 'none',
+                candidates: [],
+                candidateTotal: 0,
+                suggestions,
+                suggestionTotal: suggestions.length,
+                availableVirtuals: virtuals,
+                message: `多维${target}不存在${suggestionText}。当前可用多维：${available || '无'}。`,
+            });
+        }
+        const virtualResult = {
+            id: virtual.id,
+            name: virtual.name,
+            keyword: virtualKeyword,
+            matchType: virtualMatchType,
+        };
+        const session = await host.getSession();
+        const baseUrl = session.baseUrl.replace(/\/+$/u, '');
+        if (orgId) {
+            const org = await resolveOrgId(host, orgId, baseUrl, virtual);
+            return hrmSuccess('hrm.org.resolve', {
+                status: 'resolved',
+                stage: 'org',
+                matchType: 'id',
+                type: org.type,
+                virtual: virtualResult,
+                org,
+                message: `已按 orgId 定位组织「${String(org.name || orgId)}」。`,
+            });
+        }
+        let matchType = 'exact';
+        let matches = await browseTypes(host, types, virtual.id, name, 'eq', pageSize);
+        let choice = resolvedFromMatches(matches, explicitType);
+        if (!choice.selected && !choice.ambiguous) {
+            const fuzzyResults = await browseTypes(host, types, virtual.id, name, 'in', pageSize);
+            const normalizedExact = exactRows(fuzzyResults, name);
+            if (totalMatches(normalizedExact) > 0) {
+                matches = normalizedExact;
+                matchType = 'exact';
+            }
+            else {
+                matches = fuzzyResults;
+                matchType = 'fuzzy';
+            }
+            choice = resolvedFromMatches(matches, explicitType);
+        }
+        if (choice.selected) {
+            const org = fullOrg(choice.selected.row, choice.selected.type, baseUrl, virtual);
+            const alsoMatched = choice.alternatives.map(({ type, row }) => orgCandidate(row, type, baseUrl, virtual));
+            const fuzzyMessage = matchType === 'fuzzy' ? '（模糊匹配）' : '';
+            const alternativeMessage = alsoMatched.length > 0
+                ? `；另有同名节点 ${alsoMatched.length} 个，请一并告知用户`
+                : '';
+            return hrmSuccess('hrm.org.resolve', {
+                status: 'resolved',
+                stage: 'org',
+                matchType,
+                type: choice.selected.type,
+                virtual: virtualResult,
+                org,
+                ...(alsoMatched.length > 0 ? { alsoMatched } : {}),
+                message: `已${fuzzyMessage}定位${choice.selected.type === 'department' ? '部门' : '分部'}「${name}」${alternativeMessage}。`,
+            });
+        }
+        if (choice.ambiguous) {
+            const candidateData = truncatedCandidates(matches, maxCandidates, baseUrl, virtual);
+            const truncatedMessage = candidateData.truncated ? `，仅列出前 ${maxCandidates} 个` : '';
+            return hrmSuccess('hrm.org.resolve', {
+                status: 'ambiguous',
+                stage: 'org',
+                matchType,
+                virtual: virtualResult,
+                ...candidateData,
+                message: `组织「${name}」匹配到 ${candidateData.candidateTotal} 个候选${truncatedMessage}，请确认后把候选 id 作为 orgId 复调。`,
+            });
+        }
+        // 名称的精确/包含查询均未命中。近似探测只用于提示，绝不自动解析。
+        const suggestionType = (requestedType || 'department');
+        const allSuggestions = await nearOrgSuggestions(host, suggestionType, virtual, name, pageSize, baseUrl);
+        const suggestions = allSuggestions.slice(0, MAX_SUGGESTIONS);
+        const suggestionMessage = suggestions.length > 0
+            ? `；找到近似名称 ${suggestions.map((item) => item.name).join('、')}，不要自行替换名称，请先让用户确认`
+            : '';
+        return hrmSuccess('hrm.org.resolve', {
+            status: 'not_found',
+            stage: 'org',
+            matchType: 'none',
+            virtual: virtualResult,
+            suggestions,
+            suggestionTotal: allSuggestions.length,
+            message: `在多维「${virtual.name}」中未找到组织「${name}」${suggestionMessage}。`,
+        });
+    },
+};
+export const hrmResolveOperations = [orgResolve];

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'),