weaver-work-cli 0.1.7 → 0.1.20

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

@@ -1,9 +1,9 @@
 import { createHash } from 'node:crypto';
 import { WorkflowCliError, workflowConfirmationError, workflowPartialError, workflowValidationError, } from '../errors.js';
 import { continuationReplayError } from '../continuation.js';
-import { rethrowAuthOrNetworkError } from './read.js';
+import { defaultTabIdOf, rethrowAuthOrNetworkError, runWorkflowSearch } 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 { asInt, asString, asStringArray, compact, responseData, detailDataOf, toArray, resolveMemoryAppId } from './shared.js';
 import { WORKFLOW_ENDPOINTS } from '../endpoints.js';
 import { findIndexedItem, loadSearchIndex, } from '../state.js';
 // ===========================================================================
@@ -195,9 +195,15 @@ async function resolveTargetViaDetail(env, requestId, action) {
     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 : {});
+    // ★ 层级与 `normalizeDetailResponse` 同源：`detailDataOf` 已处理"`responseData()` 解过一层 `data`"
+    // （旧写法在这里又取一次 `.data` ⇒ 恒 undefined ⇒ 门禁永远拿不到 `mapItem`）。
+    // ⚠️ 但要清楚：该详情响应里**本来就没有** `mapItem` / `canSubmitRejectTransfer`（真机探针实测，
+    // 这两个字段只出现在列表 `displayData` 与会话映射里，`otherInfo` 常为空对象）⇒ 本函数在
+    // "直传 requestId"场景下通常仍拿不到门禁信息，`allowed` 为 undefined ⇒ **不拦截**。
+    // 这与 V11.3 的行为一致（`_normalized` 里没有 `mapItem` ⇒ 降级为 `{requestId}` ⇒ 同样不拦），
+    // 属于"缺少门禁数据"，不是"误放行"——修正层级只是让 fallback 逻辑按其本意生效。
+    const data = detailDataOf(detail);
+    const mapItem = (data.mapItem && typeof data.mapItem === 'object' ? data.mapItem : undefined) ?? data;
     const isRemark = String(mapItem.isremark ?? mapItem.isRemark ?? '');
     const allowed = mapItem.canSubmitRejectTransfer;
     const isSpecialSubmit = ['agree', 'submit'].includes(String(action ?? '')) &&
@@ -299,6 +305,56 @@ async function withUserId(env, payload) {
     const session = await env.host.getSession();
     return { ...payload, userId: session.userId };
 }
+/**
+ * 批量提交请求体（2026-09-20 用户指定，对齐前端 `POST /api/workflow/core/flow/batchSubmit` 的形态）。
+ *
+ * 与旧端点（`/api/workflow/core/paService/v1/batchSubmit`，只吃 `requestIds` + `userId`）不同：
+ *   - `batchSubmitListParams` 是一段 **JSON 字符串**，内含查询上下文（`params`）与查询条件（`searchParams`，
+ *     `formDatas` 里各条件先给"只有 term 的空壳"，真正的过滤由 `requestIds` 承担）；
+ *   - `requestIds` / `operateUserIds` 都是**逗号分隔串**；操作人取每条流程上的 `userid`（即当前操作者）。
+ */
+function buildBatchSubmitPayload(input) {
+    const termOnly = (extra = {}) => [{ term: 'in', ...extra }];
+    const searchParams = {
+        formDatas: {
+            workflowid: termOnly(), requestname: termOnly(), requestmark: termOnly(),
+            creator: termOnly({ hrmOpt: 'targetUser' }), personaltag: termOnly(), creatordept: termOnly(),
+            workflowtype: termOnly(), flowstatus: termOnly(), relateprj: termOnly(), creatorsubcom: termOnly(),
+            nodeid: termOnly(), relatedoc: termOnly(), relatehrm: termOnly(), relatecrm: termOnly(),
+            sourceUserid: termOnly({ hrmSourceOpt: 'targetUser' }), sysCode: termOnly(),
+        },
+        quickSearchDatas: {},
+        type: 'and',
+        initSearch: false,
+    };
+    const params = {
+        tabid: '0',
+        cusMenuId: '',
+        urlPageTitle: '',
+        outType: 0,
+        sortParams: [],
+        workflowId: '',
+        dimension: 'todo',
+        selectedSubId: '',
+        searchAdWorkflowid: '',
+        flowCenterParam: {},
+        flowSpareType: '1',
+        sdkModule: '',
+        queryId: '',
+        workflowid: '',
+    };
+    return {
+        isMobile: false,
+        isAsync: input.isAsync,
+        isSelectAll: false,
+        conditionId: '',
+        batchSubmitListParams: JSON.stringify({ params, searchParams }),
+        requestIds: input.requestIds.join(','),
+        operateUserIds: input.operateUserIds.join(','),
+        remark: input.remark,
+        handWrittenSign: '',
+    };
+}
 // ---------------------------------------------------------------------------
 // 节点字段校验（来源：run_node_field_verification L14294）
 // 提交/批准/确认 triggerOperation=0，退回 triggerOperation=1。
@@ -1249,6 +1305,566 @@ const BATCH_COMMON_INPUT = schemaOf({
 function batchWriteSchema(input) {
     return schemaOf({ ...input.properties, confirm: SCHEMA_CONFIRM }, { required: ['confirm'] });
 }
+// ===========================================================================
+// 3.0 范围驱动的批量执行（scopeCondition / action / exRequestIds）
+//
+// 背景：范围驱动（"把这些待办都处理了"、没有准确 requestId）原先要由**模型**自己
+// 查一页 → 执行 → 再查 → 再执行，既烧轮次又容易出错（模型把多页 ID 先收集起来一次性提交 ⇒
+// 门禁判"不在最近一次查询结果里"；或漏掉"流程被处理后从列表消失"导致重复/漏处理）。
+// 现在把循环下沉到 CLI：给 `scopeCondition`（与 workflow.search 同形）即可。
+//
+// 三条路径（三者互斥）：
+//   ① `requestIds`         —— 只处理这些（原行为不变，门禁仍走快照）
+//   ② `scopeCondition` + `action:"total"`   —— 只查数量（不发写入），供用户确认
+//   ③ `scopeCondition` + `action:"execute"` —— 内部循环：查一页 → 立即执行该页 → 排除集并入本次
+//      已处理与失败的 ID → 再查（始终从第 1 页 + exRequestId 排除，对"处理后消失"与
+//      "处理后不消失"两类操作都成立）→ 直到取不到数据 / 触达上限 / 出现必须停止的错误。
+// ===========================================================================
+/** 范围驱动单次调用的上限：批次数与总条数，防止一次调用静默跑掉几百条写操作 */
+const MAX_SCOPE_BATCHES = 20;
+const MAX_SCOPE_ITEMS = 2000;
+const BATCH_SCOPE_INPUT_PROPERTIES = {
+    action: {
+        type: 'string',
+        enum: ['total', 'execute'],
+        description: '**给了 `scopeCondition` 时必填**（不给报 `batch_action_required`）：`"total"` 只查条数（不发写入，用于先向用户确认）、`"execute"` 查询并执行',
+    },
+    scopeCondition: {
+        type: 'object',
+        description: '范围条件（与 workflow.search 入参同形：category/workflow/creator/时间条件/filterFields 等）。**与 requestIds 互斥**；给了它就不需要（也不要）先自己查 requestIds——循环由 CLI 内部完成。CLI 会自动补 `batchType`；**未显式给 subCategory/tabName/tabid 时自动按「全部」子分类取数**（给「待处理(7)」会漏掉抄送/传阅/转发类，导致范围恒 0 条）',
+    },
+    exRequestIds: {
+        ...BATCH_REQUEST_IDS_INPUT,
+        description: '本次要**排除**的 requestId（数组或逗号分隔串）。用于续跑：上一次执行失败/未处理的 ID 传进来即可跳过',
+    },
+};
+/** 从批量写入错误里取「逐条失败」的 ID；取不到返回空数组（表示整批失败、无法定位到条目） */
+function failedRequestIdsFromError(error) {
+    const details = (error?.details ?? {});
+    const candidates = [
+        details.failedRequestIds, details.failedBatch, details.requestIds, details.blockedRequestIds,
+    ];
+    for (const candidate of candidates) {
+        const ids = asStringArray(candidate, 'failedRequestIds');
+        if (ids && ids.length)
+            return ids.map((id) => String(id).trim()).filter(Boolean);
+    }
+    return [];
+}
+/**
+ * 从**单批返回的信封数据**里提取逐条失败/跳过项（带原因）。
+ *
+ * 为什么必须做这一步（2026-09-20 修复的真实 bug）：部分批量操作**部分失败时不抛错**，而是返回
+ * `ok:true` + `status:'PARTIAL'`（转发/退回）或 `success:false`（催办），逐条原因就在信封里。
+ * 驱动原先只按"内层没抛错"就 `succeededCount += 本页条数` ⇒ **把失败项计成成功、失败清单为空**。
+ *
+ * 各操作给的信息并不一致，按"有原因就用原因、没原因给可读兜底"处理：
+ *   - `batchForward` / `batchReject`：`failures:[{requestId, resultMessage}]`（有逐条原因）
+ *   - `batchSupervise`：`batches:[{requestIds, failNum, resultMessage}]`（**批次级**原因，摊到该批每条）
+ *   - `batchSubmit`：`skippedRequestIds` —— **CLI 自己输出的字段**（本地按 `isRemark` 判定的"不可批量
+ *     提交"条目，见 batchSubmit 里的 blockedItems），**接口没有这个属性**，所以这里解析的是内层信封
+ *     而不是服务端响应
+ */
+function itemFailuresFromEnvelope(data) {
+    const collected = [];
+    const push = (id, reason, fallback) => {
+        const requestId = String(id ?? '').trim();
+        if (!requestId)
+            return;
+        const text = String(reason ?? '').trim();
+        collected.push({ requestId, reason: text || fallback });
+    };
+    for (const failure of Array.isArray(data?.failures) ? data?.failures : []) {
+        if (!failure || typeof failure !== 'object')
+            continue;
+        push(failure.requestId, failure.resultMessage ?? failure.message ?? failure.reason, '操作未成功');
+    }
+    for (const batch of Array.isArray(data?.batches) ? data?.batches : []) {
+        if (!batch || typeof batch !== 'object')
+            continue;
+        if ((asInt(batch.failNum) ?? 0) <= 0)
+            continue;
+        for (const id of asStringArray(batch.requestIds, 'requestIds') ?? []) {
+            push(id, batch.resultMessage ?? batch.userMessage, '操作未成功');
+        }
+    }
+    // `skippedRequestIds` 是 CLI 自家字段（服务端没有）；范围驱动读内层信封时把它并入失败清单，避免假成功
+    for (const id of asStringArray(data?.skippedRequestIds, 'skippedRequestIds') ?? []) {
+        push(id, '', '该流程当前状态不可批量提交，已跳过');
+    }
+    // ④ 嵌套容器：`submitResponse.data.failRequest` 这类（真机 batchSubmit 的逐条失败就在这一层，
+    // 转发/退回的逐条结果同样嵌在 `data.data.operateResult` 里）——复用同一套解析器，避免两处维护。
+    const nested = findBatchResultContainer(data);
+    if (nested) {
+        for (const item of parseBatchWriteOutcome(nested, []).failed)
+            push(item.requestId, item.reason, '操作未成功');
+    }
+    // 同一 requestId 可能同时出现在多个来源（逐条失败 / 跳过清单 / 嵌套容器）里：保留**带原因**的那条
+    const byId = new Map();
+    for (const item of collected) {
+        const existing = byId.get(item.requestId);
+        if (!existing || (existing.reason.length <= item.reason.length && existing.reason !== item.reason)) {
+            byId.set(item.requestId, item);
+        }
+    }
+    return [...byId.values()];
+}
+/**
+ * 定位响应里的「逐条结果容器」。
+ *
+ * 不同批量接口的嵌套层数并不统一（真机实测：`batchSubmit` 的响应是
+ * `{message, data:{successRequest, failRequest}}`，而转发/退回的逐条结果在 `data.data.operateResult`）
+ * ⇒ 做**有界**深度搜索（≤3 层），只认那些"装逐条结果"的键。
+ */
+function findBatchResultContainer(node, depth = 0, seen = new Set()) {
+    if (!node || typeof node !== 'object' || depth > 3 || seen.has(node))
+        return null;
+    seen.add(node);
+    const record = node;
+    // `failMsg` 是前端同款批量接口（/api/workflow/core/flow/batchSubmit 等）的失败映射键，
+    // 与 `failRequest` 同形（{流程ID: 原因}），一并认。
+    const markers = ['successRequest', 'successRequestIds', 'failRequest', 'failMsg', 'submitResult', 'operateResult'];
+    if (markers.some((key) => record[key] !== undefined))
+        return record;
+    for (const value of Object.values(record)) {
+        const hit = findBatchResultContainer(value, depth + 1, seen);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+/**
+ * 单个"逐条结果行"的判定（数组本身就是结果集时用）。
+ *
+ * 要求**同时**带 ID 与**布尔型/字符串布尔**的成功标记：这样才不会把查询结果数组误认成写结果
+ * —— 查询记录里也有 `requestId`，而它的 `status` 是"经办人发起 至 部门领导审批"这类**描述字符串**。
+ */
+function isBatchOutcomeRow(row) {
+    if (!row || typeof row !== 'object' || Array.isArray(row))
+        return false;
+    const record = row;
+    const hasId = record.requestId !== undefined || record.sourceId !== undefined || record.id !== undefined;
+    const resultLike = record.result === true || record.result === false
+        || record.result === 'true' || record.result === 'false';
+    return hasId && (resultLike || typeof record.status === 'boolean');
+}
+/**
+ * 探测**数组本身就是逐条结果**的形态（`workflow.batchShare` 的 `addRequestShare2` 就是这样：
+ * `data: [{sourceId, result:"true", msg}]`，既没有 `submitResult` 这类具名字段，`data` 也不是对象）。
+ *
+ * 与 `findBatchResultContainer` 的分工：后者找具名对象字段（`submitResult[]` / `failMsg{}`），
+ * 本函数兜住"裸数组"。保持同样的有界深度（≤3），两种嵌套都能吃。
+ */
+function findBatchResultRows(node, depth = 0, seen = new Set()) {
+    if (!node || typeof node !== 'object' || depth > 3 || seen.has(node))
+        return null;
+    seen.add(node);
+    if (Array.isArray(node)) {
+        if (node.length && node.every(isBatchOutcomeRow))
+            return node;
+        for (const item of node) {
+            const hit = findBatchResultRows(item, depth + 1, seen);
+            if (hit)
+                return hit;
+        }
+        return null;
+    }
+    for (const value of Object.values(node)) {
+        const hit = findBatchResultRows(value, depth + 1, seen);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+/**
+ * 解析**一次**批量写入响应 → 「确认成功 / 逐条失败（带原因） / 无法确认」。
+ *
+ * 为什么必须有它（2026-09-20 真机实证的 P0）：`batchSubmit` 原先是**按发出去的条数**计数、
+ * `status` 恒 `COMPLETE`，从不看响应。实测把一条必然失败的流程提交，服务端返回
+ * `successRequest: []` + `failRequest: {"<id>":"当前工作流未开启允许批量提交"}`，
+ * CLI 却回 `status:"COMPLETE"` + `submittedCount:1` ⇒ **0 条成功被报成 1 条成功**。
+ *
+ * 口径（判据）：**响应里有逐条结果就按它计数；一个逐条结果都没有时不能默认"全成功"**。
+ */
+function parseBatchWriteOutcome(response, requestedIds) {
+    let flat = null;
+    try {
+        flat = responseData(response);
+    }
+    catch {
+        flat = null;
+    }
+    // 布尔契约（`doBatchRead`：`data === true` 成功 / `false` 失败）
+    if (flat === true)
+        return { succeeded: [...requestedIds], failed: [], unverified: false };
+    if (flat === false) {
+        return {
+            succeeded: [],
+            failed: requestedIds.map((requestId) => ({ requestId, reason: '服务端返回失败' })),
+            unverified: false,
+        };
+    }
+    const container = findBatchResultContainer(response);
+    // 具名对象容器找不到时，再试「数组本身就是逐条结果」的形态（共享 addRequestShare2）；
+    // 两种都拿不到 ⇒ 无法确认（绝不默认成功）。
+    const bareRows = container ? null : findBatchResultRows(response);
+    if (!container && !bareRows)
+        return { succeeded: [], failed: [], unverified: true };
+    const failed = [];
+    const succeeded = [];
+    const failureIds = new Set();
+    const pushFailure = (id, reason, name) => {
+        const requestId = String(id ?? '').trim();
+        if (!requestId)
+            return;
+        const title = String(name ?? '').trim();
+        // 同一个 requestId 可能先由「只有 ID 的映射」（failMsg/failRequest）登记、后由「逐条结果数组」
+        // （submitResult/operateResult）带来**标题** ⇒ 后到的补上标题，不要丢掉它。
+        if (failureIds.has(requestId)) {
+            if (!title)
+                return;
+            const existing = failed.find((item) => item.requestId === requestId);
+            if (existing && !existing.name)
+                existing.name = title;
+            return;
+        }
+        failureIds.add(requestId);
+        failed.push({
+            requestId,
+            reason: String(reason ?? '').trim() || '服务端未说明原因',
+            ...(title ? { name: title } : {}),
+        });
+    };
+    // ① failRequest / failMsg：**{ requestId: 原因 } 映射**（两种键名都真机见过）
+    for (const key of ['failRequest', 'failMsg']) {
+        const failMap = container?.[key];
+        if (failMap && typeof failMap === 'object' && !Array.isArray(failMap)) {
+            for (const [id, reason] of Object.entries(failMap))
+                pushFailure(id, reason);
+        }
+        if (Array.isArray(failMap)) {
+            for (const item of failMap) {
+                pushFailure(item?.requestId ?? item?.id, item?.resultMessage ?? item?.message ?? item?.reason);
+            }
+        }
+    }
+    // ② 逐条数组：具名的 submitResult / operateResult，或**数组本身就是逐条结果**（共享：根级 `data` 数组）
+    const rowGroups = [];
+    if (container) {
+        for (const key of ['submitResult', 'operateResult']) {
+            if (Array.isArray(container[key]))
+                rowGroups.push(container[key]);
+        }
+    }
+    else if (bareRows) {
+        rowGroups.push(bareRows);
+    }
+    for (const rows of rowGroups) {
+        for (const row of rows) {
+            if (!row || typeof row !== 'object')
+                continue;
+            // 标题：前端同款接口在 row.requestName 与 row.data.requestNameTitle 都给了（真机样本）
+            const rowName = row.requestName ?? row.requestNameTitle ?? row.data?.requestNameTitle ?? row.data?.requestName;
+            // ID：共享形态是 `sourceId`；成功标记：共享给的是**字符串** `result:"true"`（不是布尔 status）
+            const rowId = row.requestId ?? row.sourceId ?? row.id;
+            const rowOk = row.status === true || row.result === true || row.result === 'true';
+            // 非明确成功一律算失败（保守，绝不放行成"成功"）
+            if (rowOk)
+                succeeded.push(String(rowId ?? '').trim());
+            else
+                pushFailure(rowId, row.resultMessage ?? row.msg ?? row.message ?? row.reason, rowName);
+        }
+    }
+    // ③ successRequest / successRequestIds：元素可能是 id 或 {requestId}
+    for (const key of ['successRequest', 'successRequestIds']) {
+        const rows = container?.[key];
+        if (!Array.isArray(rows))
+            continue;
+        for (const row of rows) {
+            const id = typeof row === 'object' && row !== null
+                ? String(row.requestId ?? row.sourceId ?? row.id ?? '').trim()
+                : String(row ?? '').trim();
+            if (id)
+                succeeded.push(id);
+        }
+    }
+    const confirmedSucceeded = succeeded.filter((id) => id && !failureIds.has(id));
+    if (!confirmedSucceeded.length && !failed.length)
+        return { succeeded: [], failed: [], unverified: true };
+    // 只给了失败映射时，成功集合由「请求集合 − 失败集合」补出（实测 batchSubmit 正是这种）
+    const succeededFinal = confirmedSucceeded.length
+        ? confirmedSucceeded
+        : requestedIds.filter((id) => !failureIds.has(id));
+    return { succeeded: succeededFinal, failed, unverified: false };
+}
+/**
+ * 给失败项补**流程标题**。
+ *
+ * 优先用服务端逐条结果里的名字（`requestName` / `data.requestNameTitle`）；那里没有时，回退到
+ * **最近一次查询结果的快照**（`search-index.json` 的 `flowName`，它取自原始记录的
+ * `requestnameTitle`/`requestnametitle`——真机确认两个键名都存在且同值）。都取不到就只给 ID，
+ * **不编造**。
+ */
+async function attachFailureTitles(failures, env) {
+    if (!failures.length || failures.every((item) => item.name))
+        return failures;
+    const titleById = new Map();
+    try {
+        const snapshot = await loadSearchIndex(env.ctx);
+        for (const item of collectAllIndexItems(snapshot)) {
+            const requestId = String(item?.requestId ?? '').trim();
+            const name = String(item?.flowName ?? '').trim();
+            if (requestId && name)
+                titleById.set(requestId, name);
+        }
+    }
+    catch {
+        // 快照读不到（尚未查询过/被清理）：只给 ID，不编造标题
+    }
+    return failures.map((item) => (item.name ? item : (() => {
+        const name = titleById.get(item.requestId) ?? '';
+        return name ? { ...item, name } : item;
+    })()));
+}
+/** 读不到逐条结果时的统一提示（"不确认"绝不等于"成功"） */
+const UNVERIFIED_NOTICE = '服务端未返回逐条结果，本次**无法确认**这些流程是否已生效：'
+    + '不要按"已成功"上报，请用 workflow.search --category done --requestId <id> 只读核对（默认子分类为「全部」）。';
+/** 从一页查询结果里取 requestId：优先 `cards`；超线时 `cards` 被移出 stdout ⇒ 回退到刚刷新的索引快照 */
+async function scopePageRequestIds(data, env) {
+    const cards = Array.isArray(data?.cards) ? data.cards : [];
+    if (cards.length) {
+        return cards.map((card) => String(card?.requestId ?? '').trim()).filter(Boolean);
+    }
+    try {
+        const snapshot = await loadSearchIndex(env.ctx);
+        return collectAllIndexItems(snapshot).map((item) => String(item?.requestId ?? '').trim()).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 范围驱动的批量执行入口。返回 `null` 表示"本次不是范围驱动"，调用方按原逻辑（requestIds）继续。
+ */
+async function runScopeDrivenBatch(args, env, operationName, suffix, inner) {
+    const scope = args.scopeCondition;
+    const hasScope = !!scope && typeof scope === 'object' && !Array.isArray(scope) && Object.keys(scope).length > 0;
+    if (!hasScope)
+        return null;
+    requireBatchConfirm(args, operationName);
+    if (collectRequestIds(args).length) {
+        throw workflowValidationError('batch_scope_conflict', '`requestIds` 与 `scopeCondition` 只能给一个：给了 `requestIds` 就只处理这些，给了 `scopeCondition` 才由 CLI 内部按范围取数');
+    }
+    // `action` 在范围驱动下**必填**（用户 2026-09-20 裁定）：不给默认值，"先数条数再执行"这一步
+    // 就不能靠"忘了写"绕过去——必须显式选 `total`（先数）或 `execute`（执行）。
+    const action = (asString(args.action) ?? '').toLowerCase();
+    if (!action) {
+        throw workflowValidationError('batch_action_required', '给了 `scopeCondition` 时必须显式指定 `action`：先用 `"total"` 只查条数并请用户确认，确认后再用 `"execute"` 执行', { retryAllowed: false });
+    }
+    if (action !== 'total' && action !== 'execute') {
+        throw workflowValidationError('batch_action_invalid', '`action` 只能是 `"total"` 或 `"execute"`');
+    }
+    const batchType = suffix.toLowerCase();
+    const pageSize = asInt(args.batchSize) ?? BATCH_SIZE_DEFAULT;
+    const scopeRaw = scope;
+    const category = asString(scopeRaw.category) ?? asString(args.category) ?? 'todo';
+    const scopeBase = { ...scopeRaw, batchType, category };
+    // ★ 范围驱动默认「全部」子分类（用户 2026-09-20 裁定）：scope 未显式给 subCategory/tabName/tabid 时，
+    // 显式带上该大分类的「全部」tabid（todo→0）。理由见 defaultTabIdOf 注释：
+    // legacy 下 todo 缺省子分类会落到「待处理(7)」，而批量过滤列表端点在该 tabid 下只返待处理
+    // ⇒ 范围里全是抄送/传阅/转发类时恒 0 条，模型会把"取不到"报成"范围内没有数据"。
+    const hasExplicitTab = ['subCategory', 'tabName', 'tabid'].some((key) => {
+        const fromScope = scopeRaw[key];
+        if (fromScope !== undefined && String(fromScope).trim() !== '')
+            return true;
+        const fromArgs = args[key];
+        return fromArgs !== undefined && String(fromArgs).trim() !== '';
+    });
+    if (!hasExplicitTab)
+        scopeBase.tabid = defaultTabIdOf(category);
+    // —— ② 只查数量：不发任何写入（但要把"能不能真取到行"一并查清，避免 total 与 execute 说两套话）——
+    if (action === 'total') {
+        const totalData = await runWorkflowSearch({ ...scopeBase, totalOnly: true }, env);
+        const scopeTotal = asInt(totalData?.total) ?? 0;
+        // 列表探针（≤1 行）：total 端点与 list 端点的口径可能不一致（真实事故：total 说 96、
+        // list 取 0 行），所以"可执行条数"必须以**能取到行**为准，不能只信 total。
+        let executable = false;
+        if (scopeTotal > 0) {
+            const probe = await runWorkflowSearch({ ...scopeBase, current: 1, pageSize: 1 }, env);
+            executable = (await scopePageRequestIds(probe, env)).length > 0;
+        }
+        const reportTotal = executable ? scopeTotal : 0;
+        // 返回只放**业务结果**：条数与可执行性。`pageSize`/预计批次数这类"内部怎么分批"的实现细节
+        // 一律不回（2026-09-20 用户裁定：对普通用户没意义，模型还会顺手念给用户听）。
+        return workflowSuccess(operationName, {
+            status: 'SCOPE_TOTAL',
+            action: 'total',
+            total: reportTotal,
+            scopeTotal,
+            executable,
+            batchType,
+            scopeCondition: scope,
+            message: executable
+                ? `该范围下可批量操作的流程共 ${reportTotal} 条。请先向用户确认条数，确认后再用 action="execute" 执行。`
+                : (scopeTotal > 0
+                    ? `该范围共有 ${scopeTotal} 条流程，但**当前没有一条能按本次操作取到**（可执行 0 条）——常见原因：这些流程是抄送/传阅/转发类（批量提交对它们等同置为已办，可改用 workflow.batchRead），或 scope 的子分类把数据收窄掉了。**这不代表范围内没有数据**。`
+                    : '该范围下没有任何流程，无需执行。'),
+        });
+    }
+    // —— ③ 内部循环执行 ——
+    const excluded = new Set(collectRequestIds({ requestIds: args.exRequestIds }));
+    const pageArgsBase = { ...args };
+    for (const key of ['scopeCondition', 'action', 'exRequestIds', 'requestIds', 'confirm'])
+        delete pageArgsBase[key];
+    const failures = [];
+    let lastBatchError = null;
+    let succeededCount = 0;
+    let stoppedReason = '';
+    let scopeTotalWhenEmpty = 0;
+    for (let index = 1; index <= MAX_SCOPE_BATCHES; index += 1) {
+        // 始终从第 1 页取 + 用排除集排掉已处理/已失败的 ID —— 对"处理后消失"（提交/置已读）
+        // 与"处理后不消失"（催办/共享/转发/退回）两类操作都成立，无需区分翻页策略。
+        const pageData = await runWorkflowSearch({
+            ...scopeBase,
+            current: 1,
+            pageSize,
+            ...(excluded.size ? { exRequestId: [...excluded].join(',') } : {}),
+        }, env);
+        const pageIds = (await scopePageRequestIds(pageData, env)).filter((id) => id && !excluded.has(id));
+        if (!pageIds.length) {
+            // 区分「范围真的没数据」与「范围内有数据、但本次取不到可批量处理的项」——后者若报成
+            // "该范围已取不到更多数据"，模型会把它写成一条**假的数据结论**（真实事故：把 96 条报成"今天 0 条"）。
+            // 只在**第一轮就取空**时补一次只读总数查询：已经处理过条目的情况下取空＝真的取完了，
+            // 不必也不能当成"不适用"。正常路径零额外开销。
+            if (index === 1 && !succeededCount && !failures.length) {
+                try {
+                    const probeData = await runWorkflowSearch({ ...scopeBase, totalOnly: true }, env);
+                    scopeTotalWhenEmpty = asInt(probeData?.total) ?? 0;
+                }
+                catch (error) {
+                    rethrowAuthOrNetworkError(error);
+                    scopeTotalWhenEmpty = 0;
+                }
+                stoppedReason = scopeTotalWhenEmpty > 0 ? 'scope_not_batch_eligible' : 'scope_exhausted';
+            }
+            else {
+                stoppedReason = 'scope_exhausted';
+            }
+            break;
+        }
+        let envelope;
+        try {
+            envelope = await inner({ ...pageArgsBase, requestIds: pageIds, confirm: true });
+        }
+        catch (error) {
+            // 认证/网络错误原样抛（不得降级成"没数据"）
+            rethrowAuthOrNetworkError(error);
+            const itemFailed = failedRequestIdsFromError(error);
+            const errorText = String(error?.message ?? error).trim().slice(0, 300);
+            const toExclude = itemFailed.length ? itemFailed : pageIds;
+            for (const id of toExclude) {
+                excluded.add(id);
+                // 抛错路径只有批次级原因（服务端响应在错误详情里）：摊到该批每条，至少让用户知道"为什么没成功"
+                failures.push({ requestId: id, reason: errorText || '批量写入未成功' });
+            }
+            lastBatchError = {
+                subtype: String(error?.subtype ?? ''),
+                message: errorText,
+            };
+            // 整批失败（定位不到逐条失败项）⇒ 立即停止：这类失败通常是口径/认证/门禁问题，
+            // 继续跑只会把同一个错误重复 N 次。能定位到逐条失败项时才继续（继续时排除集里已有它们）。
+            if (!itemFailed.length) {
+                stoppedReason = 'batch_failed_stop';
+                break;
+            }
+            if (succeededCount + failures.length >= MAX_SCOPE_ITEMS) {
+                stoppedReason = 'max_items_reached';
+                break;
+            }
+            continue;
+        }
+        // ★ 内层单批"部分失败"不一定抛错（转发/退回返回 PARTIAL+failures、催办返回 success=false、
+        // 提交返回 skippedRequestIds）⇒ 必须解析信封，否则失败项会被计成成功、失败清单为空。
+        const itemFailures = itemFailuresFromEnvelope((envelope.data ?? {}));
+        const failedIdSet = new Set(itemFailures.map((item) => item.requestId));
+        // 内层"无法确认"（服务端没给逐条结果，如 batchRead 的 resultUnverified）⇒ **不计入成功**：
+        // 收进失败清单并如实标注原因，由模型只读核对后再决定是否重试（"不确认"绝不等于"成功"）。
+        const innerData = (envelope.data ?? {});
+        if (innerData.unverified === true || innerData.resultUnverified === true) {
+            for (const id of pageIds) {
+                if (failedIdSet.has(id))
+                    continue;
+                failedIdSet.add(id); // 同步进"失败集合"，使下面的成功计数同步扣除
+                itemFailures.push({ requestId: id, reason: '服务端未返回逐条结果，无法确认是否生效（请只读核对）' });
+            }
+        }
+        // 已处理与已失败都进排除集：既不重复取数（否则原地打转），也不重复写入
+        for (const id of pageIds)
+            excluded.add(id);
+        for (const item of itemFailures)
+            failures.push(item);
+        succeededCount += pageIds.length - pageIds.filter((id) => failedIdSet.has(id)).length;
+        if (succeededCount + failures.length >= MAX_SCOPE_ITEMS) {
+            stoppedReason = 'max_items_reached';
+            break;
+        }
+    }
+    if (!stoppedReason)
+        stoppedReason = 'max_batches_reached';
+    const complete = stoppedReason === 'scope_exhausted';
+    const notEligible = stoppedReason === 'scope_not_batch_eligible';
+    const failuresWithTitles = await attachFailureTitles(failures, env);
+    // 返回只放**业务结果**：处理条数、失败清单、未跑完的原因（诊断用）。
+    // 不返回 `batches`/`batchSummaries`/`pageSize`——那是"内部怎么分批循环"的实现细节，
+    // 对用户没有意义，还会被顺手念给用户听（2026-09-20 用户裁定）。
+    const partialReasonText = {
+        max_batches_reached: '已达单次调用的处理上限',
+        max_items_reached: '已达单次调用的处理上限',
+        batch_failed_stop: '其中一批整体失败，已停止',
+    };
+    return workflowSuccess(operationName, {
+        status: complete ? 'COMPLETE' : 'PARTIAL',
+        action: 'execute',
+        batchType,
+        scopeCondition: scope,
+        succeededCount,
+        failedCount: failuresWithTitles.length,
+        ...(failuresWithTitles.length ? { failures: failuresWithTitles } : {}),
+        ...(notEligible ? { scopeTotal: scopeTotalWhenEmpty } : {}),
+        ...(!complete && !notEligible && lastBatchError ? { lastError: lastBatchError } : {}),
+        stoppedReason,
+        message: complete
+            ? `已处理 ${succeededCount} 条${failuresWithTitles.length ? `、失败 ${failuresWithTitles.length} 条` : ''}，该范围已处理完。`
+            : (notEligible
+                ? `已处理 ${succeededCount} 条；该范围共有 ${scopeTotalWhenEmpty} 条流程，但**余下的都取不到**（本次操作对它们不适用）。`
+                    + '常见原因：这些流程是抄送/传阅/转发类（例如批量提交对它们等同置为已办，可改用 workflow.batchRead）。'
+                    + '**这不代表该范围内没有数据**——向用户汇报时必须说明"有多少条、为什么不适用"，不要报成"0 条/没有数据"。'
+                : `已处理 ${succeededCount} 条、失败 ${failuresWithTitles.length} 条，但**没有跑完**（${partialReasonText[stoppedReason] ?? stoppedReason}）。`
+                    + '不要把本次结果当成"全部处理完了"；如需续跑，带上同一 `scopeCondition` 再执行一次（本次已处理的会被自动跳过）；'
+                    + '**要重试失败的那几条时，先只读核对它们是否其实已经生效**（workflow.search --category done --requestId <id>），确认没生效再用 requestIds 单独重试。'),
+        notice: '汇报时只说"处理了多少条、失败了多少条（`failures` 里有逐条原因）"这类业务结果；'
+            + '**不要向用户提内部分批、循环、页数、批次数等实现细节**——那是 CLI 内部的事，对用户没有意义。'
+            + (failuresWithTitles.length ? '失败项要连**原因**一起说明（`failures[].reason`），不要只报个数。' : ''),
+    });
+}
+/** 给 6 个单命令批量操作统一挂上范围驱动（requestIds 路径完全不受影响）。 */
+function withBatchScopeDriver(definition, suffix) {
+    const inner = definition.handler;
+    const properties = {
+        ...(definition.inputSchema?.properties ?? {}),
+        ...BATCH_SCOPE_INPUT_PROPERTIES,
+    };
+    return {
+        ...definition,
+        inputSchema: schemaOf(properties, { required: ['confirm'] }),
+        handler: async (args, env) => {
+            const scoped = await runScopeDrivenBatch(args, env, definition.name, suffix, (pageArgs) => inner(pageArgs, env));
+            if (scoped)
+                return scoped;
+            return inner(args, env);
+        },
+    };
+}
 /**
  * 单命令批量操作的**幂等键**：由「哪个操作、谁、在哪个租户、要写哪一批流程、写向哪些对象」决定，
  * 与 `remark` / `batchSize` / `confirm` 无关（同一批同一对象换个意见再执行一次，仍然是重复执行）。
@@ -1383,26 +1999,60 @@ const workflowBatchSubmit = {
                 method: 'POST', path: WORKFLOW_ENDPOINTS.BATCH_READ, operation: 'workflow.batchSubmit', body: readPayload,
             }), readPayload);
         }
+        // 前置置已办（"不需提交"类）也要按服务端的逐条/布尔结果计数，不能默认成功
+        let readCount = 0;
+        let readUnverified = false;
+        const readOutcome = readItems.length
+            ? parseBatchWriteOutcome(readResult, readItems.map((item) => item.requestId))
+            : { succeeded: [], failed: [], unverified: false };
+        readCount = readOutcome.succeeded.length;
+        readUnverified = readOutcome.unverified;
         let submitResult = null;
-        let submittedCount = 0;
+        const submitFailures = [];
+        const submitSucceededIds = [];
+        let submitUnverified = false;
         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 });
+                const payload = buildBatchSubmitPayload({
+                    requestIds: batch.map((it) => it.requestId),
+                    operateUserIds: [...new Set(batch.map((it) => String(it.userid || it.userMasterId || '')).filter(Boolean))],
+                    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;
+                // ★ 只认服务端逐条结果：`successRequest` 是成功清单、`failRequest` 是 {id: 原因} 映射
+                const outcome = parseBatchWriteOutcome(submitResult, batch.map((it) => it.requestId));
+                submitSucceededIds.push(...outcome.succeeded);
+                submitFailures.push(...outcome.failed);
+                if (outcome.unverified)
+                    submitUnverified = true;
             }
         }
+        const failures = await attachFailureTitles([...readOutcome.failed, ...submitFailures], env);
+        const unverified = readUnverified || submitUnverified;
         const data = {
-            status: 'COMPLETE',
-            readCount: readItems.length,
-            submittedCount,
+            // 有逐条失败、或读不到逐条结果 ⇒ 都不是"全部成功"
+            status: failures.length || unverified ? 'PARTIAL' : 'COMPLETE',
+            readCount,
+            submittedCount: submitSucceededIds.length,
+            failedCount: failures.length,
             batchRead: readResult,
             submitResponse: submitResult,
+            ...(failures.length ? { failures } : {}),
+            ...(unverified
+                ? {
+                    unverified: true,
+                    unverifiedRequestIds: [
+                        ...(readUnverified ? readItems.map((item) => item.requestId) : []),
+                        ...(submitUnverified ? submitItems.map((item) => item.requestId) : []),
+                    ],
+                    warnings: [UNVERIFIED_NOTICE],
+                }
+                : {}),
             ...(blockedItems.length
                 ? {
                     skippedRequestIds: blockedItems.map((item) => item.requestId),
@@ -1572,6 +2222,7 @@ const workflowBatchSupervise = {
             otherReminder: otherReminderIds,
         });
         const batches = chunkArray(requestIds, batchSize);
+        let resultUnverified = false;
         const result = {
             success: true,
             requestIdCount: requestIds.length,
@@ -1594,20 +2245,34 @@ const workflowBatchSupervise = {
             const submitResult = await runWrite('batchSupervise', env, () => env.host.workflowRequest({
                 method: 'POST', path: WORKFLOW_ENDPOINTS.BATCH_SUPERVISE, operation: 'workflow.batchSupervise', body: payload,
             }), payload);
+            // 催办是**唯一**返回批次级计数的批量接口（真机样本：`data.data.{successNum, failNum, resultMessage}`，
+            // 双层嵌套、**没有逐条 ID/标题**）——所以这里不走逐条解析，但**认不出这个结构时不能默认 0 条成功**。
             const inner = submitResult?.data?.data ?? submitResult?.data ?? submitResult;
-            const successNum = Number(inner?.successNum ?? 0);
-            const failNum = Number(inner?.failNum ?? 0);
+            const hasCounters = inner && typeof inner === 'object'
+                && (inner.successNum !== undefined || inner.failNum !== undefined);
+            if (!hasCounters)
+                resultUnverified = true;
+            const successNum = hasCounters ? Number(inner?.successNum ?? 0) : 0;
+            const failNum = hasCounters ? Number(inner?.failNum ?? 0) : 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.status = 'PARTIAL';
+                result.failedCount = result.failNum;
                 result.userMessage = `批量催办第 ${i + 1}/${batches.length} 批部分失败：成功 ${successNum} 条，失败 ${failNum} 条`;
                 await env.continuation.settle(key, result, 'workflow.batchSupervise');
                 return workflowSuccess('workflow.batchSupervise', result);
             }
         }
+        result.status = result.failNum || resultUnverified ? 'PARTIAL' : 'COMPLETE';
+        result.failedCount = result.failNum;
+        if (resultUnverified) {
+            result.unverified = true;
+            result.warnings = [UNVERIFIED_NOTICE];
+        }
         result.userMessage = `已批量催办 ${result.successNum} 条流程。` + (result.failNum ? `失败 ${result.failNum} 条。` : '');
         await env.continuation.settle(key, result, 'workflow.batchSupervise');
         return workflowSuccess('workflow.batchSupervise', result);
@@ -1664,6 +2329,8 @@ const workflowBatchShare = {
             maxSec,
         });
         const sharedIds = [];
+        const shareFailures = [];
+        let shareUnverified = false;
         let lastResult = null;
         for (const batch of chunkArray(sourceItems, batchSize)) {
             const payload = {
@@ -1681,9 +2348,24 @@ const workflowBatchShare = {
                 method: 'POST', path: WORKFLOW_ENDPOINTS.SHARE_ADD, operation: 'workflow.batchShare', body: payload,
             }), payload);
             lastResult = response;
-            sharedIds.push(...batch.map((it) => String(it.requestId)));
+            // ★ 共享的逐条结果在**根级数组**：`data: [{sourceId, result:"true", msg}]`（真机样本；
+            // `result` 是字符串、ID 键名是 `sourceId`）——按它计数，不再按"发出去几条"，
+            // 否则一条都没共享成功也会报成功（与 batchSubmit 的 P0 同源）。
+            const outcome = parseBatchWriteOutcome(response, batch.map((it) => String(it.requestId)));
+            sharedIds.push(...outcome.succeeded);
+            shareFailures.push(...outcome.failed);
+            if (outcome.unverified)
+                shareUnverified = true;
         }
-        const data = { status: 'COMPLETE', sharedCount: sharedIds.length, requestIds: sharedIds, response: lastResult };
+        const failures = await attachFailureTitles(shareFailures, env);
+        const data = {
+            status: failures.length || shareUnverified ? 'PARTIAL' : 'COMPLETE',
+            sharedCount: sharedIds.length,
+            requestIds: sharedIds,
+            ...(failures.length ? { failedCount: failures.length, failures } : {}),
+            ...(shareUnverified ? { unverified: true, warnings: [UNVERIFIED_NOTICE] } : {}),
+            response: lastResult,
+        };
         await env.continuation.settle(key, data, 'workflow.batchShare');
         return workflowSuccess('workflow.batchShare', data);
     },
@@ -1738,6 +2420,8 @@ const workflowBatchForward = {
         });
         const forwardedIds = [];
         let lastResult = null;
+        // 拿不到服务端逐条结果时置位（详见 UNVERIFIED_NOTICE：不确认 ≠ 成功）
+        let forwardUnverified = false;
         for (const batch of chunkArray(sourceItems, batchSize)) {
             const payload = {
                 src: 'forward',
@@ -1767,25 +2451,34 @@ const workflowBatchForward = {
                 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);
-                }
+            // 逐条结果在 `data.submitResult[]`（真机样本：**一层** `body.data`，且**没有** `failMsg`）。
+            // 交给统一解析器：有界深度探测（不写死层级）+ 认布尔/字符串结果 + 取 `requestName`/`requestNameTitle` 作标题。
+            // 旧实现写死 `body.data.data.submitResult`，比真实结构**多解一层** ⇒ 成功也被判成"无法确认"。
+            const outcome = parseBatchWriteOutcome(response, batch.map((it) => String(it.requestId)));
+            forwardedIds.push(...outcome.succeeded);
+            if (outcome.unverified)
+                forwardUnverified = true;
+            if (outcome.failed.length) {
+                const failed = await attachFailureTitles(outcome.failed, env);
+                const partial = {
+                    status: 'PARTIAL',
+                    success: false,
+                    forwardedCount: forwardedIds.length,
+                    failedCount: failed.length,
+                    failures: failed,
+                    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 };
+        const data = {
+            status: forwardUnverified ? 'PARTIAL' : 'COMPLETE',
+            forwardedCount: forwardedIds.length,
+            requestIds: forwardedIds,
+            response: lastResult,
+            ...(forwardUnverified ? { unverified: true, warnings: [UNVERIFIED_NOTICE] } : {}),
+        };
         await env.continuation.settle(key, data, 'workflow.batchForward');
         return workflowSuccess('workflow.batchForward', data);
     },
@@ -1823,6 +2516,7 @@ const workflowBatchReject = {
         const key = await claimBatchWrite(env, 'workflow.batchReject', requestIds);
         const rejectedIds = [];
         let lastResult = null;
+        let rejectUnverified = false;
         for (const batch of chunkArray(sourceItems, batchSize)) {
             const payload = {
                 isMobile: false,
@@ -1844,25 +2538,33 @@ const workflowBatchReject = {
                 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);
-                }
+            // 逐条结果在 `data.operateResult[]` + `data.failMsg`（真机样本：同样是**一层** `body.data`，
+            // 且退回比转发多一个 `failMsg` 映射）——统一解析器两种都认，还会补上标题。
+            const outcome = parseBatchWriteOutcome(response, batch.map((it) => String(it.requestId)));
+            rejectedIds.push(...outcome.succeeded);
+            if (outcome.unverified)
+                rejectUnverified = true;
+            if (outcome.failed.length) {
+                const failed = await attachFailureTitles(outcome.failed, env);
+                const partial = {
+                    status: 'PARTIAL',
+                    success: false,
+                    rejectedCount: rejectedIds.length,
+                    failedCount: failed.length,
+                    failures: failed,
+                    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 };
+        const data = {
+            status: rejectUnverified ? 'PARTIAL' : 'COMPLETE',
+            rejectedCount: rejectedIds.length,
+            requestIds: rejectedIds,
+            response: lastResult,
+            ...(rejectUnverified ? { unverified: true, warnings: [UNVERIFIED_NOTICE] } : {}),
+        };
         await env.continuation.settle(key, data, 'workflow.batchReject');
         return workflowSuccess('workflow.batchReject', data);
     },
@@ -1981,11 +2683,13 @@ export const workflowWriteOperations = [
     workflowOperateApply,
     workflowSharePrepare,
     workflowShareApply,
-    workflowBatchSubmit,
-    workflowBatchRead,
-    workflowBatchSupervise,
-    workflowBatchShare,
-    workflowBatchForward,
-    workflowBatchReject,
+    // 6 个单命令批量操作统一挂「范围驱动」（scopeCondition / action / exRequestIds）；
+    // 走 requestIds 时行为与以往完全一致。
+    withBatchScopeDriver(workflowBatchSubmit, 'SUBMIT'),
+    withBatchScopeDriver(workflowBatchRead, 'READ'),
+    withBatchScopeDriver(workflowBatchSupervise, 'URGE'),
+    withBatchScopeDriver(workflowBatchShare, 'SHARE'),
+    withBatchScopeDriver(workflowBatchForward, 'FORWARD'),
+    withBatchScopeDriver(workflowBatchReject, 'REJECT'),
     workflowMemoryExtract,
 ];