weaver-work-cli 0.1.5 → 0.1.7

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

@@ -0,0 +1,1991 @@
+import { createHash } from 'node:crypto';
+import { WorkflowCliError, workflowConfirmationError, workflowPartialError, workflowValidationError, } from '../errors.js';
+import { continuationReplayError } from '../continuation.js';
+import { rethrowAuthOrNetworkError } from './read.js';
+import { CONTINUATION_INPUT, SCHEMA_CATEGORY, SCHEMA_CONFIRM, SCHEMA_INDEX, SCHEMA_REQUEST_ID, schemaOf, workflowSuccess, } from './types.js';
+import { asInt, asString, asStringArray, compact, responseData, toArray, resolveMemoryAppId } from './shared.js';
+import { WORKFLOW_ENDPOINTS } from '../endpoints.js';
+import { findIndexedItem, loadSearchIndex, } from '../state.js';
+// ===========================================================================
+// 工作流写操作（operate / share / batch / memory）
+//
+// 移植自 scripts/e10_workflow.py。所有成对的 prepare/apply 严格遵循
+// 「prepare 只解析/取数/校验/预览，apply 校验 continuation 后才写」的确认链；
+// **批量类写操作（batchSubmit / batchRead / batchSupervise / batchShare / batchForward /
+// batchReject）是单命令**：一次调用内完成门禁校验、名称解析与写入，防重复写入由
+// 「确定性幂等键 + 有界保护窗口」的一次性闸门承担（见 batchIdempotencyKey / claimBatchWrite）。
+// 写请求遇网络中断/超时（结果未知）一律抛 workflowPartialError，禁止自动重试。
+// ===========================================================================
+const CONTINUATION_TTL_SECONDS = 600;
+const BATCH_SIZE_DEFAULT = 100;
+const READ_REMARK_VALUES = new Set(['60', '61', '70', '71', '80', '81']);
+// 共享对象类型 → addRequestShare2 的 shareType
+const SHARE_TYPE_MAP = {
+    user: '1',
+    dept: '2',
+    subcompany: '5',
+    role: '10',
+    group: '14',
+    position: '1311',
+    all: '11',
+};
+// 转发接收人类型（batchForward receiveOperatorInfos 的 _entityType）
+const FORWARD_RECEIVER_TYPES = new Set(['user', 'dept', 'group', 'all']);
+// RESOURCE_BROWSER 名称转 ID 的额外固定参数（与 Python SYSTEM_BROWSER_COMPLETE['creator'] 一致）
+const RESOURCE_BROWSER_EXTRA = {
+    browserMultiple: true,
+    authWecahtBook: false,
+    wxDepNeedConvertCount: 0,
+    wxEmpNeedConvertCount: 0,
+    wxTotalNeedConvertCount: 0,
+};
+// ---------------------------------------------------------------------------
+// 通用工具
+// ---------------------------------------------------------------------------
+function chunkArray(items, size) {
+    const out = [];
+    const n = Math.max(1, size);
+    for (let i = 0; i < items.length; i += n)
+        out.push(items.slice(i, i + n));
+    return out;
+}
+function splitInlineId(value) {
+    const text = (value || '').trim();
+    if (!text)
+        return { id: '', name: null };
+    const match = /^(.*?)\(([^()]+)\)\s*$/.exec(text);
+    if (match) {
+        const name = match[1].trim();
+        const id = match[2].trim();
+        if (id && /^[0-9A-Za-z_\-]+$/.test(id))
+            return { id, name: name || null };
+    }
+    return { id: text, name: null };
+}
+function parseJsonObject(value) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    if (typeof value === 'object')
+        return value;
+    const text = String(value).trim();
+    try {
+        const parsed = JSON.parse(text);
+        return parsed && typeof parsed === 'object' ? parsed : undefined;
+    }
+    catch {
+        throw workflowValidationError('json_invalid', `无法解析 JSON 参数：${text.slice(0, 80)}`);
+    }
+}
+/** 走浏览按钮把关键字解析成候选 [{id,name}]；任何异常按 0 命中处理（保守，不抛）。 */
+async function browserResolve(env, path, keyword, extra = {}) {
+    const kw = (keyword || '').trim();
+    if (!kw)
+        return [];
+    const body = compact({ browserMultiple: true, newly: 1, searchValue: kw, ...extra });
+    let response;
+    try {
+        response = await env.host.workflowRequest({ method: 'POST', path, operation: 'name.resolve', body });
+    }
+    catch {
+        return [];
+    }
+    const data = responseData(response);
+    const list = data?.data?.data ?? data?.data ?? data;
+    if (!Array.isArray(list))
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const item of list) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const id = asString(item.id);
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        out.push({ id, name: asString(item.name) ?? asString(item.content) ?? '' });
+    }
+    return out;
+}
+/** 把多个（逗号分隔的）接收人名称解析为已解析的 ID 列表；歧义/0 命中抛错。 */
+async function resolveReceiverNames(env, receiverName) {
+    const parts = String(receiverName || '')
+        .split(',')
+        .map((p) => p.trim())
+        .filter(Boolean);
+    if (!parts.length)
+        throw workflowValidationError('receiver_required', '接收人名称不能为空');
+    const ids = [];
+    for (const part of parts) {
+        const inline = splitInlineId(part);
+        if (inline.id !== part) {
+            ids.push(inline.id);
+            continue;
+        }
+        const candidates = await browserResolve(env, WORKFLOW_ENDPOINTS.RESOURCE_BROWSER, part, RESOURCE_BROWSER_EXTRA);
+        if (candidates.length === 1) {
+            ids.push(candidates[0].id);
+        }
+        else if (candidates.length > 1) {
+            throw workflowValidationError('receiver_ambiguous', `接收人「${part}」匹配到多个候选，请确认后回传 "名称(ID)"`, {
+                candidates: candidates.map((c, i) => ({ index: i + 1, id: c.id, name: c.name })),
+            });
+        }
+        else {
+            throw workflowValidationError('receiver_not_found', `未匹配到接收人「${part}」，请提供准确姓名或 "名称(ID)"`, {
+                receiverName: part,
+            });
+        }
+    }
+    return ids;
+}
+// ---------------------------------------------------------------------------
+// 序号定位：requestId 或 group+index（来源：resolve_request_id_from_args）
+// ---------------------------------------------------------------------------
+function collectAllIndexItems(index) {
+    const flat = index.items ?? [];
+    const grouped = Object.values(index.groups ?? {}).flatMap((g) => g.items ?? []);
+    const byId = new Map();
+    for (const it of [...flat, ...grouped]) {
+        if (it && it.requestId)
+            byId.set(String(it.requestId), it);
+    }
+    return [...byId.values()];
+}
+function findIndexItemByRequestId(index, requestId) {
+    return collectAllIndexItems(index).find((it) => String(it.requestId) === String(requestId));
+}
+/** 解析出目标流程条目；显式 requestId 时优先用索引元数据，索引缺失则回退拉详情校验（对应 Python 写前门禁）。 */
+async function resolveTargetItem(env, args) {
+    const explicit = asString(args.requestId);
+    const index = await loadSearchIndex(env.ctx);
+    let item;
+    if (explicit) {
+        const fromIndex = findIndexItemByRequestId(index, explicit);
+        item = fromIndex ?? (await resolveTargetViaDetail(env, explicit, asString(args.action)));
+    }
+    else {
+        const position = asInt(args.index);
+        if (position === undefined) {
+            throw workflowValidationError('locate_required', '必须提供 requestId 或 group+index 定位目标流程');
+        }
+        const group = asString(args.group);
+        const located = findIndexedItem(index, group, position);
+        if (!located || !located.requestId) {
+            throw workflowValidationError('index_stale', '序号定位失败：本地检索索引已失效或该序号不存在，请重新执行查询（workflow.search）后再操作。', { group: group ?? null, index: position });
+        }
+        item = located;
+    }
+    // 写前可操作性门禁：canSubmitRejectTransfer 不可操作时拒绝 agree/submit/reject/return/transfer/turnTodo
+    // （对应 Python cmd_workflow_operate 的 map_item 校验；isRemark 10/11 或 60/61/70/71/80/81 走特殊分支不拦截）
+    applyOperabilityGate(item, asString(args.action));
+    return item;
+}
+/** 显式 requestId 且本地索引无元数据时，拉 REQUEST_DETAIL 校验流程当前是否可操作。 */
+async function resolveTargetViaDetail(env, requestId, action) {
+    const session = await env.host.getSession();
+    let detail;
+    try {
+        detail = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS.REQUEST_DETAIL,
+            operation: 'request.detail',
+            body: { requestId, isGetRequestBaseInfo: true, isGetRequestLog: false, isGetFormData: false, userId: session.userId },
+        });
+    }
+    catch {
+        throw workflowValidationError('request_detail_unavailable', `无法获取流程 ${requestId} 详情以校验操作权限，已停止操作（请通过列表序号操作）`, { requestId });
+    }
+    const data = responseData(detail)?.data;
+    const mapItem = (data && typeof data === 'object' && data.mapItem && typeof data.mapItem === 'object' ? data.mapItem : undefined)
+        ?? (data && typeof data === 'object' ? data : {});
+    const isRemark = String(mapItem.isremark ?? mapItem.isRemark ?? '');
+    const allowed = mapItem.canSubmitRejectTransfer;
+    const isSpecialSubmit = ['agree', 'submit'].includes(String(action ?? '')) &&
+        (isRemark === '10' || isRemark === '11' || READ_REMARK_VALUES.has(isRemark));
+    // 门禁只在服务端明确返回 false 时拦截（来源：Python `if allowed is False and not is_special_submit`）。
+    // 不要把 0/'' 之类历史返回一并当"不允许"——会把可操作流程误拦成 operate_not_allowed。
+    if (allowed === false && !isSpecialSubmit) {
+        throw workflowValidationError('operate_not_allowed', `流程 ${requestId} 当前不支持「${String(action ?? '')}」操作，已停止操作`, { requestId, isRemark, canSubmitRejectTransfer: allowed });
+    }
+    return {
+        requestId,
+        isRemark,
+        nodeid: String(mapItem.nodeid ?? mapItem.nodeId ?? ''),
+        workflowId: String(mapItem.workflowid ?? mapItem.workflowId ?? ''),
+        userMasterId: String(mapItem.usermasterid ?? mapItem.userMasterId ?? mapItem.secondempid ?? ''),
+        userid: String(mapItem.userid ?? ''),
+        canSubmitRejectTransfer: allowed,
+    };
+}
+/** 单条操作可操作性门禁（对应 Python cmd_workflow_operate 的 canSubmitRejectTransfer 校验）。 */
+function applyOperabilityGate(item, action) {
+    const needsGate = ['agree', 'submit', 'reject', 'return', 'transfer', 'turnTodo'].includes(String(action ?? ''));
+    if (!needsGate)
+        return;
+    const isRemark = String(item.isRemark ?? '');
+    const allowed = item.canSubmitRejectTransfer;
+    const isSpecialSubmit = ['agree', 'submit'].includes(String(action ?? '')) &&
+        (isRemark === '10' || isRemark === '11' || READ_REMARK_VALUES.has(isRemark));
+    // 同 detail 门禁：只在明确 false 时拦截（V11.3 语义）
+    if (allowed === false && !isSpecialSubmit) {
+        throw workflowValidationError('operate_not_allowed', `流程 ${String(item.requestId)} 当前不支持「${String(action ?? '')}」操作，已停止操作`, { requestId: item.requestId, isRemark, canSubmitRejectTransfer: allowed });
+    }
+}
+/** apply 阶段校验：confirm + continuation（且与 prepare 时登记的操作名一致）。 */
+async function verifyConfirm(env, args, expectedOperation) {
+    if (args.confirm !== true) {
+        throw workflowConfirmationError(expectedOperation, {
+            hint: '请重新调用并传入 confirm=true 与 prepare 返回的 continuation',
+        });
+    }
+    const lease = await env.continuation.verify(args.continuation, expectedOperation);
+    const session = await env.host.getSession();
+    if (lease.baseUrl !== session.baseUrl || lease.profile !== session.profile || lease.userId !== session.userId) {
+        throw workflowValidationError('context_mismatch', '确认上下文已变化（租户或登录账号不同），请重新执行 prepare');
+    }
+    // verifyConfirm 仅 apply 阶段调用：校验通过后**原子抢占**该 continuation（一次性防重放）。
+    // 抢占判据是落盘 `wx` 创建本身的成败，而不是"先查存在、再写标记"——后者在两次执行交错时
+    // 会双双通过校验并各自写入，构成真实重复提交（2026-09-16 发现的 TOCTOU 窗口）。
+    // 抢不到（已被另一次执行占用）时**不再执行任何写入**，直接把上一次的执行结果回报出去：
+    // 已成功 → 幂等成功信封（ALREADY_APPLIED）；结果未确认 → continuation_consumed。
+    const claim = await env.continuation.consume(args.continuation, expectedOperation);
+    if (!claim.claimed) {
+        throw continuationReplayError(claim.previous ?? { state: 'unknown' }, expectedOperation);
+    }
+    // 登记"本次执行正持有这个句柄"：后续每一个写请求发出去之前都要据此推进阶段（见 runWrite）。
+    env.activeContinuation = String(args.continuation ?? '');
+    return lease;
+}
+/**
+ * 读取 prepare 阶段签发的 prepared 载荷（apply 阶段的唯一入口）。
+ *
+ * 兼容两种结构：**扁平**（本文件全部 prepare 实际签发的形态：`{prepared, operation, baseUrl, ...}`）
+ * 与**嵌套**（`{payload: {prepared}}`，表单系形态）。两种都取不到时抛显式 validation，
+ * **不允许**退化成 `undefined.prepared` 的 TypeError——契约错配若伪装成 internal/unexpected，
+ * 排查成本极高（2026-09-15 线上事故：8 个 apply 全崩且报错指向"未知内部错误"）。
+ */
+function readPreparedPayload(lease, operation) {
+    const prepared = lease?.prepared ?? lease?.payload?.prepared;
+    if (!prepared || typeof prepared !== 'object') {
+        throw workflowValidationError('continuation_payload_missing', `continuation 中没有 ${operation} 的 prepare 数据，无法执行。请重新执行对应的 Prepare 命令后再 apply。`, { retryAllowed: true, operation });
+    }
+    return prepared;
+}
+/**
+ * 包装写请求：发请求前把 continuation 阶段推进到 `saving`；网络中断/超时（结果未知）→
+ * workflowPartialError；其余错误原样抛出。
+ *
+ * 为什么必须在**写请求之前**推进阶段：`consume` 落下的 `claimed` 表示"只抢到句柄、还没写入"，
+ * 是允许安全重占（同一句柄重试）的唯一依据。若"已经发过写请求"也停在 `claimed`，进程被杀后
+ * 重放就会把它当成"上次没写成"而重新提交 ⇒ 真实重复写入。推进失败则**不发请求**（宁可失败，
+ * 也不留一次无法判定结果的高风险写入）。
+ */
+async function runWrite(stage, env, attempt, partialData) {
+    const active = env.activeContinuation;
+    if (active)
+        await env.continuation.markStage(active, 'saving');
+    try {
+        return await attempt();
+    }
+    catch (error) {
+        if (error instanceof WorkflowCliError && error.type === 'network') {
+            throw workflowPartialError('写操作请求已发出但响应中断/超时，操作结果未知。禁止自动重试，请先通过只读接口回查流程状态确认是否已生效。', partialData, { stage });
+        }
+        throw error;
+    }
+}
+/** 给写请求体附加当前操作人 userId（对应 Python with_userid）。 */
+async function withUserId(env, payload) {
+    const session = await env.host.getSession();
+    return { ...payload, userId: session.userId };
+}
+// ---------------------------------------------------------------------------
+// 节点字段校验（来源：run_node_field_verification L14294）
+// 提交/批准/确认 triggerOperation=0，退回 triggerOperation=1。
+// 仅作写前硬性门禁：blocked 时 apply 应停止。
+// ---------------------------------------------------------------------------
+async function runNodeFieldVerification(env, requestId, nodeId, triggerOperation) {
+    const result = { enabled: false, blocked: false, passed: true, reminders: [], results: [], passPopUpPrompt: 0, noPassPrompt: 0 };
+    const rid = String(requestId || '').trim();
+    const nid = String(nodeId || '').trim();
+    if (!rid || !nid)
+        return result;
+    let conf;
+    try {
+        conf = await env.host.workflowRequest({
+            method: 'GET',
+            path: WORKFLOW_ENDPOINTS.CONFORMANCE_SET,
+            operation: 'nodeVerification',
+            query: { requestId: rid, nodeId: nid, entryMode: 2, triggerOperation, delete: 'false' },
+        });
+    }
+    catch {
+        return result;
+    }
+    const confData = responseData(conf)?.data;
+    const cptBase = confData?.cptBase;
+    const cptSetList = confData?.cptSetList;
+    if (!cptBase || !Array.isArray(cptSetList) || !cptSetList.length)
+        return result;
+    if (Number(cptBase.openNodeCheck) !== 1)
+        return result;
+    result.enabled = true;
+    const ruleSet = cptSetList.map((rule) => ({
+        ruleName: String(rule.ruleName || ''),
+        verificationResult: '检测中…',
+        rowId: `${Math.random().toString(16).slice(2)}`,
+        conditionKey: String(rule.conditionKey || ''),
+        rulePassTip: String(rule.rulePassTip || ''),
+        ruleNoPassTip: String(rule.ruleNoPassTip || ''),
+        verificationStatus: 0,
+        processType: Number(rule.processType || 1),
+        cptSetId: String(rule.id || ''),
+        ruleType: Number(rule.ruleType || 0),
+    }));
+    let dataResult;
+    try {
+        // testUserId 传当前操作人 userId（来源：Python runtime.get("userId")），
+        // 保证依赖操作人身份的校验规则不因空串而漏拦/误拦。
+        const session = await env.host.getSession();
+        dataResult = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS.VERIFICATION_REQUEST_DATA,
+            operation: 'nodeVerification',
+            body: { requestId: rid, nodeId: nid, ruleSet, isCooperate: 0, isTest: 0, testUserId: String(session.userId ?? '').trim() },
+        });
+    }
+    catch {
+        return result;
+    }
+    const dataPayload = responseData(dataResult)?.data;
+    if (!dataPayload || typeof dataPayload !== 'object')
+        return result;
+    const requestData = dataPayload.requestData ?? [];
+    const systemContents = dataPayload.systemContents ?? [];
+    for (const rule of ruleSet) {
+        let verdict;
+        try {
+            verdict = await env.host.workflowRequest({
+                method: 'POST',
+                path: WORKFLOW_ENDPOINTS.VERIFICATION_CONDITION_RULE,
+                operation: 'nodeVerification',
+                body: {
+                    requestId: rid,
+                    nodeId: nid,
+                    identityId: '',
+                    cptSetId: rule.cptSetId,
+                    conditionKey: rule.conditionKey,
+                    requestData,
+                    systemContents,
+                },
+            });
+        }
+        catch {
+            continue;
+        }
+        const vd = responseData(verdict)?.data;
+        const status = Number(vd?.status || 0);
+        const ruleType = Number(rule.ruleType || 0);
+        const reason = String(vd?.reason || '').trim();
+        const tip = ruleType === 2 ? reason : String(vd?.result || '').trim();
+        const item = { ruleName: rule.ruleName, status, result: tip, reason, ruleType };
+        result.results.push(item);
+        if (status === 3)
+            result.reminders.push(item);
+    }
+    const ruleRelation = Number(cptBase.ruleRelation || 0);
+    const statuses = result.results.map((r) => r.status);
+    result.blocked = ruleRelation === 1 ? !statuses.some((s) => s === 1) : statuses.some((s) => s === 2);
+    result.passed = !result.blocked;
+    // 校验提示开关（来源：Python cpt_base.get("passPopUpPrompt"/"noPassPrompt")）——
+    // 0 时不显示校验结果直接操作；提醒（status=3）提示由 noPassPrompt=1 控制；
+    // 纯通过提示由 passPopUpPrompt=1 控制。
+    result.passPopUpPrompt = Number(cptBase.passPopUpPrompt || 0);
+    result.noPassPrompt = Number(cptBase.noPassPrompt || 0);
+    return result;
+}
+/** 节点字段校验提示文本（来源：Python post_operation 把 reminders 拼进 userMessage 的逻辑）。
+ *  reminder（status=3 仅提醒）不阻止操作，但须回传给用户，否则「建议补充某字段」被吞。 */
+function verificationNotice(verification) {
+    if (!verification?.enabled)
+        return undefined;
+    const reminders = verification.reminders || [];
+    if (reminders.length && verification.noPassPrompt === 1) {
+        const lines = reminders.map((r) => `${r.ruleName} 校验未通过（${r.result}）`).join('；');
+        return `节点字段校验提醒：${lines}`;
+    }
+    if (verification.passed && !reminders.length && verification.passPopUpPrompt === 1) {
+        const lines = (verification.results || []).map((r) => `${r.ruleName} 校验通过（${r.result}）`).join('；');
+        return `节点字段校验：${lines}`;
+    }
+    return undefined;
+}
+function parseShareObjects(raw) {
+    const arr = asStringArray(raw, 'shareObjects');
+    if (!arr)
+        return [];
+    const out = [];
+    for (const item of arr) {
+        const obj = parseJsonObject(item);
+        if (!obj || typeof obj !== 'object')
+            throw workflowValidationError('share_objects_invalid', '--share-objects 每项必须是对象');
+        const type = asString(obj.type);
+        if (!type)
+            throw workflowValidationError('share_type_missing', '共享对象缺少 type');
+        out.push({ type: type.trim().toLowerCase(), name: asString(obj.name) });
+    }
+    return out;
+}
+/** 共享对象多命中 → 以成功态返回候选澄清（来源：Python cmd_workflow_share 的 clarification 分支）。 */
+class ShareClarificationSignal extends Error {
+    payload;
+    constructor(payload) {
+        super('share_clarification');
+        this.name = 'ShareClarificationSignal';
+        this.payload = payload;
+    }
+}
+/** 解析单个共享目标 → addRequestShare2 shareTargetList 项；歧义/0 命中抛错。 */
+async function resolveShareTarget(env, obj, minSec, maxSec) {
+    const scope = (obj.type || '').trim().toLowerCase();
+    const shareType = SHARE_TYPE_MAP[scope];
+    if (!shareType) {
+        throw workflowValidationError('share_type_unsupported', `共享对象类型「${scope}」当前环境未提供对应浏览接口，仅支持 user/dept/subcompany/group/role/position/all`, { shareType: scope });
+    }
+    if (scope === 'all') {
+        return {
+            shareType: '11',
+            shareObjId: '0',
+            permissionTypeList: [0, 1, 2],
+            minSeclevel: minSec && /^\d+$/.test(minSec) ? Number(minSec) : -10,
+            maxSeclevel: maxSec && /^\d+$/.test(maxSec) ? Number(maxSec) : 900,
+        };
+    }
+    const name = (obj.name || '').trim();
+    if (!name)
+        throw workflowValidationError('share_target_name_missing', `共享对象（${scope}）缺少 name`);
+    // 名称转 ID 复用人员范围（EmployeeScope）浏览接口：各类对象各有端点
+    // （来源：Python EMPLOYEE_SCOPE_BROWSER_TYPES，module=hrm）
+    const browserPaths = {
+        user: WORKFLOW_ENDPOINTS.HRM_RESOURCE_BROWSER,
+        dept: WORKFLOW_ENDPOINTS.DEPT_BROWSER,
+        subcompany: WORKFLOW_ENDPOINTS.SUBCOMPANY_BROWSER,
+        group: WORKFLOW_ENDPOINTS.GROUP_BROWSER,
+        role: WORKFLOW_ENDPOINTS.ROLE_BROWSER,
+        position: WORKFLOW_ENDPOINTS.POSITION_BROWSER,
+    };
+    const path = browserPaths[scope];
+    if (!path) {
+        throw workflowValidationError('share_type_unsupported', `共享对象类型「${scope}」当前环境未提供对应浏览接口，仅支持 user/dept/subcompany/group/role/position/all`, { shareType: scope });
+    }
+    // 共享对象的公共修饰（安全级别范围、角色/岗位级别）——「名称(ID) 直取」与「名称搜索」两条路径共用
+    const decorate = (shareObjId) => {
+        const built = { shareType, shareObjId, permissionTypeList: [0, 1, 2] };
+        // 部门/分部/角色/岗位/所有人带安全级别范围（来源：Python resolve_share_target）
+        if (scope === 'dept' || scope === 'subcompany' || scope === 'role' || scope === 'position') {
+            built.minSeclevel = minSec && /^\d+$/.test(minSec) ? Number(minSec) : -10;
+            built.maxSeclevel = maxSec && /^\d+$/.test(maxSec) ? Number(maxSec) : 900;
+        }
+        // 角色级别：0 总部（默认）；岗位级别：0 所有组织下的岗位（默认）
+        if (scope === 'role' || scope === 'position')
+            built.shareTragetType = '0';
+        return built;
+    };
+    // 显式「名称(ID)」：直接采用括号里的 ID，不再拿整串去搜名称。与 resolveReceiverNames 同一口径
+    // （V11.3 的 split_name_with_inline_id 亦然）。缺这条分支时，澄清与报错里指引的「改用 名称(ID)」
+    // 是死路——整串会被当成姓名去搜，必然 0 命中，用户按提示回传反而再报一次 not_found。
+    const inline = splitInlineId(name);
+    if (inline.id !== name)
+        return decorate(inline.id);
+    const candidates = await browserResolve(env, path, name);
+    const exact = candidates.filter((c) => c.name.trim().toLowerCase() === name.toLowerCase());
+    const selected = exact.length === 1 ? exact : candidates;
+    if (!selected.length) {
+        throw workflowValidationError('share_target_not_found', `共享对象「${name}（${scope}）」未匹配到任何候选，请核对名称或改用 "名称(ID)"`, { shareType: scope, name });
+    }
+    if (selected.length !== 1) {
+        // 多命中不是失败而是"需要澄清"：按 V11.3 语义以成功态返回候选（模型展示给用户后按
+        // "名称(ID)" 回传续跑）。原先直接抛校验错误会让模型把它当失败中止、不给候选。
+        throw new ShareClarificationSignal({
+            name,
+            scope,
+            candidates: selected.map((c, i) => ({ index: i + 1, id: c.id, name: c.name })),
+        });
+    }
+    return decorate(selected[0].id);
+}
+/** 取共享安全级别默认值（getAddShareForm）；失败返回空串（不阻断）。 */
+async function shareDefaultSecLevels(env) {
+    try {
+        const res = await env.host.workflowRequest({
+            method: 'GET',
+            path: WORKFLOW_ENDPOINTS.SHARE_ADD_FORM,
+            operation: 'share.form',
+        });
+        // 解包层数：responseData 已解一层（res.data），此处只在未直接拿到 items 时再解一层
+        // ——原先固定多写一层 `.data`，实测导致 safeLevelObj 恒取不到，安全级别默认值退化成
+        // -10/900（比系统默认更宽），与 Python `result["data"]["items"]["safeLevelObj"]["value"]` 不符。
+        const body = responseData(res);
+        const data = body && typeof body === 'object' && body.items
+            ? body
+            : (body && typeof body === 'object' ? body.data ?? {} : {});
+        const value = data?.items?.safeLevelObj?.value ?? {};
+        return [String(value?.min ?? '').trim(), String(value?.max ?? '').trim()];
+    }
+    catch {
+        return ['', ''];
+    }
+}
+function mergeSecLevel(userValue, defaultValue, takeMax) {
+    const userStr = String(userValue ?? '').trim();
+    if (!userStr || !/^\d+$/.test(userStr))
+        return (defaultValue ?? '').trim();
+    const userInt = Number(userStr);
+    if (!/^\d+$/.test((defaultValue ?? '').trim()))
+        return userStr;
+    const defInt = Number(defaultValue);
+    return String(takeMax ? Math.max(userInt, defInt) : Math.min(userInt, defInt));
+}
+/** 转发接收人定义：{type, name?}；type=all 不需要 name。 */
+function parseReceiveTargets(raw) {
+    const arr = asStringArray(raw, 'receiveTargets');
+    if (!arr)
+        return [];
+    const out = [];
+    for (const item of arr) {
+        const obj = parseJsonObject(item);
+        if (!obj || typeof obj !== 'object')
+            throw workflowValidationError('receive_targets_invalid', '--receive-targets 每项必须是对象');
+        const type = asString(obj.type);
+        if (!type)
+            throw workflowValidationError('forward_type_missing', '转发接收人缺少 type');
+        out.push({ type: type.trim().toLowerCase(), name: asString(obj.name) });
+    }
+    return out;
+}
+/** 解析单个转发接收人 → batchForward receiveOperatorInfos 项；歧义/0 命中抛错。 */
+async function resolveForwardReceiver(env, obj) {
+    const rtype = (obj.type || '').trim().toLowerCase();
+    if (!FORWARD_RECEIVER_TYPES.has(rtype)) {
+        throw workflowValidationError('forward_receiver_unsupported', `转发接收人类型「${rtype}」当前环境仅支持 user/dept/group/all（人员/部门/群组/所有人）`, { receiverType: rtype });
+    }
+    if (rtype === 'all')
+        return { _entityType: 'all', id: '0' };
+    const name = (obj.name || '').trim();
+    if (!name)
+        throw workflowValidationError('forward_receiver_name_missing', `转发接收人（${rtype}）缺少 name`);
+    const path = rtype === 'dept' ? WORKFLOW_ENDPOINTS.DEPT_BROWSER : WORKFLOW_ENDPOINTS.RESOURCE_BROWSER;
+    // 显式「名称(ID)」：直接采用括号里的 ID（与 resolveShareTarget 同名分支同一理由）。
+    const inline = splitInlineId(name);
+    if (inline.id !== name)
+        return { _entityType: rtype, id: inline.id };
+    const candidates = await browserResolve(env, path, name);
+    const exact = candidates.filter((c) => c.name.trim().toLowerCase() === name.toLowerCase());
+    const selected = exact.length === 1 ? exact : candidates;
+    if (selected.length !== 1) {
+        throw workflowValidationError('forward_receiver_ambiguous', `转发接收人「${name}（${rtype}）」匹配到 ${selected.length} 个候选，请确认后回传 "名称(ID)"`, { candidates: selected.map((c, i) => ({ index: i + 1, id: c.id, name: c.name })) });
+    }
+    return { _entityType: rtype, id: selected[0].id };
+}
+/** 判断系统是否允许转发给所有人（getReceiverAllowAllConfig）。 */
+async function forwardAllowAllEnabled(env) {
+    try {
+        const res = await env.host.workflowRequest({
+            method: 'GET',
+            path: WORKFLOW_ENDPOINTS.FORWARD_ALLOW_ALL,
+            operation: 'forward.allowAll',
+        });
+        return Boolean(responseData(res)?.data?.allowAll);
+    }
+    catch {
+        return false;
+    }
+}
+/** 拉取某类批量可执行待办数据（对应 Python workflow-search --batch-type 的批量端点查询）。 */
+async function fetchBatchTodoItems(env, suffix, pageSize) {
+    const listKey = `TODO_LIST_BATCH_${suffix}`;
+    const totalKey = `TODO_TOTAL_BATCH_${suffix}`;
+    const listPath = WORKFLOW_ENDPOINTS[listKey];
+    const totalPath = WORKFLOW_ENDPOINTS[totalKey];
+    if (!listPath || !totalPath) {
+        throw workflowValidationError('batch_type_unsupported', `暂不支持的批量类型：${suffix}`);
+    }
+    const body = {
+        params: { tabid: '0', dimension: 'todo', flowSpareType: 1, outType: 0 },
+        searchParams: { formDatas: {}, type: 'and', initSearch: false },
+        customDisplayPage: { current: 1, size: Math.max(1, pageSize) },
+    };
+    const totalBody = { ...body };
+    delete totalBody.customDisplayPage;
+    const [totalResponse, listResponse] = await Promise.all([
+        env.host.workflowRequest({ method: 'POST', path: totalPath, operation: 'batch.fetchTotal', body: totalBody }),
+        env.host.workflowRequest({ method: 'POST', path: listPath, operation: 'batch.fetch', body }),
+    ]);
+    return { items: extractBatchItems(listResponse), total: extractBatchTotal(totalResponse) };
+}
+function extractBatchItems(response) {
+    const record = responseData(response);
+    const data = record?.data && typeof record.data === 'object' ? record.data : {};
+    const records = toArray(data?.displayData ?? record?.displayData ?? data?.list ?? record?.list ?? []);
+    const out = [];
+    for (const rec of records) {
+        const o = rec && typeof rec === 'object' ? rec : {};
+        const requestId = String(o.requestid ?? o.requestId ?? '');
+        if (!requestId)
+            continue;
+        out.push({
+            requestId,
+            isRemark: String(o.isremark ?? o.isRemark ?? ''),
+            userMasterId: String(o.usermasterid ?? o.userMasterId ?? o.secondempid ?? o.secondEmpId ?? ''),
+            userid: String(o.userid ?? o.usermasterid ?? o.userMasterId ?? ''),
+            nodeid: String(o.nodeid ?? o.nodeId ?? ''),
+            workflowId: String(o.workflowid ?? o.workflowId ?? ''),
+        });
+    }
+    return out;
+}
+function extractBatchTotal(response) {
+    const record = responseData(response);
+    const candidates = [
+        record?.total,
+        record?.count,
+        record?.totalCount,
+        record?.data?.total,
+        record?.data?.totalCount,
+    ];
+    for (const c of candidates) {
+        const n = asInt(c);
+        if (n !== undefined)
+            return n;
+    }
+    return 0;
+}
+/** 快照条目 → 批量候选：元数据全部取自「最近一次查询结果」（与 V11.3 会话映射一致）。 */
+function indexItemToBatchCandidate(item) {
+    const record = item;
+    return {
+        requestId: String(record.requestId ?? ''),
+        isRemark: String(record.isRemark ?? ''),
+        userMasterId: String(record.userMasterId ?? record.secondEmpId ?? ''),
+        userid: String(record.userid ?? ''),
+        nodeid: String(record.nodeid ?? record.nodeId ?? ''),
+        workflowId: String(record.workflowId ?? ''),
+    };
+}
+/**
+ * 用实时批量列表补齐**快照里缺的字段**（典型是 `userid`：列表归一化不产出它，而批量转发要用
+ * 它拼 operateUserIds）。
+ *
+ * 只补空值——不覆盖快照已有字段、不改变 isRemark 分类、**不参与放行判据**。因此实时列表用哪套
+ * 取数口径（含 `tabid`）与"能不能操作"无关。认证/网络错误原样抛出；其余失败静默忽略（快照已
+ * 足够支撑写请求，门禁在上游已通过）。
+ */
+async function enrichBatchMetadata(env, suffix, items, pageSize) {
+    const pending = items.filter((it) => !it.userid || !it.userMasterId || !it.nodeid || !it.workflowId);
+    if (!pending.length)
+        return;
+    const live = new Map();
+    try {
+        const fetched = await fetchBatchTodoItems(env, suffix, Math.max(pageSize, items.length));
+        for (const it of fetched.items)
+            live.set(String(it.requestId), it);
+    }
+    catch (error) {
+        rethrowAuthOrNetworkError(error);
+        return;
+    }
+    for (const target of pending) {
+        const source = live.get(String(target.requestId));
+        if (!source)
+            continue;
+        if (!target.userid && source.userid)
+            target.userid = source.userid;
+        if (!target.userMasterId && source.userMasterId)
+            target.userMasterId = source.userMasterId;
+        if (!target.nodeid && source.nodeid)
+            target.nodeid = source.nodeid;
+        if (!target.workflowId && source.workflowId)
+            target.workflowId = source.workflowId;
+    }
+}
+/**
+ * 门禁失败文案：只指向**唯一的取数口径**——最近一次查询结果。
+ *
+ * 旧文案把失败归因为"刚被处理掉"或"取了别的 `--tabid`"，并把"必要时带 `--tabid` 重新取数"
+ * 写成恢复路径；而后者本身就是导致误判的原因（见 `locateBatchItems`），模型会顺着它去换口径
+ * 反复重查。这里同时保留「先只读核对是否已被处理」的指引，避免把"上一次已成功"误判成需要重试。
+ */
+function batchGateMessage(missing) {
+    const preview = `${missing.slice(0, 5).join(',')}${missing.length > 5 ? ',…' : ''}`;
+    return '批量操作需校验流程来自最近一次查询结果（isRemark < 100 才可批量操作）。'
+        + `以下 ${missing.length} 条不在最近一次查询结果里：${preview}。`
+        + '正确流程：先用 workflow.search --batchType <类型> --pageSize 100 查询一页，'
+        + '再立即用该页返回的 requestId 调用批量命令（不要先收集全部 requestId 再一次性提交）。'
+        + `若这些流程其实已经被处理过，请先只读核对：workflow.search --category done --requestId ${preview}；`
+        + '已处理就按成功汇报，不要重复执行同一条批量命令（也不要为此重跑 Prepare）。';
+}
+/**
+ * 定位批量 requestIds：在**最近一次查询结果的快照**（本地索引 `search-index.json`，对应 Python
+ * `session_maps.json` 的 `latestQueryId.items`）中校验并取回元数据 —— V11.3 会话映射门禁语义。
+ *
+ * 为什么必须回到快照（2026-09-16 裁决）：V11.3 的门禁是
+ * `cmd_batch_submit → load_session_maps() → queries[latestQueryId].items`，**从不在门禁时再查
+ * 一次服务端**，因此不存在"查询一个口径、门禁另一个口径"的分叉。V12 一度改成实时查
+ * `batchSubmit` 列表、且请求体硬编码 `tabid:'0'`，而文档指引的查询
+ * （`workflow.search --batchType`）解析出的 tabid 可能是别的值——两批数据不相交时，模型按文档
+ * 查出来的 requestId 会被门禁判成"不存在"，只能反复重查反复试（真实事故：3 条一起提交全部
+ * `batch_gate_required`）。回到快照后，判据只依赖"这些流程确实是模型刚查到的"。
+ *
+ * "重复执行同一批 requestId"的风险由 continuation 一次性门禁承担（句柄只能消费一次；已消费且
+ * 成功时 apply 直接返回 `ALREADY_APPLIED` 成功信封），不再依赖门禁多查一次服务端兜底。
+ */
+async function locateBatchItems(env, suffix, requestIds, pageSize) {
+    const index = await loadSearchIndex(env.ctx);
+    const byId = new Map();
+    for (const item of collectAllIndexItems(index)) {
+        const requestId = String(item.requestId ?? '');
+        if (requestId && !byId.has(requestId))
+            byId.set(requestId, item);
+    }
+    const located = [];
+    const missing = [];
+    for (const rid of requestIds) {
+        const hit = byId.get(String(rid));
+        if (hit)
+            located.push(indexItemToBatchCandidate(hit));
+        else
+            missing.push(String(rid));
+    }
+    if (missing.length) {
+        throw workflowValidationError('batch_gate_required', batchGateMessage(missing), {
+            missingRequestIds: missing,
+        });
+    }
+    await enrichBatchMetadata(env, suffix, located, pageSize);
+    return { items: located, total: located.length };
+}
+function collectRequestIds(args) {
+    const fromJson = asStringArray(args.requestIds, 'requestIds');
+    if (fromJson)
+        return fromJson.map((s) => String(s).trim()).filter(Boolean);
+    const raw = asString(args.requestIds);
+    if (raw)
+        return raw.split(',').map((s) => s.trim()).filter(Boolean);
+    return [];
+}
+// ===========================================================================
+// 1. workflow.operatePrepare / workflow.operateApply
+// ===========================================================================
+const OPERATE_LOCATE_SCHEMA = schemaOf({
+    requestId: SCHEMA_REQUEST_ID,
+    group: { type: 'string', description: '检索索引分组标识（与 index 配合）' },
+    index: SCHEMA_INDEX,
+    action: {
+        type: 'string',
+        enum: [
+            'agree', 'submit', 'reject', 'return', 'transfer', 'turnTodo', 'delegate',
+            'forward', 'cc', 'addreview', 'forceDrawBack', 'forceOver', 'consul',
+            'deleteRequest', 'supervise',
+        ],
+        description: '动作，按用户原话选：agree/submit 同意提交，reject/return 退回，turnTodo 转办，forward 转发，delegate 委托，cc 抄送，addreview 加审，forceDrawBack 强制收回，forceOver 强制结束，consul 意见征询，deleteRequest 删除，supervise 催办',
+    },
+    opinion: { type: 'string', description: '签字/操作意见（同意/退回/强制结束/意见征询/催办等使用）' },
+    receiverName: { type: 'string', description: '接收人类动作（transfer/forward/cc/addreview/consul）接收人名称，逗号分隔，支持 "名称(ID)"' },
+    agent: { type: 'string', description: 'delegate 代理人用户 ID' },
+    rejectType: { type: 'string', description: 'reject 退回类型 0自由/1逐级/2指定范围/3按出口' },
+    nodeid: { type: 'string', description: 'reject 退回目标节点 ID' },
+    deleteType: { type: 'string', description: 'deleteRequest 删除方式 0回收站(默认)/1彻底删除' },
+    otherParamJson: { type: 'string', description: '附加参数 JSON（forceDrawBack/forceOver/consul 的 otherParam/otherParams）' },
+    selectFlowParamJson: { type: 'string', description: 'submit/agree 多出口节点提交时的指定流转参数 JSON（selectFlowParam）' },
+    exceptionHandleInfoJson: { type: 'string', description: 'submit/agree 提交时的异常处理参数 JSON（exceptionHandleInfo）' },
+    formdataJson: { type: 'string', description: 'submit/agree 随提交携带的表单数据 JSON（formdata）' },
+}, { required: ['action'] });
+const workflowOperatePrepare = {
+    name: 'workflow.operatePrepare',
+    resource: 'workflow',
+    method: 'operatePrepare',
+    action: 'workflow.operatePrepare',
+    summary: '准备单条流程操作：解析定位、接收人名称转 ID、预览，不写入；产出 continuation 供 apply 使用',
+    capability: 'operate',
+    risk: 'read-before-write',
+    requiresConfirmation: true,
+    inputSchema: OPERATE_LOCATE_SCHEMA,
+    handler: async (args, env) => {
+        const action = asString(args.action);
+        if (!action)
+            throw workflowValidationError('action_required', 'action 必填');
+        const item = await resolveTargetItem(env, args);
+        const remark = asString(args.opinion) ?? asString(args.remark) ?? '';
+        const prepared = {
+            requestId: String(item.requestId),
+            action,
+            remark,
+            isRemark: String(item.isRemark ?? ''),
+            nodeid: String(item.nodeid ?? item.nodeId ?? ''),
+            // 置为已办（doBatchRead）必需：缺 workflowId/secondEmpId 时接口报错
+            // （来源：Python cmd_workflow_operate 注入 read_items / cmd_batch_read 取 nodeid+workflowId+userMasterId）
+            workflowId: String(item.workflowId ?? ''),
+            userMasterId: String(item.userMasterId ?? item.secondEmpId ?? ''),
+            canSubmitRejectTransfer: item.canSubmitRejectTransfer,
+        };
+        const needsReceiver = ['transfer', 'turnTodo', 'forward', 'cc', 'addreview', 'consul'].includes(action);
+        if (needsReceiver) {
+            const receiverName = asString(args.receiverName);
+            if (!receiverName)
+                throw workflowValidationError('receiver_required', `动作 ${action} 必须提供 --receiver-name`);
+            prepared.receivers = await resolveReceiverNames(env, receiverName);
+        }
+        if (action === 'delegate') {
+            const agent = asString(args.agent);
+            if (!agent)
+                throw workflowValidationError('agent_required', 'delegate 必须提供 --agent 代理人用户 ID');
+            prepared.agent = agent;
+        }
+        if (action === 'reject') {
+            if (args.rejectType !== undefined)
+                prepared.rejectType = asString(args.rejectType);
+            if (args.nodeid !== undefined)
+                prepared.rejectNodeid = asString(args.nodeid);
+        }
+        if (action === 'deleteRequest') {
+            prepared.deleteType = asString(args.deleteType) ?? '0';
+        }
+        if (['forceDrawBack', 'forceOver', 'consul', 'supervise'].includes(action) && args.otherParamJson !== undefined) {
+            const op = parseJsonObject(args.otherParamJson);
+            if (op)
+                prepared.otherParam = op;
+        }
+        // 多出口节点提交：透传 selectFlowParam / exceptionHandleInfo / formdata（来源：Python cmd_submit
+        // add_optional_payload）——否则多出口流程会取默认/首分支或报「请选择出口」，走错审批路径。
+        if (action === 'agree' || action === 'submit') {
+            const selectFlowParam = parseJsonObject(args.selectFlowParamJson);
+            if (selectFlowParam)
+                prepared.selectFlowParam = selectFlowParam;
+            const exceptionHandleInfo = parseJsonObject(args.exceptionHandleInfoJson);
+            if (exceptionHandleInfo)
+                prepared.exceptionHandleInfo = exceptionHandleInfo;
+            const formdata = parseJsonObject(args.formdataJson);
+            if (formdata)
+                prepared.formdata = formdata;
+        }
+        const session = await env.host.getSession();
+        const token = await env.continuation.issue({
+            operation: 'workflow.operateApply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            prepared,
+        }, CONTINUATION_TTL_SECONDS * 1000);
+        return workflowSuccess('workflow.operatePrepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview: {
+                requestId: prepared.requestId,
+                action,
+                remark,
+                receivers: prepared.receivers,
+                agent: prepared.agent,
+            },
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+        });
+    },
+};
+const workflowOperateApply = {
+    name: 'workflow.operateApply',
+    resource: 'workflow',
+    method: 'operateApply',
+    action: 'workflow.operateApply',
+    summary: '提交单条流程操作；必须 confirm=true 且携带 operatePrepare 的 continuation',
+    capability: 'operate',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        ...OPERATE_LOCATE_SCHEMA.properties,
+        ...CONTINUATION_INPUT,
+    }, { required: ['action', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        const lease = await verifyConfirm(env, args, 'workflow.operateApply');
+        const prepared = readPreparedPayload(lease, 'workflow.operateApply');
+        if (!prepared || !prepared.requestId) {
+            throw workflowValidationError('continuation_invalid', 'continuation 缺少操作数据');
+        }
+        const action = prepared.action;
+        const requestId = String(prepared.requestId);
+        const remark = prepared.remark ?? '';
+        // 不需批示/不需提交/不需批注（isremark 60/61/70/71/80/81）走置为已办；10/11 走征询回复
+        const isRemark = String(prepared.isRemark ?? '');
+        if ((action === 'agree' || action === 'submit')) {
+            if (isRemark === '10' || isRemark === '11') {
+                const payload = await withUserId(env, { requestId, remark });
+                const response = await runWrite('consulReply', env, () => env.host.workflowRequest({
+                    method: 'POST', path: WORKFLOW_ENDPOINTS.CONSUL_REPLY, operation: 'workflow.operateApply', body: payload,
+                }), payload);
+                return workflowSuccess('workflow.operateApply', { status: 'COMPLETE', action: 'consulReply', requestId, result: response });
+            }
+            if (READ_REMARK_VALUES.has(isRemark)) {
+                const umid = String(prepared.userMasterId ?? '');
+                const readPayload = [{
+                        requestId,
+                        workflowId: String(prepared.workflowId ?? ''),
+                        nodeId: String(prepared.nodeid ?? ''),
+                        dataSrc: 0,
+                        module: 0,
+                        requestCode: '',
+                        workflowCode: '',
+                        isRemark: Number(isRemark) || 0,
+                        secondEmpId: umid,
+                    }];
+                const response = await runWrite('batchRead', env, () => env.host.workflowRequest({
+                    method: 'POST', path: WORKFLOW_ENDPOINTS.BATCH_READ, operation: 'workflow.operateApply', body: readPayload,
+                }), readPayload);
+                return workflowSuccess('workflow.operateApply', { status: 'COMPLETE', action: 'batchRead', requestId, result: response });
+            }
+        }
+        const receivers = prepared.receivers ?? [];
+        const receiveOperators = receivers.map((id) => ({ id, entityType: 'user' }));
+        switch (action) {
+            case 'agree':
+            case 'submit': {
+                const nodeId = String(prepared.nodeid ?? '');
+                const verification = await runNodeFieldVerification(env, requestId, nodeId, '0');
+                if (verification.blocked) {
+                    const lines = verification.results
+                        .filter((r) => r.status !== 1)
+                        .map((r) => `${r.ruleName} 校验未通过（${r.result}）`)
+                        .join('；');
+                    throw workflowValidationError('node_field_verification_blocked', `节点字段校验未通过，已停止提交：${lines}`, {
+                        verification,
+                    });
+                }
+                const payload = await withUserId(env, { requestId, remark });
+                if (nodeId)
+                    payload.userCurrentNodeId = nodeId;
+                if (prepared.requestName)
+                    payload.requestName = prepared.requestName;
+                // 多出口节点提交透传（来源：Python cmd_submit add_optional_payload）
+                if (prepared.selectFlowParam)
+                    payload.selectFlowParam = prepared.selectFlowParam;
+                if (prepared.exceptionHandleInfo)
+                    payload.exceptionHandleInfo = prepared.exceptionHandleInfo;
+                if (prepared.formdata)
+                    payload.formdata = prepared.formdata;
+                const response = await runWrite('submit', env, () => env.host.workflowRequest({
+                    method: 'POST', path: WORKFLOW_ENDPOINTS.SUBMIT_REQUEST, operation: 'workflow.operateApply', body: payload,
+                }), payload);
+                const notice = verificationNotice(verification);
+                return workflowSuccess('workflow.operateApply', {
+                    status: 'COMPLETE', action: 'submit', requestId, result: response, verification,
+                    ...(notice ? { notice } : {}),
+                });
+            }
+            case 'reject':
+            case 'return': {
+                const nodeId = String(prepared.nodeid ?? '');
+                const verification = await runNodeFieldVerification(env, requestId, nodeId, '1');
+                if (verification.blocked) {
+                    const lines = verification.results
+                        .filter((r) => r.status !== 1)
+                        .map((r) => `${r.ruleName} 校验未通过（${r.result}）`)
+                        .join('；');
+                    throw workflowValidationError('node_field_verification_blocked', `节点字段校验未通过，已停止退回：${lines}`, {
+                        verification,
+                    });
+                }
+                const payload = await withUserId(env, {
+                    requestId,
+                    RejectToType: prepared.rejectType ?? '0',
+                    remark,
+                });
+                if (prepared.rejectNodeid)
+                    payload.RejectToNodeid = prepared.rejectNodeid;
+                const response = await runWrite('reject', env, () => env.host.workflowRequest({
+                    method: 'POST', path: WORKFLOW_ENDPOINTS.REJECT_REQUEST, operation: 'workflow.operateApply', body: payload,
+                }), payload);
+                const notice = verificationNotice(verification);
+                return workflowSuccess('workflow.operateApply', {
+                    status: 'COMPLETE', action: 'reject', requestId, result: response, verification,
+                    ...(notice ? { notice } : {}),
+                });
+            }
+            case 'transfer':
+            case 'turnTodo': {
+                const payload = await withUserId(env, { requestId, receiveOperators, remark });
+                const response = await runWrite('transfer', env, () => env.host.workflowRequest({
+                    method: 'POST', path: WORKFLOW_ENDPOINTS.TRANSFER_REQUEST, operation: 'workflow.operateApply', body: payload,
+                }), payload);
+                return workflowSuccess('workflow.operateApply', { status: 'COMPLETE', action: 'transfer', requestId, result: response });
+            }
+            case 'delegate': {
+                const payload = await withUserId(env, { requestId, agentUserId: prepared.agent, remark });
+                const response = await runWrite('delegate', env, () => env.host.workflowRequest({
+                    method: 'POST', path: WORKFLOW_ENDPOINTS.DELEGATE_REQUEST, operation: 'workflow.operateApply', body: payload,
+                }), payload);
+                return workflowSuccess('workflow.operateApply', { status: 'COMPLETE', action: 'delegate', requestId, result: response });
+            }
+            case 'forward': {
+                const payload = await withUserId(env, { requestId, receiveOperators, remark });
+                if (prepared.otherParam)
+                    payload.otherParam = prepared.otherParam;
+                const response = await runWrite('forward', env, () => env.host.workflowRequest({
+                    method: 'POST', path: WORKFLOW_ENDPOINTS.FORWARD_REQUEST, operation: 'workflow.operateApply', body: payload,
+                }), payload);
+                return workflowSuccess('workflow.operateApply', { status: 'COMPLETE', action: 'forward', requestId, result: response });
+            }
+            case 'cc': {
+                const payload = await withUserId(env, { requestId, receiveOperators, remark });
+                if (prepared.otherParam)
+                    payload.otherParam = prepared.otherParam;
+                const response = await runWrite('cc', env, () => env.host.workflowRequest({
+                    method: 'POST', path: WORKFLOW_ENDPOINTS.CC_REQUEST, operation: 'workflow.operateApply', body: payload,
+                }), payload);
+                return workflowSuccess('workflow.operateApply', { status: 'COMPLETE', action: 'cc', requestId, result: response });
+            }
+            case 'addreview': {
+                const payload = await withUserId(env, { requestId, receiveOperators, remark });
+                if (prepared.otherParam)
+                    payload.otherParam = prepared.otherParam;
+                const response = await runWrite('addReview', env, () => env.host.workflowRequest({
+                    method: 'POST', path: WORKFLOW_ENDPOINTS.ADD_REVIEW_REQUEST, operation: 'workflow.operateApply', body: payload,
+                }), payload);
+                return workflowSuccess('workflow.operateApply', { status: 'COMPLETE', action: 'addreview', requestId, result: response });
+            }
+            case 'forceDrawBack': {
+                const payload = { requestId };
+                if (prepared.otherParam)
+                    payload.otherParams = prepared.otherParam;
+                const response = await runWrite('forceDrawBack', env, () => env.host.workflowRequest({
+                    method: 'POST', path: WORKFLOW_ENDPOINTS.FORCE_DRAW_BACK, operation: 'workflow.operateApply', body: payload,
+                }), payload);
+                return workflowSuccess('workflow.operateApply', { status: 'COMPLETE', action: 'forceDrawBack', requestId, result: response });
+            }
+            case 'forceOver': {
+                const payload = await withUserId(env, { requestId, remark });
+                if (prepared.otherParam)
+                    payload.otherParams = prepared.otherParam;
+                const response = await runWrite('forceOver', env, () => env.host.workflowRequest({
+                    method: 'POST', path: WORKFLOW_ENDPOINTS.FORCE_OVER, operation: 'workflow.operateApply', body: payload,
+                }), payload);
+                return workflowSuccess('workflow.operateApply', { status: 'COMPLETE', action: 'forceOver', requestId, result: response });
+            }
+            case 'consul': {
+                const payload = await withUserId(env, { requestId, receiveOperators, remark });
+                if (prepared.otherParam)
+                    payload.otherParam = prepared.otherParam;
+                const response = await runWrite('consul', env, () => env.host.workflowRequest({
+                    method: 'POST', path: WORKFLOW_ENDPOINTS.CONSUL, operation: 'workflow.operateApply', body: payload,
+                }), payload);
+                return workflowSuccess('workflow.operateApply', { status: 'COMPLETE', action: 'consul', requestId, result: response });
+            }
+            case 'deleteRequest': {
+                const payload = await withUserId(env, {
+                    requestId,
+                    deleteType: Number(prepared.deleteType ?? 0) || 0,
+                });
+                if (prepared.otherParam)
+                    payload.otherParams = prepared.otherParam;
+                const response = await runWrite('deleteRequest', env, () => env.host.workflowRequest({
+                    method: 'POST', path: WORKFLOW_ENDPOINTS.DELETE_REQUEST, operation: 'workflow.operateApply', body: payload,
+                }), payload);
+                return workflowSuccess('workflow.operateApply', { status: 'COMPLETE', action: 'deleteRequest', requestId, result: response });
+            }
+            case 'supervise': {
+                // 默认提醒当前审批人；otherParamJson 可覆盖提醒对象（来源：Python cmd_supervise
+                // `other_param.update(override)`——提醒谁的几个属性至少填 1 个）
+                const otherParam = {
+                    currentOperator: 1,
+                    messageRemind: 0,
+                    doneOperator: 0,
+                    submitOperator: 0,
+                    ccOperator: 0,
+                    emailRemind: 0,
+                };
+                if (prepared.otherParam && typeof prepared.otherParam === 'object') {
+                    Object.assign(otherParam, prepared.otherParam);
+                }
+                const payload = await withUserId(env, { requestId, remark, otherParam });
+                const response = await runWrite('supervise', env, () => env.host.workflowRequest({
+                    method: 'POST', path: WORKFLOW_ENDPOINTS.SUPERVISE, operation: 'workflow.operateApply', body: payload,
+                }), payload);
+                return workflowSuccess('workflow.operateApply', { status: 'COMPLETE', action: 'supervise', requestId, result: response });
+            }
+            default:
+                throw workflowValidationError('action_unsupported', `不支持的审批动作：${action}`);
+        }
+    },
+};
+// ===========================================================================
+// 2. workflow.sharePrepare / workflow.shareApply
+// ===========================================================================
+const SHARE_INPUT = schemaOf({
+    requestId: SCHEMA_REQUEST_ID,
+    group: { type: 'string' },
+    index: SCHEMA_INDEX,
+    shareObjects: {
+        type: 'array',
+        items: { type: 'string' },
+        description: '共享对象 JSON 数组字符串，每项 {"type":"user|dept|subcompany|group|role|position|all","name":"名称"}；all 不需要 name',
+    },
+    minSeclevel: { type: 'string', description: '最小安全级别（与默认值取大）' },
+    maxSeclevel: { type: 'string', description: '最大安全级别（与默认值取小）' },
+});
+const workflowSharePrepare = {
+    name: 'workflow.sharePrepare',
+    resource: 'workflow',
+    method: 'sharePrepare',
+    action: 'workflow.sharePrepare',
+    summary: '准备流程共享：解析共享对象名称转 ID、取安全级别默认值，不写入；产出 continuation',
+    capability: 'share',
+    risk: 'read-before-write',
+    requiresConfirmation: true,
+    inputSchema: SHARE_INPUT,
+    handler: async (args, env) => {
+        const item = await resolveTargetItem(env, args);
+        const objects = parseShareObjects(args.shareObjects);
+        if (!objects.length)
+            throw workflowValidationError('share_objects_required', '必须提供 --share-objects 共享对象列表');
+        const [defMin, defMax] = await shareDefaultSecLevels(env);
+        const minSec = mergeSecLevel(args.minSeclevel, defMin, true);
+        const maxSec = mergeSecLevel(args.maxSeclevel, defMax, false);
+        const targets = [];
+        for (const obj of objects) {
+            try {
+                targets.push(await resolveShareTarget(env, obj, minSec, maxSec));
+            }
+            catch (err) {
+                if (err instanceof ShareClarificationSignal) {
+                    return workflowSuccess('workflow.sharePrepare', {
+                        status: 'NEED_CLARIFICATION',
+                        needClarification: true,
+                        clarificationType: 'share_target',
+                        clarificationQuestion: `共享对象「${err.payload.name}」匹配到多个候选，请确认要共享给哪一个。`,
+                        candidates: err.payload.candidates,
+                        displayRules: [
+                            'needClarification=true 时原样展示候选，等用户确认后用 "名称(ID)" 重新调用 workflow.sharePrepare',
+                            '候选序号与显示名称保持原样，不要自行重建查询条件',
+                        ],
+                    });
+                }
+                throw err;
+            }
+        }
+        const prepared = {
+            requestId: String(item.requestId),
+            userMasterId: String(item.userMasterId ?? item.secondEmpId ?? ''),
+            targets,
+            minSec,
+            maxSec,
+        };
+        const session = await env.host.getSession();
+        const token = await env.continuation.issue({
+            operation: 'workflow.shareApply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            prepared,
+        }, CONTINUATION_TTL_SECONDS * 1000);
+        return workflowSuccess('workflow.sharePrepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview: { requestId: prepared.requestId, targetCount: targets.length, minSec, maxSec },
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+        });
+    },
+};
+const workflowShareApply = {
+    name: 'workflow.shareApply',
+    resource: 'workflow',
+    method: 'shareApply',
+    action: 'workflow.shareApply',
+    summary: '提交流程共享（addRequestShare2）；必须 confirm=true 且携带 sharePrepare 的 continuation',
+    capability: 'share',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...SHARE_INPUT.properties, ...CONTINUATION_INPUT }, { required: ['confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        const lease = await verifyConfirm(env, args, 'workflow.shareApply');
+        const prepared = readPreparedPayload(lease, 'workflow.shareApply');
+        if (!prepared || !prepared.requestId)
+            throw workflowValidationError('continuation_invalid', 'continuation 缺少共享数据');
+        const payload = {
+            otherParams: {},
+            shareSourceList: [
+                {
+                    requestid: String(prepared.requestId),
+                    workflowid: '0',
+                    isCreate: 0,
+                    createWfId: '0',
+                    secondEmpId: String(prepared.userMasterId ?? ''),
+                },
+            ],
+            shareTargetList: prepared.targets,
+        };
+        const response = await runWrite('shareAdd', env, () => env.host.workflowRequest({
+            method: 'POST', path: WORKFLOW_ENDPOINTS.SHARE_ADD, operation: 'workflow.shareApply', body: payload,
+        }), payload);
+        return workflowSuccess('workflow.shareApply', { status: 'COMPLETE', requestId: prepared.requestId, result: response });
+    },
+};
+// ===========================================================================
+// 3. workflow.batchSubmit（单命令：门禁 → 置已办 → 提交）
+// ===========================================================================
+const BATCH_REQUEST_IDS_INPUT = {
+    oneOf: [{ type: 'array', items: SCHEMA_REQUEST_ID }, { type: 'string' }],
+    description: '待批量操作的 requestId（数组或与查询索引一致的逗号分隔串）',
+};
+const BATCH_SIZE_INPUT = {
+    type: 'integer',
+    minimum: 1,
+    maximum: 100,
+    description: '单批最大条数，默认 100',
+};
+const BATCH_COMMON_INPUT = schemaOf({
+    requestIds: BATCH_REQUEST_IDS_INPUT,
+    remark: { type: 'string', description: '批量操作统一意见' },
+    batchSize: BATCH_SIZE_INPUT,
+    async: { type: 'boolean', description: '批量提交是否异步执行（isAsync，仅 batchSubmit 使用）' },
+    category: SCHEMA_CATEGORY,
+});
+/** 单命令批量写入的统一入参：操作自身字段 + `confirm`（必填，与 requestIds 在同一次调用里传）。 */
+function batchWriteSchema(input) {
+    return schemaOf({ ...input.properties, confirm: SCHEMA_CONFIRM }, { required: ['confirm'] });
+}
+/**
+ * 单命令批量操作的**幂等键**：由「哪个操作、谁、在哪个租户、要写哪一批流程、写向哪些对象」决定，
+ * 与 `remark` / `batchSize` / `confirm` 无关（同一批同一对象换个意见再执行一次，仍然是重复执行）。
+ *
+ * 为什么"写向哪些对象"必须进键：换对象是**另一次操作**——把同一批流程先转给张三、再转给李四，
+ * 两次都合法；若键只看 requestIds，第二次会被误判成"上一次已成功"，于是**不写入却报成功**，
+ * 用户会以为李四收到了。remark 相反：同一批同一对象换句话再执行一次没有任何正当理由。
+ *
+ * 为什么用确定性键而不是 prepare 句柄：单命令没有可供模型搬运的句柄（这正是本次改造的目的），
+ * 而防重复写入不能因此缺位。键相同 ⇒ 同一次写入意图 ⇒ 由 `consume` 原子抢占 + `saving` 阶段
+ * 推进 + `settle` 回写结果组成的一次性闸门拦下第二次执行。
+ */
+function batchIdempotencyKey(operation, session, requestIds, scope = {}) {
+    // workflow.batchRead → batch-read（batchSubmit 仍是 batch-submit）
+    const prefix = operation.replace(/^workflow\./u, '').replace(/[A-Z]/gu, (char) => `-${char.toLowerCase()}`);
+    const fingerprint = [
+        operation,
+        session.baseUrl,
+        session.profile,
+        session.userId,
+        [...requestIds].sort().join(','),
+        canonicalJson(scope),
+    ].join('|');
+    return `${prefix}:${createHash('sha256').update(fingerprint).digest('hex')}`;
+}
+/** 稳定序列化：对象按键排序、数组保持顺序，保证同一组入参在任何书写顺序下得到同一个幂等键。 */
+function canonicalJson(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value ?? null);
+    if (Array.isArray(value))
+        return `[${value.map((item) => canonicalJson(item)).join(',')}]`;
+    const record = value;
+    const keys = Object.keys(record).filter((key) => record[key] !== undefined).sort();
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(',')}}`;
+}
+/**
+ * 批量写入的幂等保护窗口：窗口内「同一操作 + 同一批 requestId + 同一组写向对象」只允许写入一次；
+ * 窗口过后同一批可以再次执行。
+ *
+ * 为什么必须有窗口（不能永久留痕）：同一条流程被再次处理**是合法操作**——被退回后再次提交、
+ * 被再次转办后再次催办、同一批流程换个人再转发一次。永久留痕会把它永久挡成 `ALREADY_APPLIED`。
+ *
+ * 为什么取 60 秒（而不是沿用句柄的 10 分钟）：窗口要盖住的是**机械式重复执行**——宿主把同一条
+ * 命令重跑（秒级）、或模型在没做只读核对前顺着报错直接重试（一般也在一个回合内）。而
+ * `write_uncertain` 之后的**合法**恢复路径是"先只读核对 → 确认未生效 → 重试"，若窗口设成
+ * 10 分钟，核对完反而要干等十分钟，恢复路径被堵死。
+ */
+const BATCH_IDEMPOTENCY_WINDOW_MS = 60_000;
+/** 单命令批量操作的统一确认门禁：必须显式 `confirm: true`。 */
+function requireBatchConfirm(args, operation) {
+    if (args.confirm !== true) {
+        throw workflowConfirmationError(operation, { hint: '请重新调用并传入 confirm=true' });
+    }
+}
+/**
+ * 抢占本次批量写入的一次性闸门（见 batchIdempotencyKey / BATCH_IDEMPOTENCY_WINDOW_MS）。
+ *
+ * 抢不到 ⇒ 上一次同键执行的状态决定回报形态（已成功 → ALREADY_APPLIED；写入未确认 →
+ * write_uncertain；仅被并发占用 → continuation_busy），**本次一个写请求都不发**。
+ *
+ * 调用位置固定：必须放在「全部校验与名称解析都已通过、即将发出第一个写请求」之处——放早了，
+ * 一次失败的校验会白白占掉窗口，让校正参数后的重试被误判成重复执行。
+ */
+async function claimBatchWrite(env, operation, requestIds, scope = {}) {
+    const session = await env.host.getSession();
+    const key = batchIdempotencyKey(operation, session, requestIds, scope);
+    const claim = await env.continuation.consume(key, operation, BATCH_IDEMPOTENCY_WINDOW_MS);
+    if (!claim.claimed) {
+        throw continuationReplayError(claim.previous ?? { state: 'unknown' }, operation);
+    }
+    // 登记本次执行的闸门：写请求发出前据此把阶段推进到 saving（见 runWrite）。
+    env.activeContinuation = key;
+    return key;
+}
+const workflowBatchSubmit = {
+    name: 'workflow.batchSubmit',
+    resource: 'workflow',
+    method: 'batchSubmit',
+    action: 'workflow.batchSubmit',
+    summary: '批量提交：一次调用完成门禁校验、置已办(BATCH_READ)与提交(BATCH_SUBMIT)；必须 confirm=true',
+    capability: 'batch',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...BATCH_COMMON_INPUT.properties, confirm: SCHEMA_CONFIRM }, { required: ['confirm'] }),
+    handler: async (args, env) => {
+        requireBatchConfirm(args, 'workflow.batchSubmit');
+        const requestIds = collectRequestIds(args);
+        if (!requestIds.length)
+            throw workflowValidationError('request_ids_required', '必须提供 requestIds');
+        const batchSize = asInt(args.batchSize) ?? BATCH_SIZE_DEFAULT;
+        const { items } = await locateBatchItems(env, 'SUBMIT', requestIds, batchSize);
+        const submitItems = [];
+        const readItems = [];
+        const blockedItems = [];
+        for (const it of items) {
+            const isRemark = String(it.isRemark ?? '');
+            const entry = {
+                requestId: String(it.requestId),
+                userid: String(it.userid ?? it.userMasterId ?? ''),
+                userMasterId: String(it.userMasterId ?? it.secondEmpId ?? ''),
+                nodeid: String(it.nodeid ?? it.nodeId ?? ''),
+                workflowId: String(it.workflowId ?? ''),
+                isRemark,
+            };
+            if (READ_REMARK_VALUES.has(isRemark))
+                readItems.push(entry);
+            else if (Number(isRemark) < 100)
+                submitItems.push(entry);
+            else
+                blockedItems.push(entry);
+        }
+        // isRemark=100 不可批量提交：全部被拦时直接失败，不做"静默成功"（来源：Python cmd_workflow_batch_submit 门禁）
+        if (!submitItems.length && !readItems.length) {
+            throw workflowValidationError('batch_gate_required', '批量提交需校验流程可操作性（isRemark < 100 才可批量提交）。正确流程：先用 workflow.search --batchType submit --pageSize 100 查询一页可批量操作的数据，再立即用该页返回的 requestId 调用批量提交；isRemark=100 的流程不可批量提交。', { blockedRequestIds: blockedItems.map((item) => item.requestId), doNotRetry: true });
+        }
+        // 一次性写入闸门（见 batchIdempotencyKey / BATCH_IDEMPOTENCY_WINDOW_MS）。
+        const key = await claimBatchWrite(env, 'workflow.batchSubmit', requestIds);
+        let readResult = null;
+        if (readItems.length) {
+            const readPayload = readItems.map((it) => ({
+                requestId: it.requestId,
+                workflowId: it.workflowId,
+                nodeId: it.nodeid,
+                dataSrc: 0,
+                module: 0,
+                requestCode: '',
+                workflowCode: '',
+                isRemark: Number(it.isRemark) || 0,
+                secondEmpId: it.userMasterId,
+            }));
+            readResult = await runWrite('batchRead', env, () => env.host.workflowRequest({
+                method: 'POST', path: WORKFLOW_ENDPOINTS.BATCH_READ, operation: 'workflow.batchSubmit', body: readPayload,
+            }), readPayload);
+        }
+        let submitResult = null;
+        let submittedCount = 0;
+        if (submitItems.length) {
+            // 按 batchSize 分批（契约：batchSize 1–100，CLI 自动分批循环）——
+            // 原先把所有 requestId 拼成一次请求，超出单批上限会被服务端拒绝
+            for (const batch of chunkArray(submitItems, batchSize)) {
+                const ids = batch.map((it) => it.requestId).join(',');
+                const payload = await withUserId(env, { requestIds: ids, remark: asString(args.remark) ?? '', isAsync: args.async === true });
+                submitResult = await runWrite('batchSubmit', env, () => env.host.workflowRequest({
+                    method: 'POST', path: WORKFLOW_ENDPOINTS.BATCH_SUBMIT, operation: 'workflow.batchSubmit', body: payload,
+                }), payload);
+                submittedCount += batch.length;
+            }
+        }
+        const data = {
+            status: 'COMPLETE',
+            readCount: readItems.length,
+            submittedCount,
+            batchRead: readResult,
+            submitResponse: submitResult,
+            ...(blockedItems.length
+                ? {
+                    skippedRequestIds: blockedItems.map((item) => item.requestId),
+                    skippedReason: 'isRemark=100 不可批量提交，已跳过',
+                }
+                : {}),
+        };
+        // 回写执行结果（best-effort）：重复执行时据此回报"上一次已成功"，而不是一句无法分辨的"已使用"。
+        await env.continuation.settle(key, data, 'workflow.batchSubmit');
+        return workflowSuccess('workflow.batchSubmit', data);
+    },
+};
+// ===========================================================================
+// 4. workflow.batchRead（单命令：门禁 → 元数据校验 → 置已读 / 已办）
+// ===========================================================================
+const BATCH_READ_INPUT = schemaOf({
+    requestIds: BATCH_REQUEST_IDS_INPUT,
+    batchSize: BATCH_SIZE_INPUT,
+});
+const workflowBatchRead = {
+    name: 'workflow.batchRead',
+    resource: 'workflow',
+    method: 'batchRead',
+    action: 'workflow.batchRead',
+    summary: '批量置已读/已办（doBatchRead）：一次调用完成门禁校验与写入；必须 confirm=true',
+    capability: 'batch',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: batchWriteSchema(BATCH_READ_INPUT),
+    handler: async (args, env) => {
+        requireBatchConfirm(args, 'workflow.batchRead');
+        const requestIds = collectRequestIds(args);
+        if (!requestIds.length)
+            throw workflowValidationError('request_ids_required', '必须提供 requestIds');
+        const batchSize = asInt(args.batchSize) ?? BATCH_SIZE_DEFAULT;
+        const { items } = await locateBatchItems(env, 'READ', requestIds, batchSize);
+        const readItems = items.map((it) => ({
+            requestId: String(it.requestId),
+            workflowId: String(it.workflowId ?? ''),
+            nodeid: String(it.nodeid ?? it.nodeId ?? ''),
+            isRemark: String(it.isRemark ?? '0'),
+            userMasterId: String(it.userMasterId ?? it.secondEmpId ?? ''),
+        }));
+        // 元数据门禁（来源：Python cmd_batch_read：缺 workflowId/nodeId 直接失败并提示需来自最近一次批量查询）
+        const missingMeta = readItems.filter((it) => !it.workflowId || !it.nodeid).map((it) => it.requestId);
+        if (missingMeta.length) {
+            throw workflowValidationError('batch_read_meta_missing', `以下流程缺少批量置已读所需元数据（workflowId/节点），无法执行：${missingMeta.join(', ')}。目标需来自最近一次 workflow.search（批量查询）结果，请重新查询后再试`, { requestIds: missingMeta });
+        }
+        const key = await claimBatchWrite(env, 'workflow.batchRead', requestIds);
+        let readCount = 0;
+        let lastResult = null;
+        let unverified = false;
+        for (const batch of chunkArray(readItems, batchSize)) {
+            const payload = batch.map((it) => ({
+                requestId: it.requestId,
+                workflowId: it.workflowId,
+                nodeId: it.nodeid,
+                dataSrc: 0,
+                module: 0,
+                requestCode: '',
+                workflowCode: '',
+                isRemark: Number(it.isRemark) || 0,
+                secondEmpId: it.userMasterId,
+            }));
+            const response = await runWrite('batchRead', env, () => env.host.workflowRequest({
+                method: 'POST', path: WORKFLOW_ENDPOINTS.BATCH_READ, operation: 'workflow.batchRead', body: payload,
+            }), payload);
+            lastResult = response;
+            // 成功校验（来源：Python cmd_batch_read_command：`data is not True` 即失败停止）——
+            // 只在明确失败时中止，避免把静默失败当成功上报
+            if (response?.data === false || response?.success === false) {
+                throw workflowValidationError('batch_read_failed', `批量置已读失败（已成功 ${readCount} 条，本批 ${batch.length} 条未生效），已停止`, { readCount, failedBatch: batch.map((it) => it.requestId), response });
+            }
+            if (response?.data !== true && response?.success !== true)
+                unverified = true;
+            readCount += batch.length;
+        }
+        const data = {
+            status: 'COMPLETE',
+            readCount,
+            response: lastResult,
+            ...(unverified
+                ? { resultUnverified: true, resultUnverifiedNotice: '接口未返回明确成功标志，已按提交成功处理；如需确认请重新查询流程状态' }
+                : {}),
+        };
+        await env.continuation.settle(key, data, 'workflow.batchRead');
+        return workflowSuccess('workflow.batchRead', data);
+    },
+};
+// ===========================================================================
+// 5. workflow.batchSupervise（单命令：提醒人解析 → 催办）
+// ===========================================================================
+const BATCH_SUPERVISE_INPUT = schemaOf({
+    requestIds: BATCH_REQUEST_IDS_INPUT,
+    remark: { type: 'string' },
+    currentOperator: { type: 'integer', enum: [0, 1], description: '催办当前节点未操作者，默认 1' },
+    messageRemind: { type: 'integer', enum: [0, 1], description: '短信提醒，默认 0' },
+    emailRemind: { type: 'integer', enum: [0, 1], description: '邮件提醒，默认 0' },
+    doneOperator: { type: 'integer', enum: [0, 1], description: '已审批人，默认 0' },
+    ccOperator: { type: 'integer', enum: [0, 1], description: '抄送人，默认 0' },
+    submitOperator: { type: 'integer', enum: [0, 1], description: '发起人，默认 0' },
+    otherReminder: { type: 'string', description: '其他提醒人姓名/ID，逗号分隔，支持 "姓名(ID)"' },
+    batchSize: BATCH_SIZE_INPUT,
+});
+/** 解析「其他提醒人」名单：`姓名(ID)` 直取 ID，纯姓名走浏览器候选解析（歧义 / 0 命中直接报错）。 */
+async function resolveOtherReminders(env, raw) {
+    const value = asString(raw);
+    const ids = [];
+    if (!value)
+        return ids;
+    for (const part of value.split(',').map((item) => item.trim()).filter(Boolean)) {
+        const inline = splitInlineId(part);
+        if (inline.id !== part) {
+            ids.push(inline.id);
+            continue;
+        }
+        const candidates = await browserResolve(env, WORKFLOW_ENDPOINTS.RESOURCE_BROWSER, part, RESOURCE_BROWSER_EXTRA);
+        if (candidates.length === 1)
+            ids.push(candidates[0].id);
+        else if (candidates.length > 1) {
+            throw workflowValidationError('reminder_ambiguous', `提醒人「${part}」匹配到多个候选，请回传 "姓名(ID)"`, {
+                candidates: candidates.map((c, i) => ({ index: i + 1, id: c.id, name: c.name })),
+            });
+        }
+        else {
+            throw workflowValidationError('reminder_not_found', `未匹配到提醒人「${part}」`, { reminderName: part });
+        }
+    }
+    return ids;
+}
+const workflowBatchSupervise = {
+    name: 'workflow.batchSupervise',
+    resource: 'workflow',
+    method: 'batchSupervise',
+    action: 'workflow.batchSupervise',
+    summary: '批量催办（batchSupervise）：一次调用完成提醒人解析与写入；必须 confirm=true',
+    capability: 'batch',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: batchWriteSchema(BATCH_SUPERVISE_INPUT),
+    handler: async (args, env) => {
+        requireBatchConfirm(args, 'workflow.batchSupervise');
+        const requestIds = collectRequestIds(args);
+        if (!requestIds.length)
+            throw workflowValidationError('request_ids_required', '必须提供 requestIds');
+        const batchSize = asInt(args.batchSize) ?? BATCH_SIZE_DEFAULT;
+        // 与其它 5 个批量命令**同一门禁**：requestIds 必须来自「最近一次查询结果」快照
+        // （后缀 URGE —— 与 workflow.search --batchType urge 共用同一套批量端点）。
+        // 刻意放在 claimBatchWrite 之前：门禁判不通过时不得占用一次性写入窗口。
+        await locateBatchItems(env, 'URGE', requestIds, batchSize);
+        const flags = {
+            currentOperator: asInt(args.currentOperator) ?? 1,
+            noViewOperator: 0,
+            viewOperator: 0,
+            messageRemind: asInt(args.messageRemind) ?? 0,
+            emailRemind: asInt(args.emailRemind) ?? 0,
+            doneOperator: asInt(args.doneOperator) ?? 0,
+            ccOperator: asInt(args.ccOperator) ?? 0,
+            submitOperator: asInt(args.submitOperator) ?? 0,
+        };
+        const otherReminderIds = await resolveOtherReminders(env, args.otherReminder);
+        const remark = asString(args.remark) ?? '';
+        const session = await env.host.getSession();
+        const key = await claimBatchWrite(env, 'workflow.batchSupervise', requestIds, {
+            // 「催给谁」进键：换提醒对象是另一次操作；remark 不进键（换句意见再催一次仍是重复执行）。
+            flags,
+            otherReminder: otherReminderIds,
+        });
+        const batches = chunkArray(requestIds, batchSize);
+        const result = {
+            success: true,
+            requestIdCount: requestIds.length,
+            batchCount: batches.length,
+            successNum: 0,
+            failNum: 0,
+            batches: [],
+        };
+        for (let i = 0; i < batches.length; i++) {
+            const batch = batches[i];
+            const payload = await withUserId(env, {
+                requestIds: batch.join(','),
+                operateUserIds: session.userId,
+                otherReminder: otherReminderIds.join(','),
+                ...flags,
+                identityId: '0',
+                identityType: 0,
+                remark,
+            });
+            const submitResult = await runWrite('batchSupervise', env, () => env.host.workflowRequest({
+                method: 'POST', path: WORKFLOW_ENDPOINTS.BATCH_SUPERVISE, operation: 'workflow.batchSupervise', body: payload,
+            }), payload);
+            const inner = submitResult?.data?.data ?? submitResult?.data ?? submitResult;
+            const successNum = Number(inner?.successNum ?? 0);
+            const failNum = Number(inner?.failNum ?? 0);
+            result.successNum += successNum;
+            result.failNum += failNum;
+            result.batches.push({ batchIndex: i + 1, requestIds: batch, successNum, failNum, resultMessage: String(inner?.resultMessage ?? '') });
+            if (failNum > 0) {
+                result.success = false;
+                result.batchIndex = i + 1;
+                result.userMessage = `批量催办第 ${i + 1}/${batches.length} 批部分失败：成功 ${successNum} 条，失败 ${failNum} 条`;
+                await env.continuation.settle(key, result, 'workflow.batchSupervise');
+                return workflowSuccess('workflow.batchSupervise', result);
+            }
+        }
+        result.userMessage = `已批量催办 ${result.successNum} 条流程。` + (result.failNum ? `失败 ${result.failNum} 条。` : '');
+        await env.continuation.settle(key, result, 'workflow.batchSupervise');
+        return workflowSuccess('workflow.batchSupervise', result);
+    },
+};
+// ===========================================================================
+// 6. workflow.batchShare（单命令：门禁 → 共享对象解析 → 共享）
+// ===========================================================================
+const BATCH_SHARE_INPUT = schemaOf({
+    requestIds: BATCH_REQUEST_IDS_INPUT,
+    shareObjects: {
+        type: 'array',
+        items: { type: 'string' },
+        description: '共享对象 JSON 数组字符串，每项 {"type":"user|dept|subcompany|group|role|position|all","name":"名称"}',
+    },
+    minSeclevel: { type: 'string' },
+    maxSeclevel: { type: 'string' },
+    batchSize: BATCH_SIZE_INPUT,
+});
+const workflowBatchShare = {
+    name: 'workflow.batchShare',
+    resource: 'workflow',
+    method: 'batchShare',
+    action: 'workflow.batchShare',
+    summary: '批量共享（addRequestShare2，分批）：一次调用完成门禁校验与共享对象解析；必须 confirm=true',
+    capability: 'batch',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: batchWriteSchema(BATCH_SHARE_INPUT),
+    handler: async (args, env) => {
+        requireBatchConfirm(args, 'workflow.batchShare');
+        const requestIds = collectRequestIds(args);
+        if (!requestIds.length)
+            throw workflowValidationError('request_ids_required', '必须提供 requestIds');
+        const batchSize = asInt(args.batchSize) ?? BATCH_SIZE_DEFAULT;
+        const { items } = await locateBatchItems(env, 'SHARE', requestIds, batchSize);
+        const objects = parseShareObjects(args.shareObjects);
+        if (!objects.length)
+            throw workflowValidationError('share_objects_required', '必须提供 --share-objects 共享对象列表');
+        const [defMin, defMax] = await shareDefaultSecLevels(env);
+        const minSec = mergeSecLevel(args.minSeclevel, defMin, true);
+        const maxSec = mergeSecLevel(args.maxSeclevel, defMax, false);
+        const targets = [];
+        for (const obj of objects)
+            targets.push(await resolveShareTarget(env, obj, minSec, maxSec));
+        const sourceItems = items.map((it) => ({
+            requestId: String(it.requestId),
+            userMasterId: String(it.userMasterId ?? it.secondEmpId ?? ''),
+        }));
+        const key = await claimBatchWrite(env, 'workflow.batchShare', requestIds, {
+            // 「共享给谁」进键：换对象是另一次操作，不能被当成重复执行拦下。
+            targets,
+            minSec,
+            maxSec,
+        });
+        const sharedIds = [];
+        let lastResult = null;
+        for (const batch of chunkArray(sourceItems, batchSize)) {
+            const payload = {
+                otherParams: {},
+                shareSourceList: batch.map((it) => ({
+                    requestid: String(it.requestId),
+                    workflowid: '0',
+                    isCreate: 0,
+                    createWfId: '0',
+                    secondEmpId: String(it.userMasterId ?? ''),
+                })),
+                shareTargetList: targets,
+            };
+            const response = await runWrite('batchShare', env, () => env.host.workflowRequest({
+                method: 'POST', path: WORKFLOW_ENDPOINTS.SHARE_ADD, operation: 'workflow.batchShare', body: payload,
+            }), payload);
+            lastResult = response;
+            sharedIds.push(...batch.map((it) => String(it.requestId)));
+        }
+        const data = { status: 'COMPLETE', sharedCount: sharedIds.length, requestIds: sharedIds, response: lastResult };
+        await env.continuation.settle(key, data, 'workflow.batchShare');
+        return workflowSuccess('workflow.batchShare', data);
+    },
+};
+// ===========================================================================
+// 7. workflow.batchForward（单命令：门禁 → 接收人解析 → 转发）
+// ===========================================================================
+const BATCH_FORWARD_INPUT = schemaOf({
+    requestIds: BATCH_REQUEST_IDS_INPUT,
+    receiveTargets: {
+        type: 'array',
+        items: { type: 'string' },
+        description: '转发接收人 JSON 数组字符串，每项 {"type":"user|dept|group|all","name":"名称"}；all 不需要 name',
+    },
+    remark: { type: 'string' },
+    batchSize: BATCH_SIZE_INPUT,
+});
+const workflowBatchForward = {
+    name: 'workflow.batchForward',
+    resource: 'workflow',
+    method: 'batchForward',
+    action: 'workflow.batchForward',
+    summary: '批量转发（batchForward，分批）：一次调用完成门禁校验、接收人解析与转发所有人配置检查；必须 confirm=true',
+    capability: 'batch',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: batchWriteSchema(BATCH_FORWARD_INPUT),
+    handler: async (args, env) => {
+        requireBatchConfirm(args, 'workflow.batchForward');
+        const requestIds = collectRequestIds(args);
+        if (!requestIds.length)
+            throw workflowValidationError('request_ids_required', '必须提供 requestIds');
+        const batchSize = asInt(args.batchSize) ?? BATCH_SIZE_DEFAULT;
+        const { items } = await locateBatchItems(env, 'FORWARD', requestIds, batchSize);
+        const receivers = parseReceiveTargets(args.receiveTargets);
+        if (!receivers.length)
+            throw workflowValidationError('forward_receivers_required', '必须提供 --receive-targets 转发接收人');
+        if (receivers.some((r) => r.type === 'all') && !await forwardAllowAllEnabled(env)) {
+            throw workflowValidationError('forward_all_not_allowed', '根据系统配置您不可转发给所有人，请联系系统管理员', { doNotRetry: true });
+        }
+        const receiverInfos = [];
+        for (const r of receivers)
+            receiverInfos.push(await resolveForwardReceiver(env, r));
+        const sourceItems = items.map((it) => ({
+            requestId: String(it.requestId),
+            userid: String(it.userid ?? it.userMasterId ?? ''),
+        }));
+        const remark = asString(args.remark) ?? '';
+        const key = await claimBatchWrite(env, 'workflow.batchForward', requestIds, {
+            // 「转给谁」进键：把同一批流程先转给张三、再转给李四，是两次都合法的操作。
+            receiverInfos,
+        });
+        const forwardedIds = [];
+        let lastResult = null;
+        for (const batch of chunkArray(sourceItems, batchSize)) {
+            const payload = {
+                src: 'forward',
+                receiveOperatorInfos: receiverInfos,
+                remark,
+                attachments: [],
+                fileData: [],
+                locationData: {},
+                comment: {
+                    relevanceList: [],
+                    imAtContent: remark,
+                    atLinkList: [],
+                    content: remark,
+                    originContent: remark,
+                },
+                quoteData: [],
+                fullTextAnnotationData: [],
+                signatureData: { signatureImgId: '' },
+                userSignatureData: { signatureImgId: '' },
+                identityId: '0',
+                identityType: 0,
+                requestIds: batch.map((it) => it.requestId).join(','),
+                operateUserIds: batch.map((it) => it.userid).join(','),
+                clientType: 0,
+            };
+            const response = await runWrite('batchForward', env, () => env.host.workflowRequest({
+                method: 'POST', path: WORKFLOW_ENDPOINTS.BATCH_FORWARD, operation: 'workflow.batchForward', body: payload,
+            }), payload);
+            lastResult = response;
+            const submitResults = responseData(response)?.data?.submitResult ?? [];
+            if (Array.isArray(submitResults) && submitResults.length) {
+                const failures = submitResults.filter((sr) => sr?.status !== true);
+                if (failures.length) {
+                    const partial = {
+                        status: 'PARTIAL',
+                        success: false,
+                        forwardedCount: forwardedIds.length,
+                        failedRequestIds: failures.map((f) => String(f.requestId ?? '')),
+                        failures: failures.map((f) => ({ requestId: String(f.requestId ?? ''), resultMessage: String(f.resultMessage ?? '转发失败') })),
+                        response,
+                    };
+                    await env.continuation.settle(key, partial, 'workflow.batchForward');
+                    return workflowSuccess('workflow.batchForward', partial);
+                }
+            }
+            forwardedIds.push(...batch.map((it) => it.requestId));
+        }
+        const data = { status: 'COMPLETE', forwardedCount: forwardedIds.length, requestIds: forwardedIds, response: lastResult };
+        await env.continuation.settle(key, data, 'workflow.batchForward');
+        return workflowSuccess('workflow.batchForward', data);
+    },
+};
+// ===========================================================================
+// 8. workflow.batchReject（单命令：门禁 → 退回）
+// ===========================================================================
+const BATCH_REJECT_INPUT = schemaOf({
+    requestIds: BATCH_REQUEST_IDS_INPUT,
+    remark: { type: 'string' },
+    batchSize: BATCH_SIZE_INPUT,
+});
+const workflowBatchReject = {
+    name: 'workflow.batchReject',
+    resource: 'workflow',
+    method: 'batchReject',
+    action: 'workflow.batchReject',
+    summary: '批量退回（batchReject，分批；不传 batchSubmitListParams）：一次调用完成门禁校验与退回；必须 confirm=true',
+    capability: 'batch',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: batchWriteSchema(BATCH_REJECT_INPUT),
+    handler: async (args, env) => {
+        requireBatchConfirm(args, 'workflow.batchReject');
+        const requestIds = collectRequestIds(args);
+        if (!requestIds.length)
+            throw workflowValidationError('request_ids_required', '必须提供 requestIds');
+        const batchSize = asInt(args.batchSize) ?? BATCH_SIZE_DEFAULT;
+        const { items } = await locateBatchItems(env, 'REJECT', requestIds, batchSize);
+        const sourceItems = items.map((it) => ({
+            requestId: String(it.requestId),
+            userid: String(it.userid ?? it.userMasterId ?? ''),
+        }));
+        const remark = asString(args.remark) ?? '';
+        const key = await claimBatchWrite(env, 'workflow.batchReject', requestIds);
+        const rejectedIds = [];
+        let lastResult = null;
+        for (const batch of chunkArray(sourceItems, batchSize)) {
+            const payload = {
+                isMobile: false,
+                isAsync: false,
+                conditionId: '',
+                requestIds: batch.map((it) => it.requestId).join(','),
+                operateUserIds: batch.map((it) => it.userid).join(','),
+                remark,
+                handWrittenSign: '',
+                comment: {
+                    relevanceList: [],
+                    imAtContent: remark,
+                    atLinkList: [],
+                    content: remark,
+                    originContent: remark,
+                },
+            };
+            const response = await runWrite('batchReject', env, () => env.host.workflowRequest({
+                method: 'POST', path: WORKFLOW_ENDPOINTS.BATCH_REJECT, operation: 'workflow.batchReject', body: payload,
+            }), payload);
+            lastResult = response;
+            const operateResults = responseData(response)?.data?.operateResult ?? [];
+            if (Array.isArray(operateResults) && operateResults.length) {
+                const failures = operateResults.filter((or) => or?.status !== true);
+                if (failures.length) {
+                    const partial = {
+                        status: 'PARTIAL',
+                        success: false,
+                        rejectedCount: rejectedIds.length,
+                        failedRequestIds: failures.map((f) => String(f.requestId ?? '')),
+                        failures: failures.map((f) => ({ requestId: String(f.requestId ?? ''), resultMessage: String(f.resultMessage ?? '退回失败') })),
+                        response,
+                    };
+                    await env.continuation.settle(key, partial, 'workflow.batchReject');
+                    return workflowSuccess('workflow.batchReject', partial);
+                }
+            }
+            rejectedIds.push(...batch.map((it) => it.requestId));
+        }
+        const data = { status: 'COMPLETE', rejectedCount: rejectedIds.length, requestIds: rejectedIds, response: lastResult };
+        await env.continuation.settle(key, data, 'workflow.batchReject');
+        return workflowSuccess('workflow.batchReject', data);
+    },
+};
+// ===========================================================================
+// 9. workflow.memoryExtract（requiresConfirmation = false，对话结束静默保存）
+// ===========================================================================
+const MEMORY_INPUT = schemaOf({
+    msgList: {
+        type: 'array',
+        items: { type: 'object' },
+        description: '记忆消息数组 [{msgRole:"user"|"assistant", msgValue:"..."}]',
+    },
+    userMessage: { type: 'array', items: { type: 'string' }, description: '用户消息列表（与 msgList 二选一）' },
+    assistantMessage: { type: 'array', items: { type: 'string' }, description: '模型消息列表（与 msgList 二选一）' },
+    dynamicContext: { type: 'object', description: '动态上下文参数（合并进 dynamicContextParams）' },
+    workflowId: { type: 'string', description: '关联工作流 ID' },
+    memoryAppId: { type: 'string', description: '记忆应用 ID' },
+    async: { type: 'boolean', description: '语义为同步发送并返回真实结果（禁止 fire-and-forget）' },
+});
+function normalizeMemoryMsgList(value) {
+    const arr = Array.isArray(value) ? value : [];
+    const out = [];
+    const aliases = { 用户: 'user', 模型: 'assistant', ai: 'assistant' };
+    for (const item of arr) {
+        if (!item || typeof item !== 'object')
+            throw workflowValidationError('msg_list_invalid', 'msgList 数组项必须是对象');
+        const it = item;
+        let role = asString(it.msgRole) ?? asString(it.role);
+        if (!role)
+            throw workflowValidationError('msg_role_required', 'msgList 项缺少 msgRole/role');
+        role = aliases[role.toLowerCase()] ?? role;
+        if (role !== 'user' && role !== 'assistant') {
+            throw workflowValidationError('msg_role_invalid', `msgList.msgRole 只能是 user 或 assistant（收到 ${role}）`);
+        }
+        const val = asString(it.msgValue) ?? asString(it.content) ?? asString(it.message);
+        if (!val)
+            continue;
+        out.push({ msgRole: role, msgValue: val });
+    }
+    if (!out.length)
+        throw workflowValidationError('msg_list_empty', 'msgList 不能为空');
+    return out;
+}
+const workflowMemoryExtract = {
+    name: 'workflow.memoryExtract',
+    resource: 'workflow',
+    method: 'memoryExtract',
+    action: 'workflow.memoryExtract',
+    summary: '抽取并保存对话记忆（agentMemoryExtract）；对话结束静默保存，返回真实 saved 结果，禁止 fire-and-forget',
+    capability: 'memory',
+    risk: 'write',
+    requiresConfirmation: false,
+    inputSchema: MEMORY_INPUT,
+    handler: async (args, env) => {
+        let msgList = normalizeMemoryMsgList(args.msgList);
+        const userMessages = asStringArray(args.userMessage, 'userMessage');
+        const assistantMessages = asStringArray(args.assistantMessage, 'assistantMessage');
+        if (!msgList.length && (userMessages || assistantMessages)) {
+            const built = [];
+            for (const m of userMessages ?? [])
+                if (m)
+                    built.push({ msgRole: 'user', msgValue: m });
+            for (const m of assistantMessages ?? [])
+                if (m)
+                    built.push({ msgRole: 'assistant', msgValue: m });
+            msgList = normalizeMemoryMsgList(built);
+        }
+        // 末尾补 remember 保存触发信号词
+        if (!msgList.length || msgList[msgList.length - 1].msgValue !== 'remember') {
+            msgList = [...msgList, { msgRole: 'user', msgValue: 'remember' }];
+        }
+        const workflowId = asString(args.workflowId);
+        const extra = (args.dynamicContext && typeof args.dynamicContext === 'object' ? args.dynamicContext : {});
+        const dynamicContextParams = { ...extra };
+        if (workflowId)
+            dynamicContextParams.workflowId = workflowId;
+        const chatParams = {
+            // appid 必须始终携带（缺省时记忆接口判为无效应用、静默不保存）
+            appid: resolveMemoryAppId(asString(args.memoryAppId)),
+            dynamicContextParams,
+        };
+        const payload = { chatParams, aiMsgEntityList: msgList };
+        let saved = false;
+        let result = null;
+        try {
+            result = await env.host.workflowRequest({
+                method: 'POST',
+                path: WORKFLOW_ENDPOINTS.MEMORY_EXTRACT,
+                operation: 'workflow.memoryExtract',
+                body: payload,
+            });
+            // 记忆接口业务标志是 status/fail（不是 success）；只在明确失败时判未保存
+            const body = (result && typeof result === 'object' ? result : {});
+            const explicitFalse = body.saved === false || body.success === false || body.status === false || body.fail === true;
+            saved = !explicitFalse && (body.saved === true || body.success === true || body.status === true);
+            if (!saved && !explicitFalse)
+                saved = body.code === 200 || body.fail === false;
+        }
+        catch {
+            saved = false;
+        }
+        return workflowSuccess('workflow.memoryExtract', {
+            saved,
+            messageCount: msgList.length,
+            workflowId: workflowId ?? '',
+            result,
+        });
+    },
+};
+// ===========================================================================
+// 导出
+// ===========================================================================
+export const workflowWriteOperations = [
+    workflowOperatePrepare,
+    workflowOperateApply,
+    workflowSharePrepare,
+    workflowShareApply,
+    workflowBatchSubmit,
+    workflowBatchRead,
+    workflowBatchSupervise,
+    workflowBatchShare,
+    workflowBatchForward,
+    workflowBatchReject,
+    workflowMemoryExtract,
+];