weaver-work-cli 0.1.23 → 0.1.25

package/dist/shortcuts/caizhilian/operations/handlers/setting-attach.js

@@ -14,6 +14,7 @@
 import { CaizhilianCliError, caizhilianValidationError } from '../../errors.js';
 import { issueWriteLease } from '../confirm.js';
 import { caizhilianSuccess } from '../types.js';
+import { hasNextPage, parsePage, requireNonEmpty } from '../shared.js';
 const ACTION = 'caizhilian.setting-attach';
 // ── 接口路径 ──────────────────────────────────────────────
 const GET_PATH = '/api/file/tenant/setting';
@@ -282,10 +283,207 @@ async function listWorkflowsByFolders(args, env) {
         total: workflows.length,
     });
 }
+// ── 获取流程上传目录设置 ──────────────────────────────────────────
+/** 源 workflow_plugins._MODULE_MAP：模块类型 → 路径/参数映射。 */
+const MODULE_MAP = {
+    workflow: { module: 'workflow', apiModule: 'workflow/core', basePath: '/api/workflow/core/form/setting/attachment' },
+    ebuilder: { module: 'ebuildercard', apiModule: 'ebuilder/flow', basePath: '/api/ebuilder/flow/form/setting/attachment' },
+};
+function resolveModuleInfo(module) {
+    return MODULE_MAP[module] ?? { module, apiModule: 'workflow/core', basePath: '/api/workflow/core/form/setting/attachment' };
+}
+function nestedValue(root, path) {
+    let current = root;
+    for (const segment of path.split('.')) {
+        if (current === null || current === undefined || typeof current !== 'object')
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+async function listUploadFolders(args, env) {
+    const action = 'caizhilian.setting-attach.list-upload-folders';
+    const workflowId = requireNonEmpty(args.workflow_id, 'workflow_id 不能为空');
+    // ── Step 1: 查询表单信息并解析模块映射 ──
+    const formResponse = await env.host.request({
+        method: 'GET',
+        path: '/api/bs/workflow/pathdef/baseSet/getEditForm',
+        query: { isCreate: '0', belongType: '1', workflowId },
+        operation: action,
+    });
+    const formData = asRecord(formResponse);
+    const formList = nestedValue(formData, 'data.data.formId');
+    if (!Array.isArray(formList) || formList.length === 0) {
+        throw caizhilianValidationError('workflow_not_found', '未找到该流程对应的表单信息', { workflow_id: workflowId });
+    }
+    const firstForm = asRecord(formList[0]);
+    const formId = String(firstForm.id ?? '').trim();
+    if (!formId) {
+        throw caizhilianValidationError('form_id_not_found', '未找到表单 ID', { workflow_id: workflowId });
+    }
+    const formModule = String(firstForm.module ?? '');
+    const moduleInfo = resolveModuleInfo(formModule);
+    // ── Step 2 + Step 3: 并行查询通用设置和附件字段列表 ──
+    const [commonResponse, fieldsResponse] = await Promise.all([
+        env.host.request({
+            method: 'POST',
+            path: `${moduleInfo.basePath}/getWeaFormAndData`,
+            body: { formId, type: 'common', module: moduleInfo.module, apiModule: moduleInfo.apiModule },
+            operation: action,
+        }),
+        env.host.request({
+            method: 'POST',
+            path: `${moduleInfo.basePath}/listAttachFields`,
+            body: { formId, apiModule: moduleInfo.apiModule, module: moduleInfo.module },
+            operation: action,
+        }),
+    ]);
+    const seen = new Map();
+    // 收集通用设置中的文件夹
+    const commonItems = nestedValue(asRecord(commonResponse), 'data.folderIdBrowserValue');
+    if (Array.isArray(commonItems)) {
+        for (const item of commonItems) {
+            if (!isPlainObject(item))
+                continue;
+            const fid = String(item.id ?? '').trim();
+            if (!fid)
+                continue;
+            const existing = seen.get(fid);
+            if (existing) {
+                existing.sources.push({ type: 'common_setting' });
+            }
+            else {
+                seen.set(fid, {
+                    id: fid,
+                    name: String(item.content ?? ''),
+                    path: String(item.title ?? ''),
+                    sources: [{ type: 'common_setting' }],
+                });
+            }
+        }
+    }
+    // ── Step 4: 并行查询每个附件字段的文件夹设置（仅 folderType=1）──
+    const fieldsData = asRecord(fieldsResponse);
+    const fieldList = Array.isArray(fieldsData.data) ? fieldsData.data : [];
+    const fieldRequests = [];
+    for (const field of fieldList) {
+        if (!isPlainObject(field))
+            continue;
+        const fieldId = String(field.fieldId ?? '').trim();
+        if (!fieldId)
+            continue;
+        if (String(field.folderType ?? '') !== '1')
+            continue;
+        fieldRequests.push({
+            meta: { fieldId, fieldName: String(field.fieldName ?? '') },
+            request: env.host.request({
+                method: 'POST',
+                path: `${moduleInfo.basePath}/getWeaFormAndData`,
+                body: { formId, type: 'folder', fieldId, module: moduleInfo.module, apiModule: moduleInfo.apiModule },
+                operation: action,
+            }),
+        });
+    }
+    if (fieldRequests.length > 0) {
+        const results = await Promise.allSettled(fieldRequests.map((r) => r.request));
+        for (let i = 0; i < fieldRequests.length; i++) {
+            const result = results[i];
+            if (result.status === 'rejected')
+                continue; // 单个字段失败不影响其他
+            const fieldFolderData = asRecord(result.value);
+            const fieldFolderItems = nestedValue(fieldFolderData, 'data.folderIdBrowserValue');
+            if (!Array.isArray(fieldFolderItems))
+                continue;
+            for (const item of fieldFolderItems) {
+                if (!isPlainObject(item))
+                    continue;
+                const fid = String(item.id ?? '').trim();
+                if (!fid)
+                    continue;
+                const source = {
+                    type: 'field',
+                    field_id: fieldRequests[i].meta.fieldId,
+                    field_name: fieldRequests[i].meta.fieldName,
+                };
+                const existing = seen.get(fid);
+                if (existing) {
+                    existing.sources.push(source);
+                }
+                else {
+                    seen.set(fid, {
+                        id: fid,
+                        name: String(item.content ?? ''),
+                        path: String(item.title ?? ''),
+                        sources: [source],
+                    });
+                }
+            }
+        }
+    }
+    return caizhilianSuccess(action, {
+        workflow_id: workflowId,
+        folders: [...seen.values()],
+    });
+}
+// ── caizhilian.setting-attach.search-workflows ────────────
+const SEARCH_WORKFLOWS_ACTION = 'caizhilian.setting-attach.search-workflows';
+const SEARCH_WORKFLOWS_PATH = '/api/bs/workflow/pathdef/baseSet/getBaseInfoList';
+/** 源 SearchWorkflowsPlugin.execute（search_plugins.py）：按流程名称模糊搜索审批流程。 */
+async function searchWorkflows(args, env) {
+    const action = SEARCH_WORKFLOWS_ACTION;
+    // 源：keyword 自动去除首尾空格；不传、传空或纯空格则返回全部流程
+    const keyword = args.keyword === undefined || args.keyword === null ? '' : String(args.keyword).trim();
+    const { pageNo, pageSize } = parsePage(args, 100);
+    const body = {
+        searchParams: {
+            searchDatas: {
+                workflowNameCondition: 'in',
+                workflowTypeCondition: 'in',
+                formType: 'all',
+                formCondition: 'in',
+                status: '0',
+                type: 'and',
+            },
+            quickSearchDatas: { workflowName: keyword },
+            otherSearchDatas: { workflowType: '', workflowId: '', subCompanyId: '' },
+        },
+        isTemplate: 0,
+        belongType: 1,
+        current: pageNo,
+        pageSize,
+    };
+    const response = await env.host.request({
+        method: 'POST',
+        path: SEARCH_WORKFLOWS_PATH,
+        body,
+        operation: action,
+    });
+    const rawList = nestedValue(asRecord(response), 'data.data');
+    const items = Array.isArray(rawList) ? rawList : [];
+    const workflows = [];
+    for (const item of items) {
+        if (!isPlainObject(item))
+            continue;
+        workflows.push({
+            id: String(item.id ?? ''),
+            workflowName: item.workflowName ?? '',
+            typeName: item.typeName ?? '',
+        });
+    }
+    return caizhilianSuccess(action, {
+        page_no: pageNo,
+        page_size: pageSize,
+        // 服务端 hasMore 不随请求 pageSize 变化（按固定 100 计算），与源一致以本页返回数量判断
+        has_next: hasNextPage(items, pageSize),
+        workflows,
+    });
+}
 // ── 处理器汇总 ────────────────────────────────────────────
 export const caizhilianSettingAttachHandlers = {
     'caizhilian.setting-attach.get': { execute: getSettingAttach },
     'caizhilian.setting-attach.list-workflows-by-folders': { execute: listWorkflowsByFolders },
+    'caizhilian.setting-attach.list-upload-folders': { execute: listUploadFolders },
+    'caizhilian.setting-attach.search-workflows': { execute: searchWorkflows },
     'caizhilian.setting-attach.set': {
         prepare: setSettingAttachPrepare,
         apply: setSettingAttachApply,

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

@@ -65,7 +65,10 @@ function prepareDefinition(spec, entry) {
         summary: `${spec.summary}｜prepare：只读校验与请求体预览，签发 apply 所需的 continuation，不产生副作用`,
         risk: 'read-before-write',
         requiresConfirmation: true,
-        handler: (args, env) => entry.prepare(args, env),
+        handler: (args, env) => {
+            entry.validateInput?.(args);
+            return entry.prepare(args, env);
+        },
     };
 }
 /**
@@ -83,6 +86,7 @@ function applyDefinition(spec, entry) {
         requiresConfirmation: true,
         inputSchema: applySchemaOf(spec.inputSchema, base.required ?? []),
         handler: async (args, env) => {
+            entry.validateInput?.(args);
             const lease = await verifyLease(args, name, env);
             assertLeaseArgs(lease, args, name);
             assertLeaseTarget(lease, args, entry.targetKeys ?? [], name);

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

@@ -191,6 +191,38 @@ export function timestampToDateStr(tsMs, fallback = '') {
         return fallback;
     return formatDateTimeMs(parsed + CN_TZ_OFFSET_MS, true);
 }
+/**
+ * 附件历史版本 updateTime 兼容转换（源为毫秒时间戳，但需兼容秒级时间戳与已格式化字符串）：
+ * - 数值/数字串 >= 1e12 → 视为毫秒时间戳；
+ * - 1e9 <= 数值 < 1e12 → 视为秒时间戳，×1000 后转换；
+ * - 已是 'YYYY-MM-DD…' 形态的字符串 → 原样透传；
+ * - 其它无法识别的值 → 原样转为字符串透传（不丢信息）。
+ */
+export function formatVersionTimestamp(value) {
+    if (value === undefined || value === null || value === '')
+        return '';
+    if (typeof value === 'number') {
+        if (value >= 1e12)
+            return timestampToDateStr(value, String(value));
+        if (value >= 1e9)
+            return timestampToDateStr(value * 1000, String(value));
+        return String(value);
+    }
+    const text = String(value).trim();
+    if (text === '')
+        return '';
+    if (/^\d{4}-\d{2}-\d{2}/u.test(text))
+        return text;
+    if (/^-?\d+$/u.test(text)) {
+        const parsed = Number(text);
+        if (parsed >= 1e12)
+            return timestampToDateStr(parsed, text);
+        if (parsed >= 1e9)
+            return timestampToDateStr(parsed * 1000, text);
+        return text;
+    }
+    return text;
+}
 function formatDateTimeMs(shiftedMs, withSeconds) {
     const t = new Date(shiftedMs);
     const date = `${t.getUTCFullYear()}-${pad(t.getUTCMonth() + 1)}-${pad(t.getUTCDate())}`;

package/dist/shortcuts/caizhilian/operations/specs.js

@@ -271,6 +271,8 @@ export const caizhilianOperationSpecs = [
         position_attribute: LIST('岗位属性'),
         position_level_department: LIST('岗位层级-部门'),
         position_level_subcompany: LIST('岗位层级-分部'),
+        seclevel_min: INT('密级下限，范围 -999~999', { minimum: -999, maximum: 999 }),
+        seclevel_max: INT('密级上限，范围 -999~999', { minimum: -999, maximum: 999 }),
     }, ['folder_id', 'permission_type', 'obj_type'], { requiresConfirmation: true }),
     spec('folder', 'permission.delete', 'delete_folder_permission', 'high-risk-write', '删除文件夹文档权限设置', {
         folder_id: ID('文件夹 ID'),
@@ -309,6 +311,50 @@ export const caizhilianOperationSpecs = [
     spec('folder', 'permission.sync-setting', 'sync_folder_setting_permission', 'high-risk-write', '将当前文件夹的"管理员"权限设置同步到下级子文件夹', {
         id: ID('文件夹 ID'),
         keepOldSettingForAllFolders: BOOL('是否保留原有管理员设置（true=保留，false=不保留）'),
+    }, ['id', 'keepOldSettingForAllFolders'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-maintain', 'sync_folder_maintain_permission', 'high-risk-write', '将当前文件夹的"文件夹维护"权限设置同步到下级子文件夹', {
+        id: ID('文件夹 ID'),
+        keepOldSettingForAllFolders: BOOL('是否保留原有文件夹维护设置（true=保留，false=不保留）'),
+    }, ['id', 'keepOldSettingForAllFolders'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-download', 'sync_folder_download_permission', 'high-risk-write', '将当前文件夹的"下载权限"设置同步到下级子文件夹', {
+        id: ID('文件夹 ID'),
+        keepOldSettingForAllFolders: BOOL('是否保留原有下载权限设置（true=保留，false=不保留）'),
+    }, ['id'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-delete', 'sync_folder_delete_permission', 'high-risk-write', '将当前文件夹的"删除权限"设置同步到下级子文件夹', {
+        id: ID('文件夹 ID'),
+        keepOldSettingForAllFolders: BOOL('是否保留原有删除权限设置（true=保留，false=不保留）'),
+    }, ['id'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-copy', 'sync_folder_copy_permission', 'high-risk-write', '将当前文件夹的"复制权限"设置同步到下级子文件夹', {
+        id: ID('文件夹 ID'),
+        keepOldSettingForAllFolders: BOOL('是否保留原有复制权限设置（true=保留，false=不保留）'),
+    }, ['id', 'keepOldSettingForAllFolders'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-create', 'sync_folder_create_permission', 'high-risk-write', '将当前文件夹的"新建文档权限"设置同步到下级子文件夹', {
+        id: ID('文件夹 ID'),
+        keepOldSettingForAllFolders: BOOL('是否保留原有新建文档权限设置（true=保留，false=不保留）'),
+    }, ['id', 'keepOldSettingForAllFolders'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-move', 'sync_folder_move_permission', 'high-risk-write', '将当前文件夹的"移动权限"设置同步到下级子文件夹', {
+        id: ID('文件夹 ID'),
+        keepOldSettingForAllFolders: BOOL('是否保留原有移动权限设置（true=保留，false=不保留）'),
+    }, ['id', 'keepOldSettingForAllFolders'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-participant', 'sync_folder_participant', 'high-risk-write', '将当前文件夹的"默认参与人"设置同步到下级子文件夹或历史文档', {
+        id: ID('文件夹 ID'),
+        sync_to_folder_docs: BOOL('是否同步到当前文件夹内的历史文档'),
+        sync_to_all_folders: BOOL('是否同步到所有下级文件夹'),
+        sync_to_all_sub_folder_docs: BOOL('是否同步到所有下级文件夹内的历史文档'),
+        keep_old_for_folder_docs: BOOL('原有参与人是否保留（同步到历史文档时）', { default: true }),
+        keep_old_for_all_folders: BOOL('原有参与人是否保留（同步到下级文件夹时）', { default: true }),
+        keep_old_for_all_sub_folder_docs: BOOL('原有参与人是否保留（同步到下级文件夹历史文档时）', { default: true }),
+    }, ['id'], { requiresConfirmation: true }),
+    spec('folder', 'permission.sync-default-share', 'sync_folder_default_share', 'high-risk-write', '将当前文件夹的"默认共享人"设置同步到下级子文件夹或历史文档', {
+        id: ID('文件夹 ID'),
+        sync_to_folder_docs: BOOL('是否同步到当前文件夹内的历史文档'),
+        sync_to_all_folders: BOOL('是否同步到所有下级文件夹'),
+        sync_to_all_sub_folder_docs: BOOL('是否同步到所有下级文件夹内的历史文档'),
+        keep_old_default_share_for_folder_docs: BOOL('原有默认共享人是否保留（同步到历史文档时）', { default: true }),
+        keep_old_non_default_share_for_folder_docs: BOOL('原有非默认共享人是否保留（同步到历史文档时）', { default: true }),
+        keep_old_default_share_for_all_folders: BOOL('原有默认共享人是否保留（同步到下级文件夹时）', { default: true }),
+        keep_old_default_share_for_sub_folder_docs: BOOL('原有默认共享人是否保留（同步到下级文件夹历史文档时）', { default: true }),
+        keep_old_non_default_share_for_sub_folder_docs: BOOL('原有非默认共享人是否保留（同步到下级文件夹历史文档时）', { default: true }),
     }, ['id'], { requiresConfirmation: true }),
     // ── setting-attach ──────────────────────────────────────
     spec('setting-attach', 'get', 'get_setting_attach', 'read', '读取附件设置（文件设置 → 附件设置）', {}, [], {
@@ -319,6 +365,16 @@ export const caizhilianOperationSpecs = [
     }, ['folder_ids'], {
         method: 'http_template',
     }),
+    spec('setting-attach', 'list-upload-folders', 'fetch_workflow_upload_folder', 'read', '获取指定审批流程的附件上传目录设置（源 fetch_workflow_upload_folder）', {
+        workflow_id: ID('审批流程 ID'),
+    }, ['workflow_id']),
+    spec('setting-attach', 'search-workflows', 'search_workflows', 'read', '按名称模糊搜索审批流程（源 search_workflows）', {
+        keyword: S('流程名称搜索词，模糊匹配；不传或空白返回全部流程'),
+        name: S('旧字段别名，等价 keyword（已废弃，与 keyword 同时出现且取值不一致会报 alias_conflict）'),
+        ...pageProps(100),
+    }, [], {
+        deprecatedInputAliases: { keyword: ['name'] },
+    }),
     spec('setting-attach', 'set', 'set_setting_attach', 'high-risk-write', '保存附件设置（只改指定字段，未指定字段透传原值）', {
         items: {
             type: 'object',
@@ -544,11 +600,17 @@ export const caizhilianOperationSpecs = [
     spec('file-upload', 'prepare', 'prepare_upload', 'read', '准备上传（本地文件校验与元数据）', {
         file_path: FILE('本地文件绝对路径'),
         module: S('业务模块（如 document、workflow 等）'),
+        context_file: FILE('可选业务上下文 JSON 文件绝对路径（最大 64 KiB）'),
+        chat_id: S('宿主对话标识，用于隔离上传回执；默认 cli'),
+        timeout_seconds: INT('上传超时秒数（1–3600，默认 300）', { minimum: 1, maximum: 3600, default: 300 }),
     }, ['file_path', 'module']),
     spec('file-upload', 'upload', 'upload_file', 'high-risk-write', '上传文件到文件服务', {
         file_path: FILE('本地文件绝对路径'),
         module: S('业务模块（如 document、workflow 等）'),
         user_confirmed: BOOL('用户已确认上传'),
+        context_file: FILE('可选业务上下文 JSON 文件绝对路径（最大 64 KiB）'),
+        chat_id: S('宿主对话标识，用于隔离上传回执；默认 cli'),
+        timeout_seconds: INT('上传超时秒数（1–3600，默认 300）', { minimum: 1, maximum: 3600, default: 300 }),
     }, ['file_path', 'module', 'user_confirmed'], { requiresConfirmation: true }),
     // ── org ─────────────────────────────────────────────────
     spec('org', 'search-user', 'search_user', 'read', '人员浏览器检索（源 search_user → /api/hrm/common/browser/data/resource）', {
@@ -659,6 +721,11 @@ export const caizhilianOperationSpecs = [
         doc_id: ID('文档 ID'),
         save_path: FILE('保存路径（完整文件路径或目录）'),
     }, ['attachment_id', 'doc_id']),
+    spec('attachment', 'list-versions', 'find_version_list', 'read', '按附件 ID 查询附件历史版本（源 filePreview 历史版本抽屉接口）', {
+        attachment_id: ID('附件 ID'),
+        doc_id: ID('文档 ID（可选，不传时发空串）'),
+        ...pageProps(10),
+    }, ['attachment_id'], { method: 'http_template' }),
     // ── cover ───────────────────────────────────────────────
     spec('cover', 'upload', 'upload_cover_image', 'read-with-upload', '上传封面图片，仅返回 file_id（不改文档）', {
         file_path: FILE('本地图片路径（.png/.jpg/.jpeg/.gif/.webp/.bmp）'),

package/dist/shortcuts/workflow/continuation.js

@@ -189,15 +189,20 @@ export function continuationReplayError(replay, expectedOperation) {
         return workflowAlreadyAppliedError(operation, replay);
     }
     if (replay.state === 'saving') {
-        // 写入请求已发出但结果未知：一律按"结果不确定"处理（先只读核对，禁止重复提交）。
-        // 恢复路径按命令形态分述：单命令（batchSubmit）没有 Prepare 可重跑，只能等幂等窗口过去后原样重跑。
-        const recovery = /Apply$/u.test(operation)
-            ? '确认未生效后再重跑对应的 Prepare 获取新句柄。'
-            : '确认未生效后，等本次写入的幂等保护窗口过去（约 1 分钟）再原样重跑同一条命令（同一批 requestId 在窗口内会被拦住）。';
-        return workflowPartialError('该 continuation 对应的上一次执行**已经发出写入请求，但结果未确认**（进程被中止或回执丢失），'
-            + '本次未执行、也不要重复提交。请先只读核对（如 workflow.search --category done --requestId <目标ID>'
-            + '，或 workflow.search --category mine 看是否已出现目标条目）确认真实状态，'
-            + recovery, replay, { stage: 'continuation_replay', ...replay });
+        // 写入请求已发出但结果未知：一律按"结果不确定"处理，**本次不执行、也不重放**。
+        //
+        // 恢复路径按**句柄形态**分述，且**不再出现"等一会儿原样重跑"**——`createForm` 签发的
+        // `wc-` 句柄是没有幂等窗口的（`consume` 不传 `ttlMs`，一次性且永久），"等约 1 分钟再跑"
+        // 对它是结构性无效的死路（2026-09-28 用户裁定改写）。批量写侧虽有 60s 确定性键窗口，
+        // 但同样不该由模型自动重跑。
+        const recovery = operation === 'workflow.createForm'
+            ? '要重新发起，请**重新执行 workflow.createForm 获取新句柄**（本次句柄已消费，重发同一句柄无效）。'
+            : /Apply$/u.test(operation)
+                ? '确认未生效后，重跑对应的 Prepare 获取新句柄。'
+                : '该命令没有可重跑的 Prepare，也**不要原样重跑**；请把结果如实告知用户。';
+        return workflowPartialError('该 continuation 对应的上一次执行**已经发出写入请求，但结果未确认**（进程被中止或回执丢失），本次未执行。'
+            + '**请把"上一次结果未确认"如实告知用户并停下，不要自行继续**'
+            + '（不要重试、不要改用其它命令反复推断、不要替用户下结论）。' + recovery, replay, { stage: 'continuation_replay', ...replay });
     }
     if (replay.state === 'claimed') {
         // 只抢到句柄、未发出任何写入：并发的另一次执行正在占用，等它结束再重试即可。

package/dist/shortcuts/workflow/endpoints.js

@@ -124,10 +124,20 @@ export const FORM_ENDPOINTS = {
     create: '/api/workflow/core/flow/create',
     /** 提交（复用查询侧同一路径） */
     submit: '/api/workflow/core/paService/v1/submitRequest',
-    /** 节点符合性校验 */
+    /**
+     * 节点字段校验的**第一跳**：轻量预检。
+     *
+     * 服务端只回一个布尔（是否需要把校验结果弹给用户），据此决定要不要再去取详细规则集
+     * （`conformanceSet` + `verificationConditionRule`）。开关 `passPopUpPrompt`/`noPassPrompt`
+     * 都为真时前端**不调**本接口，直接取详细规则集（2026-09-28 双 HAR 实证）。
+     */
+    verifyNodeFieldByList: '/api/workflow/core/verification/verifyNodeFieldByList',
+    /** 节点符合性校验（详细规则集，仅在需要展示校验结果时才取） */
     conformanceSet: '/api/bs/workflow/pathdef/nodeConformance/getConformanceSetByVerification',
     verificationRequestData: '/api/workflow/core/verification/getRequestDataByRequestId',
     verificationConditionRule: '/api/bs/workflow/pathdef/nodeConformance/verificationConditionRule',
+    /** 提交已创建的流程（创建后页面重载拿到 view 页鉴权再提交，与真机同路径） */
+    flowSubmit: '/api/workflow/core/flow/submit',
     /** 租户级文件上传设置（单文件大小上限 + 格式黑白名单） */
     tenantSetting: '/api/file/tenant/setting',
 };

package/dist/shortcuts/workflow/index.js

@@ -5,6 +5,7 @@ import { createWorkflowHost } from './host.js';
 import { workflowManifest } from './manifest.js';
 import { executeWorkflowOperation } from './operations.js';
 import { workflowValidationError } from './errors.js';
+import { compactStdoutPaths } from './stdout-compact.js';
 function asOptions(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
@@ -73,6 +74,59 @@ function failureEnvelope(error) {
         error: toErrorEnvelope(error),
     };
 }
+/**
+ * 紧凑路径的**声明**在 `stdout-compact.ts`：`operations/form.ts` 判线时要用同一份路径
+ * （它量的必须是最终打出去的那份文本），常量留在本文件会让 `form.ts` 反向 import，
+ * 与 `index → operations → form` 形成循环依赖。本文件只把查询函数转发出去。
+ */
+export { compactStdoutPaths };
+/**
+ * 「stdout 整体直出」的判定 —— 目前**只有小e 环境的 `BROWSER_FILL` 一档**适用。
+ *
+ * 用户 2026-10-15 裁定：「xiaoe 下应该直接输出 `<browsertool>` 标签」。即该档的 stdout **就是**
+ * 那段标签块本身，**不再套** `{schemaVersion, ok, operation, data, warnings}` 信封 —— 于是
+ * `workflow-create.md` 里「返回内容以 `<browsertool>` 开头 ⇒ 原样输出」这句是**字面成立**的。
+ * 代价（用户已知悉并接受）：这一档模型拿不到 `status` / `contextId`（本档不写服务端、句柄也未消费，
+ * 需要重发时由用户重新发起即可）。
+ *
+ * 两个条件必须同时成立，缺一就退回信封 —— 宁可不直出，也不让调用方拿到半截或空输出：
+ * - `data.status === 'BROWSER_FILL'`：小e 专用档，其它状态（含 `NEEDS_INPUT`）一律维持信封；
+ * - `data.finalMarkdown` 以 `<browsertool>` 开头：与文档口径同字面，渲染档万一变了也不会直出一个
+ *   看起来像标签、实际不是的东西。
+ *
+ * 必须走 `ctx.output.raw()` 而不是 `write(value, { text })`：后者在**全局 `--json`** 下仍会退化成
+ * JSON（`core/output.ts`：`useJson = globalOptions.json || options.json || !options.text`），
+ * 而本 skill 的文档一律带 `--json`。
+ */
+export function rawStdoutOf(result) {
+    const data = result.data;
+    if (!data || typeof data !== 'object')
+        return undefined;
+    if (data.status !== 'BROWSER_FILL')
+        return undefined;
+    const markdown = data.finalMarkdown;
+    if (typeof markdown !== 'string' || !markdown.startsWith('<browsertool>'))
+        return undefined;
+    return markdown;
+}
+/**
+ * 把一次 operation 的结果打到 stdout —— **形态二选一**（判定见 `rawStdoutOf`）。
+ *
+ * 独立成函数并**导出**，是为了让用例直接锁住这条接线（与 `compactStdoutPaths` 同一理由：
+ * 回归要在这里红，而不是等到真机上模型拿到一份"既不是 JSON、也不是标签块"的东西才发现）。
+ */
+export function printWorkflowResult(ctx, operation, result) {
+    const raw = rawStdoutOf(result);
+    if (raw !== undefined) {
+        // 小e：stdout 就是标签块本身 —— 不套信封、不进 `prepare()` 的超线落盘（这段本来就不长）。
+        ctx.output.raw(raw);
+        return;
+    }
+    ctx.output.write(successEnvelope(operation, result), {
+        json: true,
+        compactPaths: compactStdoutPaths(operation),
+    });
+}
 async function executeAndPrint(ctx, operation, input) {
     try {
         const result = await executeWorkflowOperation(operation, input, {
@@ -80,7 +134,7 @@ async function executeAndPrint(ctx, operation, input) {
             host: createWorkflowHost(ctx),
             continuation: createWorkflowContinuationSigner(ctx),
         });
-        ctx.output.write(successEnvelope(operation, result), { json: true });
+        printWorkflowResult(ctx, operation, result);
     }
     catch (error) {
         console.error(JSON.stringify(failureEnvelope(error), null, 2));

package/dist/shortcuts/workflow/operations/flow-status.js

@@ -0,0 +1,63 @@
+/**
+ * 流程状态（`flowstatus`）系统条件。
+ *
+ * ★ `flowstatus` 是**选项类**系统条件，服务端只认 `[{term, multiContent:[<代码>]}]`
+ *   —— **不是** `[{content, term}]`。`content` 形态是给"文本类"条件（requestname /
+ *   requestmark）用的；把取值塞进 `content`，服务端会**静默忽略**该条件
+ *   ⇒ 按流程状态筛选恒不生效、退化成全量。
+ *
+ *   来源对照：V11.3 `e10_workflow.py:8519 flow_status_condition` 产出的就是
+ *   `[{"term": "in", "multiContent": [...]}]`；V12.1 移植时退化成了 `[{content, term}]`
+ *   （2026-09-28 用户实测预期结构为 `[{"term":"in","multiContent":["notFinish","finish"]}]`）。
+ *
+ * ★★ 取值口径（2026-09-28 用户裁定＝方案 C）：**只认四个选项代码，不做中文口语词识别**。
+ *   说明层（schema 描述 / 报错文案 / `workflow-query.md` 的筛选条件表）已经列出四个代码及其
+ *   含义，"用户口语 → 代码"的翻译由**模型**完成；CLI 只做代码的校验与纯归一，且：
+ *   - 出现任何一个非代码取值 ⇒ **整体报错并停止**，不静默丢弃——丢掉一个取值就少一层筛选，
+ *     等于把结果静默放大到全量，与本项目"禁止静默丢条件"的纪律相悖；
+ *   - 大小写不敏感（`Finish` → `finish`）属纯归一，不做任何语义猜测。
+ */
+/** 服务端认可的流程状态选项（唯一定义处，说明文案由它派生，避免两处口径漂移）。 */
+const FLOW_STATUS_OPTIONS = [
+    { code: 'finish', meaning: '已结束' },
+    { code: 'normalFinish', meaning: '正常结束' },
+    { code: 'forceFinish', meaning: '强制结束' },
+    { code: 'notFinish', meaning: '未结束·审批中' },
+];
+/**
+ * 模型可见的取值说明（schema 描述与报错文案共用同一份，避免两处口径漂移）。
+ *
+ * ★ **代码在前、含义在后**（`finish（已结束）`）：与本条契约"传的就是这个 key"一致，
+ *   也和 `workflow-query.md` 筛选条件表的写法逐字对齐（2026-09-28 用户要求统一）。
+ */
+export const FLOW_STATUS_HINT = `${FLOW_STATUS_OPTIONS.map((item) => `${item.code}（${item.meaning}）`).join('、')}`
+    + '；只接受上述四个代码、不接受中文，可逗号分隔多值';
+/**
+ * `--flow-status` 取值 → `formDatas.flowstatus` 条件项。
+ *
+ * 返回 `null` 仅代表**输入为空**（调用方不设该条件）。取值非法一律通过 `invalid` 上报，
+ * 由调用方报错——**绝不静默丢弃条件**（丢弃会退化成全量查询）。
+ */
+export function flowStatusCondition(value, term) {
+    const text = String(value ?? '').trim();
+    if (!text)
+        return null;
+    const byLowerCode = new Map(FLOW_STATUS_OPTIONS.map((item) => [item.code.toLowerCase(), item.code]));
+    const codes = [];
+    const invalid = [];
+    for (const partRaw of text.split(/[,，、]/u)) {
+        const part = partRaw.trim();
+        if (!part)
+            continue;
+        const code = byLowerCode.get(part.toLowerCase());
+        if (code)
+            codes.push(code);
+        else
+            invalid.push(part);
+    }
+    if (invalid.length || !codes.length) {
+        return { condition: [], invalid: invalid.length ? invalid : [text] };
+    }
+    const normalizedTerm = String(term ?? '').trim().toLowerCase() === 'notin' ? 'notin' : 'in';
+    return { condition: [{ term: normalizedTerm, multiContent: [...new Set(codes)] }], invalid: [] };
+}