weaver-work-cli 0.1.5 → 0.1.7

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

@@ -0,0 +1,3778 @@
+// E10 工作流「查询/查看」类 operation 集合。
+//
+// 移植自 Python skill `scripts/e10_workflow.py`，唯一事实来源，严禁臆造接口/字段。
+// 仅实现 8 个面向模型的高层 operation；query-dependency / relate-name2id / raw-* 等
+// 内部步骤内联进对应 operation，不单独暴露。
+//
+// 顺序定位约定：查询类 operation 把"序号 → requestId"写入本地检索索引
+// （saveSearchIndex / findIndexedItem，由 CLI 托管，本文件不读写索引文件）；
+// 查看/操作类 operation 允许用 requestId 或 group+index 定位（findIndexedItem）。
+import { workflowSuccess, schemaOf, SCHEMA_REQUEST_ID, SCHEMA_CATEGORY, SCHEMA_INDEX, SCHEMA_PAGE_SIZE, } from './types.js';
+import { asString, asInt, asStringArray, asBool, compact, responseData, toArray, resolveMemoryAppId, withLeadingMeta, STDOUT_SAFE_BYTES, stdoutBytesOf, } from './shared.js';
+import { workflowValidationError, WorkflowCliError, workflowClarificationError, CLARIFICATION_SUBTYPE, } from '../errors.js';
+import { WORKFLOW_ENDPOINTS } from '../endpoints.js';
+import { loadSearchIndex, saveSearchIndex, findIndexedItem, readStateFile, writeStateFileBestEffort, } from '../state.js';
+const ENDPOINT_PREFIX = {
+    todo: 'TODO',
+    done: 'DONE',
+    mine: 'MINE',
+    all: 'ALL',
+};
+const DEFAULT_TABID = {
+    todo: '0',
+    done: '50',
+    mine: '100',
+    all: '300',
+};
+// 子分类别名 → tabid（来源：WORKFLOW_CATEGORIES.tabs）
+const SUB_CATEGORY_TABS = {
+    todo: {
+        全部: '0', 待处理: '7', 未读: '1', 新反馈: '2', 已查阅: '3', 待阅: '5', 超时: '6',
+        被退回: '8', 转发: '4', 传阅: '11', 抄送: '9', 关注: '10', 被督办: '12', 被转办: '13', 草稿: '14',
+    },
+    done: {
+        全部: '50', 审批中: '52', 已结束: '51', 待回复: '60', 未读: '61', 已处理: '53', 新反馈: '62',
+        已阅: '54', 关注: '63', 抄送: '55', 转发: '56', 传阅: '57', 超时已办: '58', 超时自动处理: '59',
+        已审批: '64', 待退回: '65', 暂停: '66',
+    },
+    mine: {
+        全部: '100', 审批中: '102', 新反馈: '101', 已结束: '103', 未读: '104', 关注: '105', 暂停: '120',
+    },
+    all: { 全部: '300', 审批中: '303', 已结束: '304' },
+};
+const CATEGORY_NAMES = {
+    todo: '待办',
+    done: '已办',
+    mine: '我发起的',
+    all: '全部流程',
+};
+// 排序：排序方式名 → 接口 orderkey（来源：Python WORKFLOW_SORT_OPTIONS，L590，穷举全量）。
+// 仅中文键名（Python 无英文别名）；sortType 必须显式 asc/desc（无默认方向），与 Python parse_sort_params 一致。
+const SORT_OPTIONS = {
+    当前节点: -45, 发起人: -15, 发起时间: -20, 所属工作流: -40, 接收时间: -25,
+    最后反馈时间: -175, 紧急程度: -55, 流程编号: -70, 流程标题: -10, 操作时间: -30, 结束时间: -35,
+};
+// plan 批量编排：特殊组槽位 tabid（来源：Python _PLAN_SLOT_TABID，L12882）
+const PLAN_SLOT_TABID = { overtime: '6', urgent: '0', forward: '4' };
+const PLAN_MAX_GROUPS = 8;
+// plan 支持的特殊组类型（来源：Python _PLAN_SPECIAL_GROUP_TYPES，L12883）——传未知类型必须报错，不能静默丢弃
+const PLAN_SPECIAL_GROUP_TYPES = ['urgentOvertime', 'forwardToSelf'];
+// 展开组草稿口径（来源：Python _PLAN_GROUP_DRAFT_LABELS）
+const PLAN_GROUP_DRAFT_LABELS = new Set(['草稿', '待提交']);
+// todo-stat 写死的 attentionFormFields（来源：Python cmd_workflow_todo_stat，L11780）
+const STAT_ATTENTION_FORM_FIELDS = [
+    { workflowId: '100003460000000485', fieldIds: ['100003720000009575', '100003720000009533'] },
+    { workflowId: '100003460000001155', fieldIds: ['100003720000022823', '100003720000022821'] },
+    { workflowId: '100003460000000060', fieldIds: ['100003720000000088', '100003720000000080'] },
+    { workflowId: '100003460000002579', fieldIds: ['100003720000110935', '100003720000009237'] },
+    { workflowId: '1047847083988836355', fieldIds: ['100501870166669555'] },
+];
+// ---------------------------------------------------------------------------
+// 工具函数
+// ---------------------------------------------------------------------------
+function pickText(source, ...keys) {
+    if (!source || typeof source !== 'object')
+        return '';
+    const record = source;
+    for (const key of keys) {
+        const value = record[key];
+        if (value !== undefined && value !== null && String(value).trim() !== '') {
+            return String(value).trim();
+        }
+    }
+    return '';
+}
+function pickRaw(source, ...keys) {
+    if (!source || typeof source !== 'object')
+        return undefined;
+    const record = source;
+    for (const key of keys) {
+        if (record[key] !== undefined)
+            return record[key];
+    }
+    return undefined;
+}
+/** 流程状态文本（来源：Python flow_status_text） */
+function flowStatusText(value) {
+    if (value && typeof value === 'object')
+        return pickText(value, 'desc', 'name', 'label', 'text', 'value');
+    return stripHtml(value);
+}
+/** 紧急程度文本（来源：Python request_level_text） */
+function requestLevelText(value) {
+    const text = stripHtml(value);
+    if (text === '0' || text === '正常')
+        return '正常';
+    if (text === '1' || text === '重要')
+        return '重要';
+    if (text === '2' || text === '紧急')
+        return '紧急';
+    return text;
+}
+/** 解析 OA 返回的本地时间文本（来源：Python parse_local_datetime） */
+function parseLocalDateTime(value) {
+    let text = stripHtml(value);
+    if (!text)
+        return null;
+    text = text.replace(/T/g, ' ').replace(/\//g, '-').trim();
+    text = text.replace(/\.\d+/g, '');
+    text = text.replace(/(Z|[+-]\d{2}:?\d{2})$/, '').trim();
+    const match = /^(\d{4})-(\d{2})-(\d{2})(?:[ ](\d{2}):(\d{2})(?::(\d{2}))?)?$/.exec(text);
+    if (!match)
+        return null;
+    const parsed = new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]), Number(match[4] ?? 0), Number(match[5] ?? 0), Number(match[6] ?? 0));
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+/** 距今时长的人话表达（来源：Python humanize_duration_since） */
+function humanizeDurationSince(value) {
+    const start = parseLocalDateTime(value);
+    if (!start)
+        return '';
+    const seconds = Math.floor((Date.now() - start.getTime()) / 1000);
+    if (seconds < 0)
+        return '';
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 1)
+        return '刚刚';
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days >= 1) {
+        const remainHours = hours % 24;
+        return remainHours ? `${days}天${remainHours}小时` : `${days}天`;
+    }
+    if (hours >= 1) {
+        const remainMinutes = minutes % 60;
+        return remainMinutes ? `${hours}小时${remainMinutes}分钟` : `${hours}小时`;
+    }
+    return `${minutes}分钟`;
+}
+const BADGE_STYLES = {
+    danger: 'background:#FFF1F0;color:#D93025;border:1px solid #FFA39E;',
+    warning: 'background:#FFF7E6;color:#AD6800;border:1px solid #FFD591;',
+    info: 'background:#E6F0FF;color:#1D4ED8;border:1px solid #A7C7FF;',
+    neutral: 'background:#F4F6F8;color:#5F6B7A;border:1px solid #D8DEE6;',
+};
+/** 常规状态不显示徽标（来源：Python REGULAR_STATUS_BADGES） */
+const REGULAR_STATUS_BADGES = new Set(['审批中', '处理中', '待处理']);
+/** 徽标颜色类型（来源：Python badge_type） */
+function badgeType(label) {
+    if (label === '已超时')
+        return 'danger';
+    if (label === '已结束' || label === '结束')
+        return 'neutral';
+    if (label === '草稿' || label === '待提交')
+        return 'warning';
+    if (REGULAR_STATUS_BADGES.has(label))
+        return 'info';
+    return 'neutral';
+}
+function buildBadgeObjects(labels) {
+    return labels.map((label) => {
+        const kind = badgeType(label);
+        return { text: label, type: kind, style: BADGE_STYLES[kind] };
+    });
+}
+/** 流程状态是否值得显示徽标（来源：Python should_display_flow_status_badge） */
+function shouldDisplayFlowStatusBadge(label) {
+    const text = stripHtml(label);
+    if (!text)
+        return false;
+    if (REGULAR_STATUS_BADGES.has(text))
+        return false;
+    if (text.startsWith('审批中'))
+        return false;
+    return true;
+}
+/** 卡片第三行元信息，按 category 选字段（来源：Python build_card_meta） */
+function buildCardMeta(item, category) {
+    let candidates;
+    if (category === 'mine') {
+        candidates = [
+            ['当前节点', item.currentNode],
+            ['发起时间', item.createdAt],
+        ];
+    }
+    else if (category === 'todo') {
+        candidates = [
+            ['发起人', item.creatorName],
+            ['当前节点', item.currentNode],
+            ['停留时长', item.stayDuration],
+        ];
+    }
+    else {
+        candidates = [
+            ['发起人', item.creatorName],
+            ['当前节点', item.currentNode],
+            ['发起时间', item.createdAt],
+        ];
+    }
+    return candidates
+        .map(([label, value]) => ({ label, value: asString(value) ?? '' }))
+        .filter((pair) => pair.value);
+}
+/** 卡片标题点击跳转 OA 详情页 URL（来源：Python card_workflow_open_url） */
+function cardWorkflowOpenUrl(card, baseUrl) {
+    const internal = card.internal || {};
+    const requestId = asString(internal.requestId) ?? '';
+    if (!requestId)
+        return '';
+    const root = baseUrl.replace(/\/+$/, '');
+    if (!root)
+        return '';
+    const userMasterId = asString(internal.userMasterId) ?? '';
+    const base = `${root}/sp/workflow/flowpage/view/${encodeURIComponent(requestId)}`;
+    return userMasterId
+        ? `${base}?secondEmpId=${encodeURIComponent(userMasterId)}&requestId=${encodeURIComponent(requestId)}`
+        : base;
+}
+/** 解析 "名称(ID)" 或纯 ID / 纯名称 → (name, id)。ID 必须是纯数字才认定为 ID。 */
+function parseNameWithId(value) {
+    const text = (value || '').trim();
+    if (!text)
+        return { name: '' };
+    const match = /^(.+?)[（(]([^（）()]*)[)）]\s*$/.exec(text);
+    if (match) {
+        const name = match[1].trim();
+        const idPart = match[2].trim();
+        if (name && idPart && /^[0-9]+$/.test(idPart)) {
+            return { name, id: idPart };
+        }
+    }
+    return { name: text };
+}
+function splitCsv(value) {
+    if (value === undefined || value === null)
+        return [];
+    const text = String(value).trim();
+    if (!text)
+        return [];
+    return text.split(',').map((item) => item.trim()).filter(Boolean);
+}
+// ---------------------------------------------------------------------------
+// 时间条件取值（口径与 V11.3 完全一致）
+//
+// 取值一律是「开始 结束」：YYYY-MM-DD，单边留空串表示该端不限；只写一个值（两侧无空白）
+// 会被补成 "值 值"，限到当天。**不接受相对日期词**（"本周/上月/近7天"）——脚本不做中文时间
+// 归一化，模型需自己换算成具体日期后传入（来源：Python workflow_intent_from_args +
+// build_system_date_conditions，V11.3 明确"相对时间词/触发词/绝对日期均不再自动提取"）。
+//
+// 非法取值（格式不符 / 2026-02-30 / start > end）按 V11.3 **静默丢弃该条件**，
+// 查询继续执行——不抛错、不把原文透传给服务端。
+// ---------------------------------------------------------------------------
+/** 严格校验 YYYY-MM-DD 且为真实日期（来源：Python date.fromisoformat + validate_date_content）。 */
+function isValidIsoDate(text) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/u.exec(text);
+    if (!match)
+        return false;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    if (month < 1 || month > 12 || day < 1 || day > 31)
+        return false;
+    const date = new Date(year, month - 1, day);
+    // 反校验：2026-02-30 会被 Date 归一化成 03-02，必须判非法
+    return date.getFullYear() === year && date.getMonth() === month - 1 && date.getDate() === day;
+}
+/**
+ * 单边取值 → 日期串。空串原样返回（该端不限）；非法返回 null。
+ * 调用方按 V11.3 语义决定：时间窗条件丢弃该条件，表单日期字段报错。
+ */
+function resolveDateBound(raw) {
+    const text = (raw === undefined || raw === null ? '' : String(raw)).trim();
+    if (!text)
+        return '';
+    return isValidIsoDate(text) ? text : null;
+}
+/**
+ * "开始 结束"（YYYY-MM-DD，单边可空串）；单值（两侧无空白）自动补成 "值 值"（限到当天）。
+ *
+ * 切分必须基于**原始串**判断有没有第二个空格——先 trim 会把 `"2026-08-01 "`（开放右边界）
+ * 误判成单值、把范围收窄到当天（来源：Python parse_time_span_parts）。
+ *
+ * 任一边非法或 start > end → null（V11.3 静默丢弃该条件，查询继续）。
+ */
+function parseDateRange(value) {
+    if (value === undefined || value === null)
+        return null;
+    const raw = String(value);
+    const matched = /^(\S*)\s+(.*)$/su.exec(raw);
+    const start = resolveDateBound(matched ? matched[1] : raw);
+    const end = resolveDateBound(matched ? matched[2] : raw);
+    if (start === null || end === null)
+        return null;
+    if (!start && !end)
+        return null;
+    if (start && end && start > end)
+        return null;
+    return [start, end];
+}
+/** 四个时间窗参数的取值说明（原文照抄 V11.3 argparse help，参数名适配为 schema 字段名） */
+const TIME_DESCRIPTIONS = {
+    createTime: "发起时间条件：'开始 结束'（YYYY-MM-DD），单边用空串，如 '2026-08-01 2026-08-07' 或 ' 2026-08-07'",
+    operateTime: "操作时间条件：'开始 结束'（YYYY-MM-DD），单边用空串；待办（todo）分类下此条件会被忽略（待办=还未处理）",
+    receiveTime: "接收时间条件：'开始 结束'（YYYY-MM-DD），单边用空串，如 '2026-08-07 2026-08-07'（\"今天提交到我待办的\"→receiveTime）",
+    finishTime: "完成/办结时间条件：'开始 结束'（YYYY-MM-DD），单边用空串",
+};
+const SYSTEM_FIELDS = {
+    workflowid: {
+        endpoint: WORKFLOW_ENDPOINTS.WORKFLOW_PATH_BROWSER,
+        extra: { browserMultiple: true, bridgeService: '' },
+    },
+    creator: {
+        endpoint: WORKFLOW_ENDPOINTS.RESOURCE_BROWSER,
+        extra: {
+            browserMultiple: true,
+            authWecahtBook: false,
+            wxDepNeedConvertCount: 0,
+            wxEmpNeedConvertCount: 0,
+            wxTotalNeedConvertCount: 0,
+        },
+    },
+    creatordept: { endpoint: WORKFLOW_ENDPOINTS.DEPT_BROWSER, extra: { browserMultiple: true } },
+    creatorsubcom: { endpoint: WORKFLOW_ENDPOINTS.SUBCOMPANY_BROWSER, extra: { browserMultiple: true } },
+    workflowtype: { endpoint: WORKFLOW_ENDPOINTS.WORKFLOW_TYPE_BROWSER, extra: { browserMultiple: true } },
+};
+/**
+ * 调 browser complete 做名称转 ID，返回**全部**候选 `{id, name}`（0/1/多）。
+ * 请求失败按 0 命中处理（不阻断主流程，由调用方决定报错还是澄清）。
+ */
+async function resolveNameCandidates(env, config, keyword) {
+    const text = (keyword || '').trim();
+    if (!text)
+        return [];
+    const body = compact({ browserMultiple: true, newly: 1, searchValue: text, ...config.extra });
+    let response;
+    try {
+        response = await env.host.workflowRequest({
+            method: 'POST',
+            path: config.endpoint,
+            operation: 'workflow.nameComplete',
+            body,
+        });
+    }
+    catch (error) {
+        // 认证/网络错误不得当成"0 命中"——否则登录过期会被报成「工作流名称不存在」（见 rethrowAuthOrNetworkError）
+        rethrowAuthOrNetworkError(error);
+        return [];
+    }
+    const data = responseData(response);
+    const list = toArray(data?.data?.data ?? data?.data ?? data);
+    const resolved = [];
+    const seen = new Set();
+    for (const item of list) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const id = pickText(item, 'id');
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        resolved.push({ id, name: pickText(item, 'name', 'content') || text });
+    }
+    return resolved;
+}
+/** 发起人自称词（= 当前用户，跳过名称匹配；来源：Python SELF_KEYWORDS）。 */
+const CREATOR_SELF_TERMS = new Set(['我', '我的', '本人', '我自己', '当前用户', '自己']);
+/**
+ * 系统字段 → 澄清标识（对齐 V11.3 `name2id_clarification`，L8244：
+ * `clarificationType = f"system_relate_name2id_{system_field}"`）。
+ *
+ * 例外：`--workflow` 的**纳入**条件在 V11.3 用的是简写 `workflow`（L10393，工作流主实体块）；
+ * `system_relate_name2id_workflowid` 只出现在排除条件里（且被 `workflow_name_exclusion` 覆盖）。
+ */
+const SYSTEM_CLARIFICATION_TYPES = {
+    workflowid: 'workflow',
+    creator: 'system_relate_name2id_creator',
+    creatordept: 'system_relate_name2id_creatordept',
+    creatorsubcom: 'system_relate_name2id_creatorsubcom',
+    workflowtype: 'system_relate_name2id_workflowtype',
+};
+/** 候选 → 澄清载荷（`display` 即用户确认后回传的 `名称(ID)` 格式）。 */
+function clarificationCandidates(items, limit) {
+    return items.slice(0, limit).map((item, index) => ({
+        index: index + 1,
+        id: item.id,
+        name: item.name,
+        display: `${item.name}(${item.id})`,
+    }));
+}
+/**
+ * 系统字段名称 → ID。
+ *
+ * 解析结果直接决定查询条件是否生效，因此**不允许静默降级**——但"澄清"与"失败"的边界
+ * **逐字对齐 V11.3**（不是整类都澄清）：
+ * - **`--workflow` 名 0 命中 → 澄清**（`e10_workflow.py:10356-10375`：`success:true` +
+ *   `needClarification:true` + `clarificationQuestion`，**不带候选**）；
+ * - **其余系统字段（发起人/部门/分部/工作流类型）0 命中 → 失败**
+ *   （`:10924-10927` `fail("系统字段名称转 ID 未匹配到数据", systemField=…, keyword=…)`）；
+ * - **多命中 → 澄清**并列出候选（`name2id_clarification`，`:8223-8244`；工作流名走 `:10382-10400`）；
+ * - 多命中但**有唯一全名精确匹配**（`normalize_compare_text` 口径）→ 直接用，不澄清。
+ */
+async function resolveTerm(env, systemKey, rawValue, label) {
+    const text = asString(rawValue);
+    if (!text)
+        return null;
+    const parsed = parseNameWithId(text);
+    if (parsed.id)
+        return { id: parsed.id, name: parsed.name || text };
+    if (systemKey === 'creator' && CREATOR_SELF_TERMS.has(text))
+        return null;
+    const candidates = await resolveNameCandidates(env, SYSTEM_FIELDS[systemKey], text);
+    const clarificationType = SYSTEM_CLARIFICATION_TYPES[systemKey];
+    if (!candidates.length) {
+        // 0 命中：只有 --workflow 澄清，其余系统字段一律失败（V11.3 口径）
+        if (systemKey === 'workflowid') {
+            throw workflowClarificationError(clarificationType, text, `${label}「${text}」未匹配到任何对象。请核对名称（是否写错字/少了字），`
+                + `或提供准确的完整名称（也可直接给工作流 ID）后再查。`);
+        }
+        throw workflowValidationError(`${systemKey}_not_found`, `${label}「${text}」未匹配到任何对象（该筛选条件不会生效，继续执行会返回不含该条件的全量数据），`
+            + '本次查询已停止。请核对名称，或改用「名称(ID)」/ 数字 ID 后重发。');
+    }
+    const exact = candidates.filter((item) => item.name.trim().toLowerCase() === text.trim().toLowerCase());
+    if (exact.length === 1)
+        return exact[0];
+    if (candidates.length === 1)
+        return candidates[0];
+    // 多命中：优先用全名精确匹配的那一批（对齐 V11.3 的 exact_candidates 优选）
+    const selected = exact.length ? exact : candidates;
+    if (selected.length === 1)
+        return selected[0];
+    throw workflowClarificationError(clarificationType, text, `${label}「${text}」匹配到 ${selected.length} 个候选项，请确认要查询的具体${label}。`, clarificationCandidates(selected, 10));
+}
+/**
+ * 读取当前环境的紧急程度列表（来源：Python QUERY_DEPENDENCY → data.requestLevelList）。
+ *
+ * **字段名是 `levelName`**（不是 `name`/`showname`）——写错会让整个列表解析为空，
+ * 进而让紧急程度条件被静默丢弃（退化为全量查询且看不出来）。
+ */
+async function fetchRequestLevels(env) {
+    const response = await env.host.workflowRequest({
+        method: 'GET',
+        path: WORKFLOW_ENDPOINTS.QUERY_DEPENDENCY,
+        operation: 'workflow.queryDependency',
+    });
+    const data = responseData(response);
+    const list = toArray(data?.requestLevelList ?? data?.data?.requestLevelList);
+    const levels = [];
+    const seen = new Set();
+    for (const item of list) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const id = pickText(item, 'id');
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        levels.push({ id, name: pickText(item, 'levelName', 'name') });
+    }
+    return levels;
+}
+/**
+ * 紧急程度名称 → requestLevelList 中的 id（来源：Python request_level_condition，L8313）。
+ *
+ * 解析结果决定查询条件是否生效，因此**不允许静默降级**（旧实现用 `catch {}` 静默丢弃该条件，
+ * 使「按紧急程度筛选」退化为不筛选）。澄清/失败边界**逐字对齐 V11.3**：
+ * - `名称(ID)`（澄清回传）/ 纯数字 ID → 直接取 ID；
+ * - 名称唯一命中 → 用其 id；
+ * - **多命中 → 澄清**（`system_relate_name2id_requestlevel` + 候选，对齐 V11.3 L8352-8363）；
+ * - **0 命中 → 失败**（V11.3 `:10938-10939` `fail("紧急程度未匹配到等级数据")`；可选等级写在
+ *   message 里，不另给结构化候选）；
+ * - 列表接口拿不到数据 / 列表为空 → 抛 `requestlevel_unavailable`（V11.3 同样 `fail`）。
+ */
+async function resolveRequestLevel(env, rawValue) {
+    const text = asString(rawValue);
+    if (!text)
+        return null;
+    const parsed = parseNameWithId(text);
+    if (parsed.id)
+        return parsed.id;
+    if (/^[0-9]+$/.test(text))
+        return text;
+    let levels = [];
+    try {
+        levels = await fetchRequestLevels(env);
+    }
+    catch (error) {
+        rethrowAuthOrNetworkError(error);
+        throw workflowValidationError('requestlevel_unavailable', `未能读取当前环境的紧急程度列表（接口无返回），无法解析紧急程度「${text}」，本次查询已停止。请稍后重试。`);
+    }
+    if (!levels.length) {
+        throw workflowValidationError('requestlevel_unavailable', `当前环境的紧急程度列表为空，无法解析紧急程度「${text}」，本次查询已停止。`);
+    }
+    const matched = levels.filter((level) => level.name && level.name.includes(text));
+    if (matched.length === 1)
+        return matched[0].id;
+    const listed = levels.map((level, index) => `${index + 1}. ${level.name}(${level.id})`).join('；');
+    if (matched.length > 1) {
+        // 多命中时**先按全名精确匹配优选**（与 resolveTerm / createList 同一套判据）：
+        // 候选里有唯一的 equals 项就直接用，不必让用户在"紧急"与"特急紧急"之间做选择。
+        const exact = matched.filter((level) => level.name.trim().toLowerCase() === text.trim().toLowerCase());
+        if (exact.length === 1)
+            return exact[0].id;
+        const selected = exact.length ? exact : matched;
+        throw workflowClarificationError('system_relate_name2id_requestlevel', text, `紧急程度「${text}」匹配到 ${selected.length} 个等级，请确认要查询的具体等级。`, clarificationCandidates(selected, 10));
+    }
+    throw workflowValidationError('requestlevel_not_found', `紧急程度「${text}」未匹配到任何等级（该筛选条件不会生效），本次查询已停止。`
+        + `当前环境可选等级：${listed}。请核对后改用「名称(ID)」重发。`);
+}
+/** 时间条件 → formDatas 顶层键（来源：Python MEMORY_DATE_FORM_KEYS）。取值非法时按 V11.3 静默丢弃该条件。 */
+function applyTimeCondition(formDatas, fieldKey, raw) {
+    const range = parseDateRange(raw);
+    if (!range)
+        return;
+    formDatas[fieldKey] = [{ dateContent: range, term: 'like' }];
+}
+// ---------------------------------------------------------------------------
+// 表单字段筛选（filterFields）——字段名 → 真实字段解析 + 按类型生成 filterFormDatas 项
+//
+// 来源：Python fetch_search_ad_fields / build_model_filter_fields /
+// workflow_field_condition_clarification（L7031/L7096/L7596/L9842）。
+//
+// 铁律：**filterFormDatas 项必须带 componentKey + fieldId**——服务端只认这两个键，
+// 只传 fieldName 会被服务端**静默忽略**（条件蒸发、返回未筛选的全量数据且不报错，
+// 实测 `{"fieldName":"报销总金额",...}` 与不传条件返回条数完全一致）。
+// 因此字段名解析不出来时一律报错让模型与用户澄清，**绝不原样直传**。
+// ---------------------------------------------------------------------------
+/** 文本类组件（值走 content） */
+const TEXT_FIELD_COMPONENT_KEYS = new Set(['Text', 'TextArea', 'Email', 'Phone', 'Mobile', 'IDCard']);
+/** 数值/金额类组件（值走 numberContent{min,max}） */
+const NUMBER_FIELD_COMPONENT_KEYS = new Set(['NumberComponent', 'Money']);
+/** 金额类组件：严格边界步长 0.01，其余数值 0.000001（来源：Python adjust_exclusive_number_bound） */
+const MONEY_FIELD_COMPONENT_KEYS = new Set(['Money']);
+/** 日期类组件（值走 dateContent[开始,结束]） */
+const DATE_FIELD_COMPONENT_KEYS = new Set(['DateComponent']);
+const TEXT_FIELD_TERMS = new Set(['like', 'notlike', 'eq', 'ne', 'null', 'notnull']);
+const NUMBER_FIELD_TERMS = new Set(['like', 'gt', 'gte', 'lt', 'lte', 'null', 'notnull']);
+const DATE_FIELD_TERMS = new Set(['like', 'null', 'notnull']);
+const RELATE_FIELD_TERMS = new Set(['eq', 'ne', 'in', 'null', 'notnull']);
+/** 中文/别名 term → 规范 term */
+const FILTER_TERM_ALIASES = {
+    等于: 'eq', 不等于: 'ne', 属于: 'in', 包含: 'like', 不包含: 'notlike',
+    大于: 'gt', 大于等于: 'gte', 小于: 'lt', 小于等于: 'lte',
+};
+/** 字段元数据进程内缓存（每次 CLI 调用一个进程；同一次 plan 多组查询可复用）。 */
+const SEARCH_AD_FIELDS_CACHE = new Map();
+const SEARCH_AD_FIELDS_CACHE_MAX = 8;
+/**
+ * 取某工作流可用的表单查询字段（来源：Python fetch_search_ad_fields，L9842）。
+ *
+ * 接口：`getListSearchAdWithForm`；表单字段在 `data.layout[1]`（`layout[0]` 是系统字段），
+ * 每个字段的组件类型/浏览按钮信息在 `items["<fieldId>Content"]` / `items["<fieldId>_item"]`。
+ */
+async function fetchWorkflowSearchFields(env, workflowId, category, tabid) {
+    const cacheKey = `${category}|${tabid}|${workflowId}`;
+    const cached = SEARCH_AD_FIELDS_CACHE.get(cacheKey);
+    if (cached)
+        return cached;
+    let response;
+    try {
+        response = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS.SEARCH_AD_WITH_FORM,
+            operation: 'workflow.searchAdWithForm',
+            body: {
+                dimension: String(category || 'todo'),
+                searchAdWorkflowid: String(workflowId),
+                fromWfList: true,
+                tabid: String(tabid === undefined || tabid === null || tabid === '' ? '0' : tabid),
+            },
+        });
+    }
+    catch (error) {
+        rethrowAuthOrNetworkError(error);
+        // V11.3 口径（`e10_workflow.py:7045-7056`）：字段元数据**读不到**时返回
+        // `needClarification:true`（不带候选），把归因指向数据/环境问题——而不是判失败让模型
+        // 继续猜字段名，陷入"猜字段名-失败-再猜"的无解循环。
+        throw workflowClarificationError('field_meta', workflowId, `已匹配到工作流「${workflowId}」，但暂时无法获取其表单字段清单（表单查询字段接口无返回）。`
+            + '请稍后重试；若持续失败，请确认该工作流是否有可用的表单字段数据。');
+    }
+    const data = responseData(response);
+    const items = (data?.items && typeof data.items === 'object' ? data.items : {});
+    const layout = toArray(data?.layout);
+    const segment = toArray(layout.length > 1 ? layout[1] : layout[layout.length - 1]);
+    const fields = [];
+    const seenIds = new Set();
+    for (const entry of segment) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const fieldId = pickText(entry, 'id');
+        const label = pickText(entry, 'label');
+        if (!fieldId || !label || seenIds.has(fieldId))
+            continue;
+        seenIds.add(fieldId);
+        const contentItem = (items[`${fieldId}Content`] && typeof items[`${fieldId}Content`] === 'object'
+            ? items[`${fieldId}Content`] : {});
+        const itemItem = (items[`${fieldId}_item`] && typeof items[`${fieldId}_item`] === 'object'
+            ? items[`${fieldId}_item`] : {});
+        const contentParams = (contentItem.customParameters && typeof contentItem.customParameters === 'object'
+            ? contentItem.customParameters : {});
+        const itemParams = (itemItem.customParameters && typeof itemItem.customParameters === 'object'
+            ? itemItem.customParameters : {});
+        // V11.3 是 `field.get("browserBean")` 的真值判断——**空对象 `{}` 在 Python 里是 False**，
+        // 而 JS 的 `Boolean({})` 恒为 true。这里必须判"非空对象"，否则一个空的 browserBean 会让
+        // 该字段（Python 里会被跳过）被判成浏览按钮字段，筛选值走 name→ID 后误报未匹配。
+        const rawBrowserBean = contentItem.browserBean;
+        const browserBean = (rawBrowserBean && typeof rawBrowserBean === 'object'
+            && Object.keys(rawBrowserBean).length > 0)
+            ? rawBrowserBean : undefined;
+        let componentKey = pickText(contentParams, 'componentKey') || pickText(itemParams, 'componentKey');
+        if (!componentKey && browserBean)
+            componentKey = 'BROWSER';
+        if (!componentKey)
+            continue;
+        const baseName = label.split('.')[0].trim();
+        const matchNames = baseName && baseName !== label ? [label, baseName] : [label];
+        const meta = { fieldId, fieldName: label, matchNames, componentKey };
+        if (browserBean) {
+            meta.browserBean = {
+                module: pickText(browserBean, 'module'),
+                type: pickText(browserBean, 'type'),
+                commonParams: (browserBean.commonParams && typeof browserBean.commonParams === 'object')
+                    ? browserBean.commonParams : undefined,
+            };
+        }
+        fields.push(meta);
+    }
+    if (SEARCH_AD_FIELDS_CACHE.size >= SEARCH_AD_FIELDS_CACHE_MAX)
+        SEARCH_AD_FIELDS_CACHE.clear();
+    SEARCH_AD_FIELDS_CACHE.set(cacheKey, fields);
+    return fields;
+}
+function fieldCandidateItem(field, index) {
+    return {
+        index,
+        fieldId: field.fieldId,
+        fieldName: field.fieldName,
+        componentKey: field.componentKey,
+        display: `${field.fieldName}(${field.fieldId})`,
+    };
+}
+/** 候选字段清单：优先列名称与请求词有共同字/被请求词包含的字段，再补足到 limit 个。 */
+function fieldCandidateList(fields, requested, limit = 12) {
+    const chars = [...new Set([...requested].filter((c) => /[\u4e00-\u9fa5A-Za-z0-9]/.test(c)))];
+    const scored = fields.map((field) => {
+        const names = field.matchNames.join('|');
+        let score = 0;
+        for (const c of chars)
+            if (names.includes(c))
+                score += 1;
+        if (names.includes(requested))
+            score += 5;
+        return { score, field };
+    });
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, limit).map((item, index) => fieldCandidateItem(item.field, index + 1));
+}
+/** 严格边界调整：gt → 下界 + 步长，lt → 上界 − 步长（来源：Python adjust_exclusive_number_bound）。 */
+function adjustExclusiveBound(rawValue, isMoney, direction) {
+    const num = Number(rawValue);
+    if (!Number.isFinite(num))
+        return rawValue;
+    const step = isMoney ? 0.01 : 0.000001;
+    const adjusted = direction === 'min' ? num + step : num - step;
+    return isMoney ? adjusted.toFixed(2) : String(Number(adjusted.toFixed(6)));
+}
+/** 表单浏览按钮字段取值候选（来源：Python form_browser_complete_candidates）。 */
+async function fetchFieldValueCandidates(env, field, keyword) {
+    const bean = field.browserBean;
+    const module = asString(bean?.module) ?? '';
+    const type = asString(bean?.type) ?? '';
+    if (!module || !type)
+        return [];
+    const body = {
+        ...(bean?.commonParams ?? {}),
+        browserMultiple: true,
+        newly: 1,
+        searchValue: keyword,
+    };
+    let response;
+    try {
+        response = await env.host.workflowRequest({
+            method: 'POST',
+            path: `/api/${module}/common/browser/complete/${type}`,
+            operation: 'workflow.fieldValueComplete',
+            body,
+        });
+    }
+    catch (error) {
+        rethrowAuthOrNetworkError(error);
+        throw workflowValidationError('field_value_unavailable', `字段「${field.fieldName}」的取值解析接口调用失败（${module}/complete/${type}），本次查询已停止。请稍后重试。`);
+    }
+    const data = responseData(response);
+    const list = toArray(data?.data ?? data);
+    const out = [];
+    const seen = new Set();
+    for (const item of list) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const id = pickText(item, 'id');
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        out.push({ id, name: pickText(item, 'name', 'content') || id });
+    }
+    return out;
+}
+/**
+ * 把「用户写的字段值」解析为 relateContent 的 `{id,name}`（选项/人员/浏览类字段）。
+ *
+ * 解析不出唯一值 → **澄清**（`fieldOption` + 候选，对齐 V11.3
+ * `field_option_condition_clarification` L7131-7150：`clarificationType:"fieldOption"`），
+ * 绝不猜测、绝不静默放行。
+ */
+async function resolveFieldValues(env, field, rawValues) {
+    const resolved = [];
+    const unresolved = [];
+    for (const raw of rawValues) {
+        if (raw === undefined || raw === null || !String(raw).trim())
+            continue;
+        const text = String(raw).trim();
+        const parsed = parseNameWithId(text);
+        if (parsed.id) {
+            resolved.push({ id: parsed.id, name: parsed.name || parsed.id });
+            continue;
+        }
+        const candidates = await fetchFieldValueCandidates(env, field, text);
+        const exact = candidates.filter((c) => c.name === text);
+        const contains = candidates.filter((c) => c.name.includes(text) || text.includes(c.name));
+        const picked = exact.length === 1 ? exact[0] : (exact.length === 0 && contains.length === 1 ? contains[0] : undefined);
+        if (picked) {
+            resolved.push(picked);
+            continue;
+        }
+        unresolved.push(text);
+    }
+    if (!unresolved.length)
+        return resolved;
+    // 解析不出唯一值 → 列出候选让用户确认（不猜测、不放行）
+    const all = await fetchFieldValueCandidates(env, field, '');
+    const listed = all.slice(0, 15).map((c, index) => `${index + 1}. ${c.name}(${c.id})`).join('；') || '（该字段未返回任何可选项）';
+    const more = all.length > 15 ? `（共 ${all.length} 个，仅列前 15 个）` : '';
+    const question = all.length
+        ? `字段「${field.fieldName}」中未找到与「${unresolved.join('、')}」唯一匹配的选项，`
+            + `请从下列选项确认一个（回复序号或「选项名(选项ID)」）：${listed}${more}。`
+        : `字段「${field.fieldName}」没有可筛选的选项数据，无法生成该字段条件。`;
+    throw workflowClarificationError('fieldOption', unresolved.join('、'), question, clarificationCandidates(all, 15));
+}
+/** --filter-fields 单项 → filterFormDatas 项（字段名必须解析为真实字段，否则报错让模型澄清）。 */
+async function resolveFilterFieldItem(env, raw, fields, workflowLabel, ordinal) {
+    if (!raw || typeof raw !== 'object') {
+        throw workflowValidationError('field_invalid', `filterFields 第 ${ordinal} 项必须是对象。`);
+    }
+    const item = raw;
+    const rawName = asString(item.fieldName) ?? '';
+    const rawTerm = (asString(item.term) ?? '').toLowerCase();
+    if (!rawName || !rawTerm) {
+        throw workflowValidationError('field_invalid', `filterFields 第 ${ordinal} 项必须同时提供 fieldName 与 term。`);
+    }
+    // 1) 字段名 → 真实字段（带 ID 直取 → 精确名称 → 包含匹配）。
+    // 解析不出来（0 命中/多命中）一律**澄清**（对齐 V11.3「字段未识别澄清」/「字段多候选澄清」，
+    // references/workflow-search.md「澄清后回传」表），由模型把候选摆给用户确认后用「字段名(字段ID)」重试。
+    const parsedName = parseNameWithId(rawName);
+    let field;
+    if (parsedName.id) {
+        field = fields.find((f) => f.fieldId === parsedName.id);
+        if (!field) {
+            throw workflowClarificationError('field', rawName, `工作流「${workflowLabel}」下没有字段 ID ${parsedName.id}（filterFields 第 ${ordinal} 项）。`
+                + `请确认该字段是否属于本工作流，或从下列可选字段中确认一个（回复「字段名(字段ID)」）：`
+                + `${fieldCandidateList(fields, rawName).map((c) => c.display).join('；')}。`, fieldCandidateList(fields, rawName));
+        }
+    }
+    else {
+        const needle = parsedName.name.toLowerCase();
+        const exact = fields.filter((f) => f.matchNames.some((n) => n.toLowerCase() === needle));
+        if (exact.length === 1) {
+            field = exact[0];
+        }
+        else if (exact.length === 0) {
+            const contains = fields.filter((f) => f.matchNames.some((n) => {
+                const lower = n.toLowerCase();
+                return lower.includes(needle) || needle.includes(lower);
+            }));
+            if (contains.length === 1)
+                field = contains[0];
+            else if (contains.length > 1) {
+                throw workflowClarificationError('field', rawName, `工作流「${workflowLabel}」的字段名「${rawName}」匹配到 ${contains.length} 个字段（filterFields 第 ${ordinal} 项），`
+                    + `请确认要查询的具体字段（回复「字段名(字段ID)」）：`
+                    + contains.slice(0, 15).map((f, index) => `${index + 1}. ${f.fieldName}(${f.fieldId})`).join('；')
+                    + '。', contains.slice(0, 15).map((f, index) => fieldCandidateItem(f, index + 1)));
+            }
+            else {
+                throw workflowClarificationError('field', rawName, `工作流「${workflowLabel}」下未找到字段「${rawName}」（filterFields 第 ${ordinal} 项）。`
+                    + `请从下列可选字段中确认一个（回复「字段名(字段ID)」）：`
+                    + `${fieldCandidateList(fields, rawName).map((c) => c.display).join('；')}。`, fieldCandidateList(fields, rawName));
+            }
+        }
+        else {
+            throw workflowClarificationError('field', rawName, `工作流「${workflowLabel}」的字段名「${rawName}」匹配到 ${exact.length} 个字段（filterFields 第 ${ordinal} 项），`
+                + `请确认要查询的具体字段（回复「字段名(字段ID)」）：`
+                + exact.slice(0, 15).map((f, index) => `${index + 1}. ${f.fieldName}(${f.fieldId})`).join('；')
+                + '。', exact.slice(0, 15).map((f, index) => fieldCandidateItem(f, index + 1)));
+        }
+    }
+    // 2) term 规范化
+    const term = FILTER_TERM_ALIASES[rawTerm] ?? rawTerm;
+    const base = {
+        componentKey: field.componentKey,
+        fieldId: field.fieldId,
+        fieldName: field.fieldName,
+    };
+    const value = item.value;
+    // 3) 按组件类型生成报文（类型不支持时报错，不猜、不静默丢弃）
+    if (term === 'null' || term === 'notnull') {
+        const allowed = TEXT_FIELD_COMPONENT_KEYS.has(field.componentKey) ? TEXT_FIELD_TERMS
+            : NUMBER_FIELD_COMPONENT_KEYS.has(field.componentKey) ? NUMBER_FIELD_TERMS
+                : DATE_FIELD_COMPONENT_KEYS.has(field.componentKey) ? DATE_FIELD_TERMS : RELATE_FIELD_TERMS;
+        if (!allowed.has(term)) {
+            throw workflowValidationError('field_term_unsupported', `字段「${field.fieldName}」（${field.componentKey}）不支持 term=${term}。`);
+        }
+        return { ...base, term };
+    }
+    if (TEXT_FIELD_COMPONENT_KEYS.has(field.componentKey)) {
+        if (!TEXT_FIELD_TERMS.has(term)) {
+            throw workflowValidationError('field_term_unsupported', `字段「${field.fieldName}」是文本字段，term 只能是 ${[...TEXT_FIELD_TERMS].join('/')}；收到 term=${term}。`
+                + `若要做数值范围请改用数值字段（如金额类字段）。`);
+        }
+        const text = asString(value) ?? '';
+        if (!text) {
+            throw workflowValidationError('field_value_required', `字段「${field.fieldName}」的 term=${term} 需要提供 value。`);
+        }
+        return { ...base, term, content: text };
+    }
+    if (NUMBER_FIELD_COMPONENT_KEYS.has(field.componentKey)) {
+        if (!NUMBER_FIELD_TERMS.has(term)) {
+            throw workflowValidationError('field_term_unsupported', `字段「${field.fieldName}」是数值字段，term 只能是 ${[...NUMBER_FIELD_TERMS].join('/')}；收到 term=${term}。`);
+        }
+        const isMoney = MONEY_FIELD_COMPONENT_KEYS.has(field.componentKey);
+        // gt/gte 只封下界、lt/lte 只封上界（另一侧留空串＝开放），like 取 [min,max]（标量视为闭区间单点）
+        let min = '';
+        let max = '';
+        if (term === 'like') {
+            if (Array.isArray(value)) {
+                min = asString(value[0]) ?? '';
+                max = asString(value[1]) ?? '';
+            }
+            else {
+                min = asString(value) ?? '';
+                max = min;
+            }
+        }
+        else {
+            const scalar = Array.isArray(value) ? (asString(value[0]) ?? '') : (asString(value) ?? '');
+            if (term === 'gt' || term === 'gte')
+                min = scalar;
+            else
+                max = scalar;
+            if (term === 'gt')
+                min = adjustExclusiveBound(min, isMoney, 'min');
+            if (term === 'lt')
+                max = adjustExclusiveBound(max, isMoney, 'max');
+        }
+        if (!min && !max) {
+            throw workflowValidationError('field_value_required', `字段「${field.fieldName}」的 term=${term} 需要提供 value（数值或 [min,max]）。`);
+        }
+        return { ...base, term: 'like', numberContent: { min, max } };
+    }
+    if (DATE_FIELD_COMPONENT_KEYS.has(field.componentKey)) {
+        if (!DATE_FIELD_TERMS.has(term)) {
+            throw workflowValidationError('field_term_unsupported', `字段「${field.fieldName}」是日期字段，term 只能是 ${[...DATE_FIELD_TERMS].join('/')}；收到 term=${term}。`);
+        }
+        const label = `字段「${field.fieldName}」`;
+        const range = Array.isArray(value) ? value : [value, value];
+        const start = resolveDateBound(range[0]);
+        const end = resolveDateBound(range[1]);
+        if (start === null || end === null || (!start && !end)) {
+            throw workflowValidationError('field_value_required', `字段「${field.fieldName}」的 term=${term} 需要提供 value（["开始","结束"]，YYYY-MM-DD，单边可空串）。`);
+        }
+        if (start > end) {
+            throw workflowValidationError('time_invalid', `${label} 的时间区间起点晚于终点（${start} > ${end}）。`);
+        }
+        return { ...base, term: 'like', dateContent: [start, end] };
+    }
+    // 同理：browserBean 为空对象时不算浏览按钮字段（见 extractSearchAdFields 的说明）。
+    const isBrowserField = (field.browserBean !== undefined
+        && Object.keys(field.browserBean).length > 0) || field.componentKey === 'BROWSER';
+    if (isBrowserField) {
+        const mapped = term === 'like' ? 'eq' : (term === 'notlike' ? 'ne' : term);
+        if (!RELATE_FIELD_TERMS.has(mapped)) {
+            throw workflowValidationError('field_term_unsupported', `字段「${field.fieldName}」是选项/人员/浏览类字段，term 只能是 ${[...RELATE_FIELD_TERMS].join('/')}（like/notLike 自动按 eq/ne 处理）；收到 term=${term}。`);
+        }
+        const values = Array.isArray(value) ? value : [value];
+        if (!values.filter((v) => v !== undefined && v !== null && String(v).trim()).length) {
+            throw workflowValidationError('field_value_required', `字段「${field.fieldName}」的 term=${mapped} 需要提供 value。`);
+        }
+        const relateContent = await resolveFieldValues(env, field, values);
+        return { ...base, term: mapped === 'in' ? 'eq' : mapped, relateContent };
+    }
+    throw workflowValidationError('field_type_unsupported', `字段「${field.fieldName}」的组件类型 ${field.componentKey} 暂不支持作为筛选条件（filterFields 第 ${ordinal} 项），`
+        + '本次查询已停止。请改用文本/数值/日期/选项类字段。');
+}
+async function buildSearchQuery(env, args, mode) {
+    // 1. 原始 JSON 直传（--query-json / --query-file 透传；CLI 侧用 queryJson 字段承载）
+    const rawJson = args.queryJson;
+    let query;
+    if (rawJson && typeof rawJson === 'object') {
+        query = JSON.parse(JSON.stringify(rawJson));
+    }
+    else {
+        query = {};
+    }
+    // 2. 分类 + tabid
+    const category = (asString(args.category) || 'todo');
+    if (!ENDPOINT_PREFIX[category]) {
+        throw workflowValidationError('category_invalid', `category 必须是 todo/done/mine/all 之一，收到：${category}`);
+    }
+    let tabid = DEFAULT_TABID[category];
+    if (args.subCategory) {
+        const resolved = SUB_CATEGORY_TABS[category]?.[asString(args.subCategory) ?? ''];
+        if (resolved)
+            tabid = resolved;
+    }
+    if (args.tabName) {
+        const resolved = SUB_CATEGORY_TABS[category]?.[asString(args.tabName) ?? ''];
+        if (resolved)
+            tabid = resolved;
+    }
+    if (args.tabid !== undefined && String(args.tabid).trim() !== '') {
+        tabid = String(args.tabid).trim();
+    }
+    // 2.5 legacy（低版本模式）恢复 V11.2 语义：todo 未显式指定子分类时默认查「待处理(7)」而非
+    // 「全部(0)」（来源：Python execute_workflow_search_legacy 的 legacy tab 恢复分支，L12612-12627）。
+    // smart 智能分组取数需覆盖全部待办，故仅在 legacy 生效；显式 subCategory/tabName/tabid 或
+    // queryJson 自带 params.tabid 时保持原值不动（尊重显式意图）。
+    if (asString(args.searchMode) === 'legacy' && category === 'todo' && tabid === DEFAULT_TABID.todo) {
+        const explicitTab = Boolean(asString(args.subCategory) || asString(args.tabName) ||
+            (args.tabid !== undefined && String(args.tabid).trim() !== ''));
+        const rawTabid = query?.params?.tabid;
+        const rawHasTabid = rawTabid !== undefined && rawTabid !== null && String(rawTabid).trim() !== '';
+        if (!explicitTab && !rawHasTabid)
+            tabid = SUB_CATEGORY_TABS.todo['待处理'];
+    }
+    // 3. params 层
+    const params = {
+        tabid,
+        dimension: category,
+        flowSpareType: 1,
+        outType: 0,
+    };
+    if (tabid === '300' || tabid === '303' || tabid === '304') {
+        params.subDimensionId = 'dirParticipant';
+    }
+    if (mode === 'stat') {
+        params.needFormFields = true;
+        params.attentionFormFields = STAT_ATTENTION_FORM_FIELDS;
+    }
+    const requestIds = asString(args.requestId);
+    if (requestIds)
+        params.requestIds = requestIds;
+    const exRequestIds = asString(args.exRequestId);
+    if (exRequestIds)
+        params.exRequestIds = exRequestIds;
+    query.params = { ...params, ...compact(query.params || {}) };
+    // 4. formDatas
+    const formDatas = { ...compact(query.searchParams?.formDatas || {}) };
+    // 发起人 / 发起人部门 / 发起人分部 / 工作流类型 / 工作流（支持 "名称(ID)" 直取或多值）
+    // 解析失败一律抛错，不静默丢弃条件（否则条件不生效会退化为全量查询）
+    const creator = await resolveTerm(env, 'creator', args.creator, '发起人');
+    if (creator)
+        formDatas.creator = [{ browserDatas: [{ id: creator.id, name: creator.name }] }];
+    const creatorDept = await resolveTerm(env, 'creatordept', args.creatorDept, '发起人部门');
+    if (creatorDept)
+        formDatas.creatordept = [{ browserDatas: [{ id: creatorDept.id, name: creatorDept.name }] }];
+    const creatorSubcom = await resolveTerm(env, 'creatorsubcom', args.creatorSubcom, '发起人分部');
+    if (creatorSubcom)
+        formDatas.creatorsubcom = [{ browserDatas: [{ id: creatorSubcom.id, name: creatorSubcom.name }] }];
+    const workflowType = await resolveTerm(env, 'workflowtype', args.workflowType, '工作流类型');
+    if (workflowType)
+        formDatas.workflowtype = [{ browserDatas: [{ id: workflowType.id, name: workflowType.name }] }];
+    const workflows = asStringArray(args.workflow, 'workflow') ?? splitCsv(args.workflow).map((w) => [w]).flat();
+    // 解析后的工作流成员提升到外层：表单字段条件必须限定到单个工作流，需要在此消费同一份结果
+    const resolvedWorkflows = [];
+    if (workflows && workflows.length) {
+        const seenWorkflowIds = new Set();
+        for (const w of workflows) {
+            const resolved = await resolveTerm(env, 'workflowid', w, '工作流');
+            if (!resolved)
+                continue;
+            if (resolved.id && seenWorkflowIds.has(resolved.id))
+                continue;
+            if (resolved.id)
+                seenWorkflowIds.add(resolved.id);
+            resolvedWorkflows.push(resolved);
+        }
+        if (resolvedWorkflows.length) {
+            // 多值必须合并为「单个条件项 + 多 browserDatas」（term 统一），逐值拆成多个条件项会被
+            // 服务端按 AND 处理 → 多工作流查询恒 0 条（来源：Python _plan_workflow_form_datas / build_workflow_condition）
+            const term = asString(args.workflowTerm) === 'notin' ? 'notin' : 'in';
+            formDatas.workflowid = [{ term, browserDatas: resolvedWorkflows }];
+            // workflowid 条件唯一时，取其首个 id 作为 params.searchAdWorkflowid
+            // （来源：Python normalize_query_shape，list/total 两种请求体共用）
+            const firstWorkflowId = asString(resolvedWorkflows[0]?.id) ?? '';
+            if (firstWorkflowId) {
+                query.params = { ...(query.params || {}), searchAdWorkflowid: firstWorkflowId };
+            }
+        }
+    }
+    // 流程标题 / 编号
+    const requestName = asString(args.requestName);
+    if (requestName) {
+        const term = asString(args.requestNameTerm) || 'like';
+        formDatas.requestname = [{ content: requestName, term }];
+    }
+    const requestMark = asString(args.requestMark);
+    if (requestMark) {
+        const term = asString(args.requestMarkTerm) || 'like';
+        formDatas.requestmark = [{ content: requestMark, term }];
+    }
+    // 紧急程度
+    const requestLevel = await resolveRequestLevel(env, args.requestLevel);
+    if (requestLevel)
+        formDatas.requestlevel = [{ content: requestLevel }];
+    // 当前节点 ID
+    const nodeId = asString(args.nodeId);
+    if (nodeId) {
+        const term = asString(args.nodeIdTerm) === 'notin' ? 'notin' : 'in';
+        formDatas.nodeid = [{ content: nodeId, term }];
+    }
+    // 流程状态
+    const flowStatus = asString(args.flowStatus);
+    if (flowStatus) {
+        const term = asString(args.flowStatusTerm) === 'notin' ? 'notin' : 'in';
+        formDatas.flowstatus = [{ content: flowStatus, term }];
+    }
+    // 时间条件（来源：Python build_system_date_conditions——待办分类下移除操作时间条件：
+    // 待办是"还未处理"的流程，操作时间（已操作过的时间）与待办状态语义矛盾）
+    // ★ 键名大小写是服务端契约，不是笔误：V11.3 `FORM_KEYS`（e10_workflow.py:358-378）20 个条件键里
+    //   只有 `operateDateTime` 与 `sysCode` 是驼峰，其余时间键（createdatetime/receivedatetime/
+    //   finishdatetime）都是全小写。V11.3 `:8369` 注释亦记「确认 OA 侧正确 key 为驼峰 operateDateTime」。
+    //   曾误写全小写 `operatedatetime` ⇒ 服务端静默忽略该条件、已办查询退化成全量（实测四次不同取值
+    //   返回同样条数），故此处必须保持驼峰。
+    applyTimeCondition(formDatas, 'createdatetime', args.createTime);
+    if (category !== 'todo')
+        applyTimeCondition(formDatas, 'operateDateTime', args.operateTime);
+    applyTimeCondition(formDatas, 'receivedatetime', args.receiveTime);
+    applyTimeCondition(formDatas, 'finishdatetime', args.finishTime);
+    // 表单字段条件：先解析字段名（→ 真实 fieldId/componentKey），解析不出就报错让模型澄清。
+    // 服务端只认 componentKey + fieldId，只传 fieldName 会被静默忽略（条件蒸发、返回全量）。
+    const filterFieldsRaw = parseFilterFieldsInput(args.filterFields);
+    if (filterFieldsRaw.length) {
+        if (!resolvedWorkflows.length) {
+            throw workflowValidationError('field_require_workflow', '使用表单字段筛选时必须同时指定工作流（服务端只在该工作流的表单字段内匹配）。'
+                + '请先与用户确认要查哪个工作流，再用「名称(ID)」传入 workflow，并附上 filterFields。');
+        }
+        if (resolvedWorkflows.length > 1) {
+            throw workflowValidationError('field_require_single_workflow', `表单字段筛选一次只能用于**单个**工作流，当前指定了 ${resolvedWorkflows.length} 个：`
+                + `${resolvedWorkflows.map((w) => `${w.name}(${w.id})`).join('；')}。`
+                + '请先把候选工作流展示给用户确认，再用「名称(ID)」传入单个 workflow 与 filterFields。', { candidates: resolvedWorkflows.map((w, index) => ({ index: index + 1, id: w.id, name: w.name })) });
+        }
+        const targetWorkflow = resolvedWorkflows[0];
+        const workflowLabel = `${targetWorkflow.name || targetWorkflow.id}(${targetWorkflow.id})`;
+        const fields = await fetchWorkflowSearchFields(env, targetWorkflow.id, category, tabid);
+        if (!fields.length) {
+            // V11.3 口径（同 `:7045-7056` 的 `fields_available=False` 分支）：该工作流没有可用的
+            // 表单查询字段 → `needClarification:true`，让模型把"这个工作流没有可筛字段"如实告诉用户，
+            // 而不是反复换字段名试探。
+            throw workflowClarificationError('field_meta', workflowLabel, `已匹配到工作流「${workflowLabel}」，但该工作流没有可用的表单查询字段`
+                + '（getListSearchAdWithForm 未返回表单字段），无法生成字段筛选条件。'
+                + '请改为不带 filterFields 查询，或与用户确认工作流是否选对。');
+        }
+        const built = [];
+        for (let index = 0; index < filterFieldsRaw.length; index += 1) {
+            built.push(await resolveFilterFieldItem(env, filterFieldsRaw[index], fields, workflowLabel, index + 1));
+        }
+        if (built.length)
+            formDatas.filterFormDatas = built;
+    }
+    query.searchParams = {
+        formDatas,
+        type: asString(args.conditionType) === 'or' ? 'or' : 'and',
+        initSearch: false,
+    };
+    // 5. 分页 / sort（仅 list）
+    if (mode === 'list') {
+        const current = asInt(args.current) ?? 1;
+        const pageSize = Math.min(asInt(args.pageSize) ?? 10, 100);
+        query.customDisplayPage = { current: Math.max(1, current), size: Math.max(1, pageSize) };
+    }
+    else {
+        delete query.customDisplayPage;
+        delete query.current;
+        delete query.pageSize;
+    }
+    // 6. sortParams（顶层，与 params 平级）
+    const sort = asString(args.sort);
+    if (sort) {
+        const items = [];
+        for (const part of sort.split(',')) {
+            const seg = part.trim();
+            if (!seg.includes(':'))
+                continue;
+            const [name, st] = seg.split(':');
+            const sortType = st.trim().toLowerCase();
+            if (sortType !== 'asc' && sortType !== 'desc')
+                continue;
+            const key = name.trim();
+            const orderKey = /^-?\d+$/.test(key) ? Number(key) : SORT_OPTIONS[key];
+            if (orderKey === undefined)
+                continue;
+            items.push({ orderkey: orderKey, sortType });
+        }
+        if (items.length)
+            query.sortParams = items;
+    }
+    return { query, tabid };
+}
+function safeJsonArray(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 解析 `filterFields` 入参（对象数组）。
+ *
+ * **不可用 `asStringArray`**——它会把对象元素拍平成 `"[object Object]"`，使字段条件在 CLI 侧
+ * 就被丢弃（旧实现即如此：只能解析为 null → `filterFormDatas` 根本不发出 → 返回未筛选的全量数据）。
+ * 支持：对象数组 / JSON 字符串的数组 / 由 JSON 字符串组成的数组。解析不出对象一律报错，不静默丢弃。
+ */
+function parseFilterFieldsInput(raw) {
+    const isPlainObject = (v) => Boolean(v) && typeof v === 'object' && !Array.isArray(v);
+    if (raw === undefined || raw === null || raw === '')
+        return [];
+    const out = [];
+    if (typeof raw === 'string') {
+        for (const item of safeJsonArray(raw.trim()))
+            if (isPlainObject(item))
+                out.push(item);
+    }
+    else if (Array.isArray(raw)) {
+        for (const item of raw) {
+            if (isPlainObject(item)) {
+                out.push(item);
+                continue;
+            }
+            if (typeof item === 'string') {
+                for (const parsed of safeJsonArray(item.trim()))
+                    if (isPlainObject(parsed))
+                        out.push(parsed);
+            }
+        }
+        if (!out.length) {
+            throw workflowValidationError('field_invalid', 'filterFields 必须是对象数组，每项形如 {"fieldName":"字段名(字段ID)","term":"like","value":...}；'
+                + `当前数组元素无法解析为对象（收到 ${JSON.stringify(raw).slice(0, 200)}）。`);
+        }
+    }
+    else {
+        throw workflowValidationError('field_invalid', 'filterFields 必须是对象数组。');
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// 列表响应归一化（来源：Python normalize_workflow_list_response，L2694）
+// ---------------------------------------------------------------------------
+/** isremark < 100 才可提交/退回/转办（来源：Python is_actionable_remark）；非数字一律视为不可操作 */
+function isActionableRemark(value) {
+    const text = value === undefined || value === null ? '' : String(value).trim();
+    if (!/^-?\d+$/.test(text))
+        return false;
+    return Number(text) < 100;
+}
+function normalizeListResponse(response, category, categoryName, baseUrl = '') {
+    const record = responseData(response);
+    const data = record?.data && typeof record.data === 'object' ? record.data : {};
+    const records = toArray(record?.data?.displayData ?? record?.displayData ?? record?.data?.list ?? record?.list ?? []);
+    const items = records.map((rec, index) => {
+        const recordObj = rec && typeof rec === 'object' ? rec : {};
+        const isRemarkRaw = pickRaw(recordObj, 'isremark', 'isRemark');
+        const finished = recordObj.finish === true;
+        const flowStatus = pickText(recordObj, 'flowstatusShow', 'flowStatusShow') ||
+            flowStatusText(recordObj.flowStatus) ||
+            pickText(recordObj, 'status') ||
+            (recordObj.draft === true ? '草稿' : '') ||
+            (finished ? '已结束' : '');
+        const stayStartAt = pickText(recordObj, 'receivedatetime', 'receiveDateTime', 'receiveDatetime', 'receiveTime', 'operatedatetime', 'operateDateTime', 'operateDatetime', 'operateTime');
+        const overdue = recordObj.overdue === true && !finished;
+        const badges = [];
+        if (overdue)
+            badges.push('已超时');
+        if (shouldDisplayFlowStatusBadge(flowStatus))
+            badges.push(flowStatus);
+        const uniqueBadges = badges.filter((label, position) => badges.indexOf(label) === position);
+        const item = {
+            index: index + 1,
+            requestId: pickText(recordObj, 'requestId', 'requestid'),
+            userMasterId: pickText(recordObj, 'userMasterId', 'userMasterID', 'secondEmpId'),
+            nodeid: pickText(recordObj, 'nodeid', 'nodeId', 'currentNodeId'),
+            flowName: pickText(recordObj, 'requestnameTitle', 'requestnametitle') ||
+                pickText(recordObj, 'requestname', 'requestName'),
+            workflowId: pickText(recordObj, 'workflowid', 'workflowId'),
+            workflowName: pickText(recordObj, 'workflowname', 'workflowName'),
+            creatorName: pickText(recordObj, 'creatername', 'creatorName', 'sourceUserName'),
+            currentNode: pickText(recordObj, 'currentnode', 'currentNode', 'currentNodeName', 'nodeName'),
+            createdAt: pickText(recordObj, 'createdatetime', 'createDateTime', 'createTime'),
+            flowStatus,
+            requestMark: pickText(recordObj, 'requestmark', 'requestMark', 'requestCode'),
+            isRemark: isRemarkRaw === undefined || isRemarkRaw === null ? '' : String(isRemarkRaw).trim(),
+            canSubmitRejectTransfer: isActionableRemark(isRemarkRaw),
+            stayStartAt,
+            stayDuration: category === 'todo' ? humanizeDurationSince(stayStartAt) : '',
+            finished,
+            overdue,
+            timeoutText: pickText(recordObj, 'userOverTime'),
+            timeoutLabel: overdue ? '超时时间' : '预计超时',
+            requestLevelText: requestLevelText(pickText(recordObj, 'requestlevelShow', 'requestLevelShow', 'requestLevelTitle', 'requestlevelTitle') ||
+                recordObj.requestLevel),
+            badges: uniqueBadges,
+            badgeObjects: buildBadgeObjects(uniqueBadges),
+        };
+        item.cardMeta = buildCardMeta(item, category);
+        return item;
+    });
+    const total = asInt(data?.total ?? record?.total);
+    const hasMore = asBool(data?.hasMore ?? record?.hasMore, false);
+    const current = asInt(data?.current ?? record?.current) ?? 1;
+    const pageSize = asInt(data?.pageSize ?? record?.pageSize) ?? 10;
+    return {
+        type: 'workflowList',
+        category,
+        categoryName,
+        current,
+        pageSize,
+        total,
+        totalReliable: total !== null,
+        hasMore,
+        items,
+        cardItems: items.map((item) => {
+            const card = {
+                index: item.index,
+                title: item.flowName,
+                badges: item.badges,
+                badgeObjects: item.badgeObjects,
+                meta: item.cardMeta,
+                internal: {
+                    requestId: item.requestId,
+                    userMasterId: item.userMasterId,
+                    nodeid: item.nodeid,
+                    isRemark: item.isRemark,
+                    canSubmitRejectTransfer: item.canSubmitRejectTransfer,
+                    overdue: item.overdue,
+                    requestLevelText: item.requestLevelText,
+                    // 该流程所属工作流（V12.1.34）：条目里本来就有（见 items 的 workflowId/workflowName）。
+                    // 这里只做结构化回显，不做任何名称→ID 推断。
+                    //
+                    // ★ V12.1.37：本结构（`cardItems`）已**不再输出给模型**（见 SLIM_INDEX_ITEM_KEYS：
+                    // 输出只保留 `cards[]` 的定位/标识/可操作性字段），它现在只在 CLI 内部用于渲染
+                    // `finalMarkdown` 与草稿过滤。模型侧要 workflowId 请从 `cards[].workflowId` 取。
+                    workflowId: item.workflowId,
+                    workflowName: item.workflowName,
+                },
+            };
+            card.url = cardWorkflowOpenUrl(card, baseUrl);
+            card.renderMarkdown = renderCardMarkdown(card);
+            return card;
+        }),
+    };
+}
+// ---------------------------------------------------------------------------
+// 输出体积预算：条目瘦身 + 超线落盘（来源：Python persist_large_search_output /
+// enforce_workflow_search_stdout_budget，V11.3.104）
+// ---------------------------------------------------------------------------
+/** 查询类 stdout 安全线（**美化**口径，与 `createForm` 同规格）。
+ *
+ *  宿主单次直读线实测约 28,000–29,300 B：超线后除开头 2,048 B 预览外**永远看不见**，
+ *  取 24,000 留余量。量这个线必须用 `stdoutBytesOf()`（美化）而不是压缩口径——CLI 实际
+ *  打印的是 `JSON.stringify(v, null, 2)`，压缩口径会低估约 1.8 倍（V12.1.34 的教训）。
+ */
+const SEARCH_STDOUT_SAFE_BYTES = STDOUT_SAFE_BYTES;
+/** 输出给模型的条目字段白名单：只保留**机器可读的定位 / 标识 / 可操作性判断**字段。
+ *
+ *  `cardMeta`/`badgeObjects`/`badges`/`flowStatus`/`currentNode`/`creatorName`/`stayDuration`/
+ *  `timeoutLabel`/`timeoutText`/`requestLevelText`/`createdAt`/`stayStartAt` 都是**渲染用**字段，
+ *  而唯一渲染源是 `finalMarkdown`（卡片文本已含标题链接、状态徽标与「标签：值」行）——保留它们
+ *  等于把同一张卡片存两遍：实测泛化待办查询（20 条）这批字段占 stdout 的 61%。
+ *  `userMasterId`/`nodeid` 只在拼 URL 与内部定位时用，模型侧没有消费点。
+ */
+const SLIM_INDEX_ITEM_KEYS = [
+    'index',
+    'requestId',
+    'requestMark',
+    'flowName',
+    'workflowId',
+    'workflowName',
+    'canSubmitRejectTransfer',
+    'isRemark',
+    'finished',
+    'overdue',
+];
+/** 条目瘦身投影（内部逻辑继续消费完整条目，只在**输出**时收窄）。 */
+function slimIndexItem(item) {
+    const slim = {};
+    for (const key of SLIM_INDEX_ITEM_KEYS) {
+        if (key in item)
+            slim[key] = item[key];
+    }
+    return slim;
+}
+/** 超线落盘时 stdout 侧保留的形态：移出结构化明细，只留渲染层与元数据。 */
+function stripHeavyPayload(result) {
+    const kept = { ...result };
+    delete kept.cards;
+    delete kept.cardItems;
+    delete kept.renderMarkdown;
+    if (Array.isArray(kept.groups)) {
+        kept.groups = kept.groups.map((group) => {
+            if (!group || typeof group !== 'object')
+                return group;
+            const next = { ...group };
+            delete next.cardItems;
+            return next;
+        });
+    }
+    if (Array.isArray(kept.specialGroups)) {
+        kept.specialGroups = kept.specialGroups.map((special) => {
+            if (!special || typeof special !== 'object')
+                return special;
+            const next = { ...special };
+            if (Array.isArray(next.slots)) {
+                next.slots = next.slots.map((slot) => {
+                    if (!slot || typeof slot !== 'object')
+                        return slot;
+                    const trimmed = { ...slot };
+                    delete trimmed.cardItems;
+                    return trimmed;
+                });
+            }
+            return next;
+        });
+    }
+    return kept;
+}
+/** 按 UTF-8 字节安全截断（用于"渲染层本身也超预算"的极端兜底）。 */
+function truncateUtf8Text(text, maxBytes) {
+    if (Buffer.byteLength(text, 'utf8') <= maxBytes)
+        return text;
+    let out = '';
+    let used = 0;
+    for (const char of text) {
+        const size = Buffer.byteLength(char, 'utf8');
+        if (used + size > maxBytes)
+            break;
+        out += char;
+        used += size;
+    }
+    return out;
+}
+/** 查询结果超安全线时的收口：完整结果落盘 + stdout 保留渲染层。
+ *
+ *  与 V11.3 的差异（有意为之）：V11.3 落盘后只回约 3,200 字的 overview，模型**必须**再读一次
+ *  `resultMdFile` 才能渲染；这里让 stdout 直接带上**全量 `finalMarkdown`**——它是模型唯一必须
+ *  渲染的内容、通常只有几 KB，被移出的只是结构化明细。⇒ 正常路径下模型一次就能看全，不需要
+ *  任何二次读取；`resultFile`/`resultMdFile` 只是"要明细时"的续取指针。
+ *
+ *  落盘不可用时**保持全量输出**（宁大不丢数据）并给出提示——与 `todoStat` 同口径。
+ */
+async function enforceSearchStdoutBudget(result, env, fileName) {
+    const bytes = stdoutBytesOf(result);
+    if (bytes <= SEARCH_STDOUT_SAFE_BYTES)
+        return result;
+    const resultFile = await writeStateFileBestEffort(fileName.json, JSON.stringify(result, null, 2), env.ctx);
+    const resultMdFile = await writeStateFileBestEffort(fileName.md, String(result.finalMarkdown || ''), env.ctx);
+    if (!resultFile) {
+        return {
+            ...result,
+            outputBytes: bytes,
+            largeOutputNotice: '查询结果较大且本地落盘不可用，已按原样返回全量条目明细。',
+        };
+    }
+    const noticeBase = '查询结果较大：完整结果已写入 resultFile（结构化 JSON）与 resultMdFile（纯渲染文本）。'
+        + '渲染直接用下方 finalMarkdown 即可，无需读文件；只有需要完整结构化明细（如逐条 requestId）时'
+        + '才从 resultFile 按需提取（不要把整份读进上下文），并请一次读完：不要用 head/tail 等管道截断'
+        + '（会破坏 JSON，并导致重复执行同一命令）。';
+    const stripped = withLeadingMeta({ resultFile, resultMdFile, persistedResult: true, outputBytes: bytes, largeOutputNotice: noticeBase }, stripHeavyPayload(result));
+    if (stdoutBytesOf(stripped) <= SEARCH_STDOUT_SAFE_BYTES)
+        return stripped;
+    // 极端兜底：渲染层本身也超预算 ⇒ 截断 finalMarkdown，强制走 resultMdFile
+    return {
+        ...stripped,
+        largeOutputNotice: `${noticeBase}注意：本次渲染文本本身也超过单次输出上限，下方 finalMarkdown **已被截断**——`
+            + '必须读取 resultMdFile 取完整 finalMarkdown 后原样渲染，禁止重跑本命令。',
+        finalMarkdown: truncateUtf8Text(String(result.finalMarkdown || ''), 8_000),
+    };
+}
+// ---------------------------------------------------------------------------
+// 序号定位（查询类写索引；查看类读索引）
+// ---------------------------------------------------------------------------
+async function saveListIndex(env, normalized) {
+    const items = normalized.items || [];
+    return saveSearchIndex({
+        items,
+        summary: {
+            type: normalized.type,
+            category: normalized.category,
+            total: normalized.total,
+            hasMore: normalized.hasMore,
+        },
+    }, env.ctx);
+}
+/** 从 requestId 或 group+index 解析出目标 requestId。索引失效抛 index_stale。 */
+async function resolveTargetRequestId(env, args) {
+    const explicit = asString(args.requestId);
+    if (explicit)
+        return explicit;
+    const index = asInt(args.index);
+    if (index === undefined) {
+        throw workflowValidationError('locate_required', '必须提供 requestId 或 group+index 定位目标流程');
+    }
+    const group = asString(args.group);
+    const searchIndex = await loadSearchIndex(env.ctx);
+    const item = findIndexedItem(searchIndex, group, index);
+    if (!item || !item.requestId) {
+        throw workflowValidationError('index_stale', '序号定位失败：本地检索索引已失效或该序号不存在，请重新执行查询（workflow.search / workflow.todoStat）后再操作。', { group: group ?? null, index });
+    }
+    return item.requestId;
+}
+// ---------------------------------------------------------------------------
+// workflow.search（来源：cmd_workflow_search / execute_workflow_search_smart）
+// ---------------------------------------------------------------------------
+const workflowSearch = {
+    name: 'workflow.search',
+    resource: 'workflow',
+    method: 'search',
+    action: 'workflow.search',
+    summary: '分页查询流程（待办/已办/我发起/全部），支持工作流、表单字段、时间、紧急程度、发起人、标题/编号等条件筛选；支持 plan 批量编排取数',
+    capability: 'search',
+    risk: 'read',
+    inputSchema: schemaOf({
+        category: SCHEMA_CATEGORY,
+        tabid: { type: 'string', description: '细分子类 tabid' },
+        tabName: { type: 'string', description: '细分子类名称' },
+        subCategory: { type: 'string', description: '细分子类名称或 tabid' },
+        keyword: { type: 'array', items: { type: 'string' }, description: '实体关键词（辅助解析）' },
+        creator: { type: 'string', description: '发起人姓名，支持 "名称(ID)"；纯名称多命中返回澄清候选，0 命中报错（对齐 V11.3）' },
+        creatorDept: { type: 'string', description: '发起人部门；纯名称多命中返回澄清候选，0 命中报错' },
+        creatorSubcom: { type: 'string', description: '发起人分部；纯名称多命中返回澄清候选，0 命中报错' },
+        workflowType: { type: 'string', description: '工作流类型；纯名称多命中返回澄清候选，0 命中报错' },
+        workflow: { type: 'array', items: { type: 'string' }, description: '工作流条件，多个 or；支持 "名称(ID)"；纯名称未匹配到/匹配到多个且无全名精确匹配时返回澄清（候选见 candidates），确认后用「名称(ID)」重发' },
+        workflowTerm: { type: 'string', enum: ['in', 'notin'] },
+        requestName: { type: 'string', description: '流程标题 like 模糊' },
+        requestNameTerm: { type: 'string', enum: ['in', 'notin', 'eq', 'ne'] },
+        requestMark: { type: 'string', description: '流程编号 like 模糊' },
+        requestMarkTerm: { type: 'string', enum: ['in', 'notin', 'eq', 'ne'] },
+        requestLevel: { type: 'string', description: '紧急程度名称（CLI 按当前环境等级列表转 ID）；纯名称多命中返回澄清候选，0 命中报错并列出可选等级（对齐 V11.3）' },
+        requestId: { type: 'string', description: '按 requestId 精确过滤，逗号分隔' },
+        exRequestId: { type: 'string', description: '排除 requestId，逗号分隔' },
+        nodeId: { type: 'string', description: '当前节点 ID' },
+        nodeIdTerm: { type: 'string', enum: ['in', 'notin'] },
+        flowStatus: { type: 'string', description: '流程状态' },
+        flowStatusTerm: { type: 'string', enum: ['in', 'notin'] },
+        createTime: { type: 'string', description: TIME_DESCRIPTIONS.createTime },
+        operateTime: { type: 'string', description: TIME_DESCRIPTIONS.operateTime },
+        receiveTime: { type: 'string', description: TIME_DESCRIPTIONS.receiveTime },
+        finishTime: { type: 'string', description: TIME_DESCRIPTIONS.finishTime },
+        filterFields: {
+            type: 'array',
+            items: { type: 'object' },
+            description: '表单字段筛选条件：[{"fieldName":"字段名(字段ID)","term":"...","value":...}]；必须同时传且只传一个 workflow，'
+                + 'fieldName 会按该工作流真实表单字段解析（解析不出唯一字段时返回澄清并列出候选）',
+        },
+        sort: { type: 'string', description: '"排序方式:asc|desc"，多组逗号分隔' },
+        current: { type: 'integer', minimum: 1, default: 1 },
+        pageSize: SCHEMA_PAGE_SIZE,
+        conditionType: { type: 'string', enum: ['and', 'or'], default: 'and' },
+        totalOnly: { type: 'boolean', default: false },
+        mode: { type: 'string', enum: ['auto', 'legacy', 'smart'], default: 'auto', description: '执行模式强制覆盖，仅回归验证用；默认按 OA 版本自动路由' },
+        batchType: {
+            type: 'string',
+            enum: ['submit', 'urge', 'read', 'share', 'forward', 'reject'],
+            description: '过滤允许对应批量操作的数据（批量操作前置取数）；配合 pageSize=100',
+        },
+        planJson: { type: 'object', description: 'V11.3.67 批量编排模式 JSON（{category, specialGroups?, groups:[{groupName,collapsed?,condition}]}）' },
+        queryJson: { type: 'object', description: '已生成的完整查询 JSON（跳过 build-query）' },
+    }),
+    handler: async (args, env) => {
+        const plan = args.planJson;
+        if (plan && typeof plan === 'object') {
+            // plan 批量编排仅智能分组模式支持（来源：Python cmd_workflow_search_plan 首行的
+            // resolve_workflow_search_mode 门禁）——该模式下 todoStat 的统计口径才成立；低版本 OA 上
+            // 直接拒绝，并引导改用单条查询，避免静默按错口径分组。--mode smart 仍可强制（回归验证用）。
+            const planMode = await resolveSearchMode(env, args);
+            if (planMode !== 'smart') {
+                throw workflowValidationError('plan_requires_smart_mode', `plan 批量编排模式仅支持智能分组模式（OA ≥ ${formatOaVersion(SMART_GROUPING_MIN_OA_VERSION)}）；低版本请改用单条 workflow.search`, { retryAllowed: false, renderMode: planMode });
+            }
+            // 顶层 pageSize 即 plan 的展示窗口 page_cap（来源：Python cmd_workflow_search_plan 的 page_cap）
+            return executePlanSearch(env, plan, asInt(args.pageSize) ?? 10);
+        }
+        const category = (asString(args.category) || 'todo');
+        const searchMode = await resolveSearchMode(env, args);
+        const batchType = asString(args.batchType);
+        const totalOnly = asBool(args.totalOnly, false);
+        // legacy 待办查询走 CLI 侧分组（V11.2 语义；来源：Python execute_workflow_search_legacy 的
+        // grouping_active 分支）：未显式指定子分类、非 total-only、非批量取数时按「待处理/超时/紧急」
+        // 分组取数并输出分组统计。smart 模式不做 CLI 侧分组（分组由模型按 countDetails 规划）。
+        if (searchMode === 'legacy' && category === 'todo' && !batchType && !totalOnly && !hasExplicitTab(args)) {
+            return executeLegacyGroupedTodoSearch(env, args);
+        }
+        const { query, tabid } = await buildSearchQuery(env, { ...args, searchMode }, 'list');
+        const prefix = ENDPOINT_PREFIX[category];
+        let listKey = `${prefix}_LIST`;
+        let totalKey = `${prefix}_TOTAL`;
+        if (batchType) {
+            const suffix = batchType.toUpperCase();
+            // 六类批量操作数据查询（来源：Python batch_endpoint_keys：
+            // submit/urge/read/share/forward/reject）——缺 share/forward/reject 时
+            // 批量共享/转发/退回的"可操作数据"取数链路断裂。
+            if (['SUBMIT', 'URGE', 'READ', 'SHARE', 'FORWARD', 'REJECT'].includes(suffix)) {
+                listKey = `TODO_LIST_BATCH_${suffix}`;
+                totalKey = `TODO_TOTAL_BATCH_${suffix}`;
+            }
+        }
+        const totalBody = JSON.parse(JSON.stringify(query));
+        // legacy 通用待办（未显式指定子分类）：表头总数按「全部(0)」口径取数（来源：Python
+        // execute_workflow_search_legacy 的 generic_todo_scope 分支）——与分组模式下的 all_total 对齐。
+        if (searchMode === 'legacy' && category === 'todo' && !hasExplicitTab(args)) {
+            totalBody.params = { ...(totalBody.params || {}), tabid: DEFAULT_TABID.todo };
+        }
+        delete totalBody.customDisplayPage;
+        const session = await env.host.getSession();
+        // 超时/紧急探查仅在 legacy（低版本）待办查询生效（来源：Python execute_workflow_search_legacy）
+        const probeEnabled = category === 'todo' && !batchType && searchMode === 'legacy';
+        // 待阅探查：待办查询且当前不在「待阅(5)」子分类时补一路待阅总数
+        // （来源：Python execute_workflow_search_legacy 的 wait_read_future）
+        const waitReadEnabled = probeEnabled && tabid !== '5';
+        const waitReadBody = JSON.parse(JSON.stringify(query));
+        waitReadBody.params = { ...(waitReadBody.params || {}), tabid: '5' };
+        delete waitReadBody.customDisplayPage;
+        const responses = await Promise.all([
+            env.host.workflowRequest({ method: 'POST', path: WORKFLOW_ENDPOINTS[totalKey], operation: 'workflow.search.total', body: totalBody }),
+            totalOnly
+                ? Promise.resolve(null)
+                : env.host.workflowRequest({ method: 'POST', path: WORKFLOW_ENDPOINTS[listKey], operation: 'workflow.search', body: query }),
+            probeEnabled ? probeTodoOverdue(env, query, totalKey) : Promise.resolve(null),
+            probeEnabled ? probeTodoUrgent(env, query, totalKey) : Promise.resolve(null),
+            waitReadEnabled
+                ? env.host.workflowRequest({ method: 'POST', path: WORKFLOW_ENDPOINTS.TODO_TOTAL, operation: 'workflow.search.probe.waitRead', body: waitReadBody })
+                : Promise.resolve(null),
+        ]);
+        const totalResponse = responses[0];
+        const listResponse = responses[1];
+        const probes = { overdue: responses[2], urgent: responses[3] };
+        const total = extractTotal(totalResponse);
+        if (total === null) {
+            throw workflowValidationError('workflow_total_invalid', '总数接口未返回有效数据，本次已停止返回，避免把接口异常误判为 0 条。', { retryAllowed: false });
+        }
+        // 探查失败必须硬失败：把接口异常当成「无超时/无紧急」会让用户与模型都误判为 0 条
+        // （来源：Python require_probe_success + require_http_result）
+        if (probeEnabled) {
+            requireProbeSuccess(probes.overdue, 'TODO_OVERDUE_PROBE', '超时待办探查');
+            requireProbeSuccess(probes.urgent, 'TODO_URGENT_PROBE', '紧急待办探查');
+        }
+        let waitReadTotal = null;
+        if (waitReadEnabled) {
+            waitReadTotal = extractTotal(responses[4]);
+            if (waitReadTotal === null) {
+                throw workflowValidationError('wait_read_total_invalid', '待阅总数接口未返回有效数据，本次已停止返回，避免把接口异常误判为 0 条。', { retryAllowed: false });
+            }
+        }
+        if (totalOnly) {
+            return workflowSuccess('workflow.search', {
+                type: 'workflowSearch',
+                renderMode: searchMode,
+                category,
+                categoryName: CATEGORY_NAMES[category],
+                total,
+                finalMarkdown: buildSearchFinalMarkdown(null, probes, total, category, true, searchMode === 'smart', waitReadTotal),
+            });
+        }
+        const normalized = normalizeListResponse(listResponse, category, CATEGORY_NAMES[category], session.baseUrl ?? '');
+        normalized.total = total;
+        const index = await saveListIndex(env, normalized);
+        return workflowSuccess('workflow.search', await enforceSearchStdoutBudget({
+            type: 'workflowSearch',
+            renderMode: searchMode,
+            category,
+            categoryName: CATEGORY_NAMES[category],
+            total,
+            hasMore: normalized.hasMore,
+            current: normalized.current,
+            pageSize: normalized.pageSize,
+            // 条目只输出机器可读的定位/标识/可操作性字段——渲染一律用 finalMarkdown，
+            // 不再回显渲染字段（此前 cards / cardItems / renderMarkdown 三份互相重复）。
+            cards: normalized.items.map(slimIndexItem),
+            finalMarkdown: buildSearchFinalMarkdown(normalized, probes, total, category, false, searchMode === 'smart', waitReadTotal),
+            queryId: index.queryId,
+            sessionMap: { queryId: index.queryId, itemCount: normalized.items.length },
+        }, env, { json: 'last_search.json', md: 'last_search.md' }));
+    },
+};
+// ---------------------------------------------------------------------------
+// workflow.search 执行模式路由与最终 Markdown（来源：Python resolve_workflow_search_mode /
+// build_workflow_search_final_markdown / todo_probe_notice）
+// ---------------------------------------------------------------------------
+/** 智能分组基线版本（来源：Python _SMART_GROUPING_MIN_OA_VERSION） */
+const SMART_GROUPING_MIN_OA_VERSION = [10, 0, 9909, 1];
+/** 把版本元组格式化为 OA 习惯的四段式（尾两段补零：10.0.9909.01）。错误提示一律由常量派生，避免文案与判定漂移。 */
+function formatOaVersion(tuple) {
+    const [a, b, c, d] = tuple;
+    return `${a}.${b}.${c}.${String(d).padStart(2, '0')}`;
+}
+function oaVersionTuple(version) {
+    const numbers = String(version ?? '')
+        .split(/[^0-9]+/)
+        .filter(Boolean)
+        .map((part) => Number(part));
+    return [numbers[0] ?? 0, numbers[1] ?? 0, numbers[2] ?? 0, numbers[3] ?? 0];
+}
+function isVersionAtLeast(actual, min) {
+    for (let i = 0; i < 4; i += 1) {
+        if (actual[i] !== min[i])
+            return actual[i] > min[i];
+    }
+    return true;
+}
+/** 解析查询执行模式：版本 ≥ 基线走 smart；版本未知/运行时不可用 → legacy 兜底 */
+async function resolveSearchMode(env, args) {
+    const forced = (asString(args.mode) ?? '').toLowerCase();
+    if (forced === 'smart' || forced === 'legacy')
+        return forced;
+    try {
+        const session = await env.host.getSession();
+        const version = asString(session.version) ?? '';
+        if (version && isVersionAtLeast(oaVersionTuple(version), SMART_GROUPING_MIN_OA_VERSION))
+            return 'smart';
+    }
+    catch (error) {
+        // 认证/网络错误不得被"版本未知 → legacy"吞掉（否则登录过期会被伪装成低版本模式）
+        rethrowAuthOrNetworkError(error);
+        // 其余情形（会话信息取不到）按 legacy 兜底
+    }
+    return 'legacy';
+}
+/** 超时/紧急探查提示（来源：Python todo_probe_notice） */
+function todoProbeNotice(probes) {
+    const parts = [];
+    const overdueTotal = asInt(probes?.overdue?.total) ?? 0;
+    if (overdueTotal > 0)
+        parts.push(`${overdueTotal} 条超时待办`);
+    const urgentTotal = asInt(probes?.urgent?.total) ?? 0;
+    if (urgentTotal > 0) {
+        const levelName = asString(probes?.urgent?.level?.levelName) ?? '紧急';
+        parts.push(`${urgentTotal} 条${levelName}待办`);
+    }
+    if (!parts.length)
+        return '';
+    return `另外，该条件下有${parts.join('、')}，建议优先关注。`;
+}
+/** workflow.search 最终 Markdown（来源：Python build_workflow_search_final_markdown） */
+function buildSearchFinalMarkdown(normalized, probes, total, category, totalOnly, smartMode, waitReadTotal = null) {
+    const label = CATEGORY_NAMES[category];
+    const lines = [];
+    if (totalOnly) {
+        lines.push(`共 ${total} 条${label}。`);
+    }
+    else if (smartMode) {
+        // smart 模式：不输出顶部统计行——只渲染纯卡片列表，分组名称与汇总由模型书写
+    }
+    else {
+        const current = asInt(normalized?.current) ?? 1;
+        const visible = (normalized?.cardItems || []).length;
+        lines.push(`共 ${total} 条${label}，当前显示第 ${current} 页（${visible} 条）。`);
+    }
+    if (!totalOnly) {
+        const notice = todoProbeNotice(probes);
+        if (notice)
+            lines.push(notice);
+        // 待阅提示（来源：Python build_workflow_search_final_markdown 的 wait_read_total 分支）
+        if (asInt(waitReadTotal) !== undefined && asInt(waitReadTotal) > 0) {
+            lines.push(`另有 ${asInt(waitReadTotal)} 条待阅流程。`);
+        }
+    }
+    const body = normalized ? renderListMarkdown(normalized) : '';
+    if (body)
+        lines.push(body);
+    return lines.filter(Boolean).join('\n\n');
+}
+/**
+ * 认证/网络类错误必须**原样向上抛**，不得被包装成探查失败或总数降级。
+ *
+ * 反例（实测 2026-09-15）：登录态过期时 `TODO_URGENT_PROBE` 抛的是
+ * `type=authentication, subtype=session_expired`，但被包装成 `todo_probe_invalid`
+ * （`type=validation`「接口未返回有效数据」）后，模型与用户会把"登录过期"误判为
+ * "数据问题"，既不会引导重新登录、也看不出真实原因（真实原因只能到 `details.detail` 里找）。
+ * 对照：同环境的已办查询（不走探查）正确返回 `authentication/session_expired`。
+ *
+ * 因此只放行这两类错误，其余错误（业务错误、协议异常等）仍按原逻辑处理。
+ */
+export function rethrowAuthOrNetworkError(error) {
+    const type = error?.type;
+    if (type === 'authentication' || type === 'network')
+        throw error;
+}
+/**
+ * 探查失败必须硬失败（来源：Python require_probe_success / require_http_result）。
+ * 此前探查异常被静默吞成 `{error:true,total:null}`，会被当成「无超时/无紧急」——
+ * 与「0 计数不体现」的渲染红线叠加后，用户与模型都会把接口异常误判为 0 条。
+ */
+function requireProbeSuccess(probe, label, title) {
+    if (!probe || typeof probe !== 'object' || !probe.error)
+        return;
+    throw workflowValidationError('todo_probe_invalid', `${title}（${label}）接口未返回有效数据，本次已停止返回，避免把接口异常误判为无超时/无紧急。`, { retryAllowed: false, probe: label, detail: asString(probe.errorMessage) ?? null });
+}
+// ---------------------------------------------------------------------------
+// legacy（低版本模式）待办分组查询
+//
+// 来源：Python `execute_grouped_todo_search` / `normalize_todo_group_list` /
+// `combine_todo_group_results` / `build_grouped_todo_summary_markdown`
+// （V11.2 查询逻辑，V11.3 由 legacy 分支沿用）。恢复版本门槛后（阈值 10.0.9909.01），
+// 低版本 OA 环境将长期走这条分支，故必须与 V11.3 对齐。
+//
+// 未移植项（有意为之）：V11.3 的 `frequentPreference` / `batchSuggestions` 两路依赖
+// **结构化记忆偏好**（displayPreferences.groupMode/groupOrder、queryPreferences、
+// batchApprovalPreferences）——该记忆上下文在 V12 已改为由模型经 `workflow.memoryPrompt`
+// 读取并自行应用，CLI 侧不再解析记忆提示词。默认分组顺序与 V11.3 在「无记忆偏好」时完全一致。
+// ---------------------------------------------------------------------------
+/** 是否显式指定了待办子分类（来源：Python explicit_tab 判定）。 */
+function hasExplicitTab(args) {
+    return Boolean(asString(args.subCategory) || asString(args.tabName) ||
+        (args.tabid !== undefined && String(args.tabid).trim() !== ''));
+}
+/** 复制查询并覆写 tabid（可选覆写展示窗口大小）（来源：Python todo_query_for_tab）。 */
+function todoQueryForTab(query, tabid, pageSize) {
+    const clone = JSON.parse(JSON.stringify(query));
+    clone.params = { ...(clone.params || {}), tabid };
+    if (pageSize !== undefined) {
+        clone.customDisplayPage = {
+            ...(clone.customDisplayPage || {}),
+            current: Math.max(1, asInt(clone.customDisplayPage?.current) ?? 1),
+            size: Math.max(1, Math.min(pageSize, 100)),
+        };
+    }
+    return clone;
+}
+/** 待办 tabid → 子分类名（分组标题用；来源：WORKFLOW_CATEGORIES.tabs 反查）。 */
+function todoTabName(tabid) {
+    for (const [name, value] of Object.entries(SUB_CATEGORY_TABS.todo)) {
+        if (value === String(tabid))
+            return name;
+    }
+    return '待处理';
+}
+/** 取一组待办明细（list 接口）并按请求窗口归一化（来源：Python normalize_todo_group_list）。 */
+async function fetchLegacyTodoGroupList(env, query, total, baseUrl) {
+    const response = await env.host.workflowRequest({
+        method: 'POST',
+        path: WORKFLOW_ENDPOINTS.TODO_LIST,
+        operation: 'workflow.search.group.list',
+        body: query,
+    });
+    const normalized = normalizeListResponse(response, 'todo', CATEGORY_NAMES.todo, baseUrl);
+    const window = (query.customDisplayPage || {});
+    normalized.current = asInt(window.current) ?? normalized.current;
+    normalized.pageSize = asInt(window.size) ?? normalized.pageSize;
+    normalized.total = total;
+    normalized.hasMore = (asInt(normalized.pageSize) ?? 0) * (asInt(normalized.current) ?? 1) < total;
+    return normalized;
+}
+/** 跨组去重：剔除已被更高优先级分组展示过的流程（来源：Python filter_group_normalized_to_unseen）。 */
+function filterGroupToUnseen(normalized, seenRequestIds) {
+    const cards = (normalized.cardItems || []).slice();
+    const items = (normalized.items || []).slice();
+    const itemByRid = new Map();
+    for (const item of items) {
+        const rid = asString(item?.requestId);
+        if (rid)
+            itemByRid.set(rid, item);
+    }
+    const keptCards = [];
+    const keptItems = [];
+    for (const card of cards) {
+        const rid = asString(card?.internal?.requestId) ?? '';
+        if (!rid || seenRequestIds.has(rid))
+            continue;
+        seenRequestIds.add(rid);
+        keptCards.push(card);
+        const item = itemByRid.get(rid);
+        if (item)
+            keptItems.push(item);
+    }
+    normalized.cardItems = keptCards;
+    normalized.items = keptItems;
+}
+/**
+ * 合并各分组（来源：Python combine_todo_group_results）。
+ *
+ * 每个分组的序号**独立从 1 开始**——全局递增会让「待处理」组序号从紧急组之后起编，
+ * 与分组标题里展示的序号对不上。
+ */
+function combineLegacyTodoGroups(groupResults) {
+    const combinedCards = [];
+    const combinedItems = [];
+    const indexGroups = {};
+    const markdownParts = [];
+    const groupPages = [];
+    for (const group of groupResults) {
+        const normalized = group.normalized || {};
+        const cards = normalized.cardItems || [];
+        const items = normalized.items || [];
+        const itemByRid = new Map();
+        for (const item of items) {
+            const rid = asString(item?.requestId);
+            if (rid)
+                itemByRid.set(rid, item);
+        }
+        const current = asInt(normalized.current) ?? 1;
+        const groupIndexItems = [];
+        let groupIndex = 1;
+        for (const card of cards) {
+            const rid = asString(card?.internal?.requestId) ?? '';
+            card.index = groupIndex;
+            card.renderMarkdown = renderCardMarkdown(card);
+            const item = itemByRid.get(rid);
+            if (item) {
+                item.index = groupIndex;
+                combinedItems.push(item);
+                groupIndexItems.push(item);
+            }
+            combinedCards.push(card);
+            groupIndex += 1;
+        }
+        indexGroups[group.kind] = { kind: group.kind, label: group.label, items: groupIndexItems };
+        const displayed = cards.length;
+        if (group.total > 0) {
+            markdownParts.push(`### ${group.label}（共 ${group.total} 条，第 ${current} 页显示 ${displayed} 条）`);
+            markdownParts.push(displayed
+                ? cards.map((card) => String(card.renderMarkdown || '')).join('\n\n---\n\n')
+                : '本页记录已在更高优先级分组中展示。');
+        }
+        groupPages.push({ kind: group.kind, label: group.label, total: group.total, current, displayed });
+    }
+    return {
+        cards: combinedCards,
+        items: combinedItems,
+        indexGroups,
+        groupPages,
+        renderMarkdown: markdownParts.filter(Boolean).join('\n\n'),
+    };
+}
+/**
+ * 通用待办顶部汇总（来源：Python build_grouped_todo_summary_markdown）。
+ *
+ * 分页数量只留在各分组标题里，顶部汇总只说总量与构成；记忆偏好尾句未移植（见本节说明）。
+ */
+function buildGroupedTodoSummaryMarkdown(total, summary) {
+    const personalTotal = asInt(summary.personalTotal) ?? 0;
+    const overdueTotal = asInt(summary.overdueTotal) ?? 0;
+    const urgentTotal = asInt(summary.urgentTotal) ?? 0;
+    const sharedTotal = asInt(summary.sharedTotal) ?? 0;
+    const sharedTotals = {
+        forward: asInt(summary.forwardTotal) ?? 0,
+        cc: asInt(summary.ccTotal) ?? 0,
+        circulate: asInt(summary.circulateTotal) ?? 0,
+    };
+    const sharedLabels = { forward: '转发', cc: '抄送', circulate: '传阅' };
+    const priorityParts = [];
+    if (overdueTotal > 0)
+        priorityParts.push(`${overdueTotal} 条为超时流程`);
+    if (urgentTotal > 0)
+        priorityParts.push(`${urgentTotal} 条为紧急流程`);
+    const categories = [];
+    if (personalTotal > 0) {
+        const suffix = priorityParts.length ? `（其中 ${priorityParts.join('、')}，建议优先关注）` : '';
+        categories.push({ label: '需您亲自处理的流程', value: personalTotal, suffix });
+    }
+    if (sharedTotal > 0) {
+        const activeNames = ['forward', 'cc', 'circulate']
+            .filter((kind) => (sharedTotals[kind] ?? 0) > 0)
+            .map((kind) => sharedLabels[kind]);
+        let sharedLabel;
+        if (activeNames.length === 1) {
+            sharedLabel = `${activeNames[0]}给您的流程`;
+        }
+        else if (activeNames.length > 1) {
+            sharedLabel = `${activeNames.slice(0, -1).join('、')}和${activeNames[activeNames.length - 1]}给您的流程`;
+        }
+        else {
+            sharedLabel = '转发、抄送或传阅给您的流程';
+        }
+        categories.push({ label: sharedLabel, value: sharedTotal, suffix: '' });
+    }
+    if (categories.length === 1) {
+        return `共有 ${total} 条流程待办，均为${categories[0].label}${categories[0].suffix}。`;
+    }
+    if (categories.length > 1) {
+        const clauses = categories.map((item) => `${item.label}共 ${item.value} 条${item.suffix}`);
+        return `共有 ${total} 条流程待办：${clauses.join('，')}。`;
+    }
+    return `共有 ${total} 条流程待办。`;
+}
+/** legacy 待办分组查询（来源：Python execute_grouped_todo_search）。 */
+async function executeLegacyGroupedTodoSearch(env, args) {
+    const { query, tabid } = await buildSearchQuery(env, { ...args, searchMode: 'legacy' }, 'list');
+    const session = await env.host.getSession();
+    const baseUrl = session.baseUrl ?? '';
+    const mainSize = Math.max(1, Math.min(asInt(args.pageSize) ?? 10, 100));
+    const auxSize = Math.min(mainSize, 5);
+    const mainTabid = tabid || SUB_CATEGORY_TABS.todo['待处理'];
+    const mainQuery = todoQueryForTab(query, mainTabid, mainSize);
+    const personalQuery = todoQueryForTab(query, '7', mainSize);
+    const allQuery = todoQueryForTab(query, '0', mainSize);
+    const waitReadQuery = todoQueryForTab(query, '5', auxSize);
+    const forwardQuery = todoQueryForTab(query, '4', auxSize);
+    const ccQuery = todoQueryForTab(query, '9', auxSize);
+    const circulateQuery = todoQueryForTab(query, '11', auxSize);
+    const overdueQuery = todoQueryForTab(query, '6', auxSize);
+    // 紧急探查：主查询已带 requestlevel 条件时不再探查（紧急是「待处理」子集，不随展示页签漂移）
+    const hasRequestLevel = Boolean(query?.searchParams?.formDatas?.requestlevel);
+    let urgentQuery = null;
+    let urgentLevelName = '紧急';
+    if (!hasRequestLevel) {
+        let level = null;
+        try {
+            level = await highestRequestLevelProbe(env);
+        }
+        catch (error) {
+            rethrowAuthOrNetworkError(error);
+            requireProbeSuccess({ error: true, errorMessage: errorText(error) }, 'TODO_URGENT_PROBE', '紧急待办探查');
+        }
+        if (level) {
+            urgentLevelName = level.levelName || '紧急';
+            urgentQuery = todoQueryForTab(query, '7', auxSize);
+            urgentQuery.searchParams = urgentQuery.searchParams || {};
+            urgentQuery.searchParams.formDatas = urgentQuery.searchParams.formDatas || {};
+            urgentQuery.searchParams.formDatas.requestlevel = [{ content: level.id }];
+        }
+    }
+    // 阶段一：各分组总数（独立总数接口；列表接口 total 与组内条数不同口径，不可当组总数用）
+    const totalJobs = {
+        all_total: planTotalCount(env, allQuery, 'todo'),
+        main_total: planTotalCount(env, mainQuery, 'todo'),
+        wait_read_total: planTotalCount(env, waitReadQuery, 'todo'),
+        forward_total: planTotalCount(env, forwardQuery, 'todo'),
+        cc_total: planTotalCount(env, ccQuery, 'todo'),
+        circulate_total: planTotalCount(env, circulateQuery, 'todo'),
+        overdue_total: planTotalCount(env, overdueQuery, 'todo'),
+    };
+    if (mainTabid !== '7')
+        totalJobs.personal_total = planTotalCount(env, personalQuery, 'todo');
+    if (urgentQuery)
+        totalJobs.urgent_total = planTotalCount(env, urgentQuery, 'todo');
+    const totalPairs = await Promise.all(Object.entries(totalJobs).map(async ([key, task]) => [key, await task]));
+    const totals = {};
+    for (const [key, value] of totalPairs)
+        totals[key] = value;
+    if (mainTabid === '7')
+        totals.personal_total = totals.main_total ?? null;
+    const requiredTotals = [
+        'all_total', 'personal_total', 'main_total', 'wait_read_total',
+        'forward_total', 'cc_total', 'circulate_total', 'overdue_total',
+    ];
+    if (requiredTotals.some((key) => totals[key] === null || totals[key] === undefined)) {
+        throw workflowValidationError('workflow_group_total_invalid', '待办分组查询未能取得完整总数，本次已停止返回，避免展示不完整分组。', { retryAllowed: false });
+    }
+    const allTotal = totals.all_total;
+    const mainTotal = totals.main_total;
+    const overdueTotal = totals.overdue_total;
+    const urgentTotal = totals.urgent_total ?? 0;
+    // 回退：未指定子分类（默认待处理）且待处理无数据时，改查「全部」——此时只给汇总、
+    // 没有任何可看列表，而转发/抄送/传阅类待办同样是有效内容。待处理为 0 时紧急（待处理子集）
+    // 必为 0；条目卡片自带超时徽标，故回退后不再单列超时/紧急组，避免与全部组重复。
+    const fallbackToAll = mainTabid === '7' && mainTotal === 0 && allTotal > 0;
+    // 超时/紧急列表仅在对应分组有货时取（无货时 V11.3 也不消费该响应）
+    const showOverdue = !fallbackToAll && mainTabid !== '6' && overdueTotal > 0;
+    const showUrgent = !fallbackToAll && Boolean(urgentQuery) && urgentTotal > 0;
+    // 阶段二：明细（主列表 + 有货的特殊组列表）；回退时主列表即「全部」
+    const mainListQuery = fallbackToAll ? allQuery : mainQuery;
+    const mainListTotal = fallbackToAll ? allTotal : mainTotal;
+    const listJobs = {
+        main_list: fetchLegacyTodoGroupList(env, mainListQuery, mainListTotal, baseUrl),
+    };
+    if (showOverdue)
+        listJobs.overdue_list = fetchLegacyTodoGroupList(env, overdueQuery, overdueTotal, baseUrl);
+    if (showUrgent) {
+        listJobs.urgent_list = fetchLegacyTodoGroupList(env, urgentQuery, urgentTotal, baseUrl);
+    }
+    const listPairs = await Promise.all(Object.entries(listJobs).map(async ([key, task]) => [key, await task]));
+    const lists = {};
+    for (const [key, value] of listPairs)
+        lists[key] = value;
+    // 分组顺序：紧急 → 超时 → 待处理（V11.3 todo_group_order 在无记忆偏好时的稳定顺序）
+    const groups = [];
+    if (showUrgent) {
+        groups.push({ kind: 'urgent', label: `${urgentLevelName}待办`, total: urgentTotal, normalized: lists.urgent_list });
+    }
+    if (showOverdue) {
+        groups.push({ kind: 'overdue', label: '超时待办', total: overdueTotal, normalized: lists.overdue_list });
+    }
+    // 回退时主组即「全部」（待处理无数据时不再展示空的待处理组）
+    groups.push({
+        kind: 'pending',
+        label: `${todoTabName(fallbackToAll ? '0' : mainTabid)}流程`,
+        total: mainListTotal,
+        normalized: lists.main_list,
+    });
+    // 跨组去重：待处理组完整展示（不剔除），超时/紧急组剔除已在更高优先级分组出现过的流程
+    const seenRequestIds = new Set();
+    for (const group of groups) {
+        if (group.kind === 'pending')
+            continue;
+        filterGroupToUnseen(group.normalized, seenRequestIds);
+    }
+    const combined = combineLegacyTodoGroups(groups);
+    const todoSummary = {
+        personalTotal: totals.personal_total,
+        sharedTotal: totals.wait_read_total,
+        overdueTotal,
+        urgentTotal,
+        forwardTotal: totals.forward_total,
+        ccTotal: totals.cc_total,
+        circulateTotal: totals.circulate_total,
+    };
+    const index = await saveSearchIndex({ groups: combined.indexGroups, items: combined.items, summary: { type: 'workflowSearch', category: 'todo', total: allTotal } }, env.ctx);
+    const renderMarkdown = combined.renderMarkdown;
+    // 回退时顶部行先说清口径切换（本次展示的是全部待办，而非默认的待处理），再给总量与构成
+    const summaryLine = fallbackToAll
+        ? `暂无需您亲自处理的流程，以下展示全部待办。${buildGroupedTodoSummaryMarkdown(allTotal, todoSummary)}`
+        : buildGroupedTodoSummaryMarkdown(allTotal, todoSummary);
+    const finalMarkdown = [summaryLine, renderMarkdown]
+        .filter(Boolean)
+        .join('\n\n');
+    return workflowSuccess('workflow.search', await enforceSearchStdoutBudget({
+        type: 'workflowSearch',
+        renderMode: 'legacy',
+        category: 'todo',
+        categoryName: CATEGORY_NAMES.todo,
+        displayMode: 'groupedCards',
+        total: allTotal,
+        hasMore: (asInt(lists.main_list.pageSize) ?? 0) * (asInt(lists.main_list.current) ?? 1) < mainListTotal,
+        current: asInt(lists.main_list.current) ?? 1,
+        pageSize: asInt(lists.main_list.pageSize) ?? mainSize,
+        // 与普通查询返回同构：条目只输出机器可读的定位/标识/可操作性字段
+        cards: combined.items.map(slimIndexItem),
+        finalMarkdown,
+        todoSummary,
+        todoGroups: combined.groupPages,
+        queryId: index.queryId,
+        sessionMap: { queryId: index.queryId, groupCount: groups.length, itemCount: combined.items.length },
+    }, env, { json: 'last_search.json', md: 'last_search.md' }));
+}
+/** 超时待办探查：复制主查询、tabid=6 走总数接口（来源：Python todo_overdue_probe） */
+async function probeTodoOverdue(env, query, totalKey) {
+    const tabid = asString(query?.params?.tabid) ?? '';
+    if (tabid === '6')
+        return { skipped: true, reason: 'main_query_is_overdue', total: null };
+    if (tabid === '9')
+        return { skipped: true, reason: 'main_query_is_cc', total: null };
+    const probeQuery = JSON.parse(JSON.stringify(query));
+    probeQuery.params = { ...(probeQuery.params || {}), tabid: '6' };
+    delete probeQuery.customDisplayPage;
+    try {
+        const response = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS[totalKey],
+            operation: 'workflow.search.probe.overdue',
+            body: probeQuery,
+        });
+        return { skipped: false, query: probeQuery, total: extractTotal(response) };
+    }
+    catch (error) {
+        rethrowAuthOrNetworkError(error);
+        return { skipped: false, error: true, errorMessage: errorText(error), total: null };
+    }
+}
+/** 最高紧急程度待办探查：复制主查询并追加 requestlevel 过滤（来源：Python todo_urgent_probe） */
+async function probeTodoUrgent(env, query, totalKey) {
+    const existing = query?.searchParams?.formDatas?.requestlevel;
+    if (Array.isArray(existing) && existing.length) {
+        return { skipped: true, reason: 'main_query_has_requestlevel', total: null };
+    }
+    // 依赖接口失败必须算探查失败（来源：Python highest_request_level_probe_condition_nonfatal 返回
+    // {"error": response} 后被 require_probe_success 拦下）——不能静默当成「无紧急待办」
+    let level;
+    try {
+        level = await highestRequestLevelProbe(env);
+    }
+    catch (error) {
+        rethrowAuthOrNetworkError(error);
+        return { skipped: false, error: true, errorMessage: errorText(error), total: null };
+    }
+    if (!level)
+        return { skipped: true, reason: 'no_request_level_available', total: null };
+    const probeQuery = JSON.parse(JSON.stringify(query));
+    probeQuery.searchParams = probeQuery.searchParams || {};
+    probeQuery.searchParams.formDatas = probeQuery.searchParams.formDatas || {};
+    probeQuery.searchParams.formDatas.requestlevel = [{ content: level.id }];
+    delete probeQuery.customDisplayPage;
+    try {
+        const response = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS[totalKey],
+            operation: 'workflow.search.probe.urgent',
+            body: probeQuery,
+        });
+        return { skipped: false, level, query: probeQuery, total: extractTotal(response) };
+    }
+    catch (error) {
+        rethrowAuthOrNetworkError(error);
+        return { skipped: false, level, error: true, errorMessage: errorText(error), total: null };
+    }
+}
+/** 异常 → 简短可读文本（供硬失败错误详情使用）。 */
+function errorText(error) {
+    if (!error)
+        return '';
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+/**
+ * 从 query-dependency 的 requestLevelList 选最高优先级等级
+ * （来源：Python highest_request_level_probe_condition_nonfatal）。
+ *
+ * 依赖接口请求失败时**向上抛**——由调用方按探查失败处理（Python 侧同等情形返回 `{"error": ...}`
+ * 并被 `require_probe_success` 拦下），不得静默降级为「无紧急待办」。
+ */
+async function highestRequestLevelProbe(env) {
+    const levels = await fetchRequestLevels(env);
+    for (const word of ['紧急', '重要', '正常']) {
+        const matched = levels.find((item) => item.name.includes(word));
+        if (matched)
+            return { id: matched.id, levelName: matched.name };
+    }
+    return null;
+}
+function extractTotal(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 null;
+}
+/** 单张卡片的三行 Markdown：标题行（含徽标）+ 元信息行（来源：Python render_card_markdown）。
+ *
+ * smart（智能分组）模式不渲染摘要行——与 Python `include_summary=False` 一致。
+ */
+function renderCardMarkdown(card) {
+    const badgeTexts = (card.badgeObjects || [])
+        .map((badge) => stripHtml(badge?.text))
+        .filter(Boolean)
+        .map((text) => `\`${text}\``);
+    const badges = badgeTexts.length ? ` ${badgeTexts.join(' ')}` : '';
+    const metaParts = (card.meta || [])
+        .map((pair) => {
+        const label = stripHtml(pair?.label);
+        const value = stripHtml(pair?.value);
+        return label && value ? `${label}：${value}` : '';
+    })
+        .filter(Boolean);
+    const meta = metaParts.join('　　');
+    const titleText = `${card.index}. ${asString(card.title) ?? ''}`.trim();
+    const url = asString(card.url) ?? '';
+    const title = url ? `[${stripHtml(titleText)}](${url})` : stripHtml(titleText);
+    const lines = [`**${title}**${badges}  `];
+    if (meta)
+        lines.push(meta);
+    return lines.join('\n');
+}
+function renderListMarkdown(normalized) {
+    const items = normalized.cardItems || [];
+    if (!items.length)
+        return '无匹配流程';
+    return items.map((card) => renderCardMarkdown(card)).join('\n\n---\n\n');
+}
+// plan 取数分页口径（来源：Python _PLAN_GROUP_FETCH_PAGE_SIZE / _PLAN_GROUP_FETCH_MAX_PAGES
+// 与 _plan_execute_slot 的 pageSize=100 / max_pages=500）
+const PLAN_FETCH_PAGE_SIZE = 100;
+const PLAN_SLOT_FETCH_MAX_PAGES = 500;
+const PLAN_GROUP_FETCH_MAX_PAGES = 50;
+/** 列表响应原始记录（与 normalizeListResponse 的取值路径一致）。 */
+function planListRecords(response) {
+    const record = responseData(response);
+    return toArray(record?.data?.displayData ?? record?.displayData ?? record?.data?.list ?? record?.list ?? []);
+}
+/** 覆写分页窗口（来源：Python prepare_list_query 的 current/pageSize → customDisplayPage）。 */
+function planPageQuery(baseQuery, current, size) {
+    const clone = JSON.parse(JSON.stringify(baseQuery));
+    clone.customDisplayPage = { current: Math.max(1, current), size: Math.max(1, Math.min(size, 100)) };
+    return clone;
+}
+/** 槽位/组总数以独立总数接口为准（来源：Python prepare_total_query + extract_total_count）。
+ *
+ * 列表接口返回的 total 与展示窗口不同口径，不能直接当组内条数用；失败返回 null 由调用方降级。
+ */
+async function planTotalCount(env, query, category) {
+    const prefix = ENDPOINT_PREFIX[category];
+    const totalKey = `${prefix}_TOTAL`;
+    const body = JSON.parse(JSON.stringify(query));
+    delete body.customDisplayPage;
+    try {
+        const response = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS[totalKey],
+            operation: 'workflow.search.plan.total',
+            body,
+        });
+        return extractTotal(response);
+    }
+    catch (error) {
+        // 认证/网络错误不得降级成 null（否则各组总数会静默变 0，用户看到的是"没有待办"而不是"没登录"）
+        rethrowAuthOrNetworkError(error);
+        return null;
+    }
+}
+/** 翻页取数并按「合并记录后一次 normalize」返回（来源：Python _plan_execute_slot 的 requestId 收集
+ *  循环、_plan_execute_regular_group 的翻页合并 —— 合并后统一编号，保证卡片序号全局连续）。
+ *
+ * pageThrough=false 时仅取第一页展示窗口（用于展开组「无草稿」快速通道）。
+ */
+async function planCollectRecords(env, baseQuery, category, totalCount, options) {
+    const merged = [];
+    const seen = new Set();
+    let firstPageTotal = null;
+    let current = 1;
+    let size = options.firstPageSize;
+    for (let page = 0; page < options.maxPages; page += 1) {
+        const response = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS[options.listKey],
+            operation: options.operation,
+            body: planPageQuery(baseQuery, current, size),
+        });
+        if (firstPageTotal === null)
+            firstPageTotal = extractTotal(response);
+        const rows = planListRecords(response);
+        if (!rows.length)
+            break;
+        let added = 0;
+        for (const row of rows) {
+            const rid = asString(row?.requestId ?? row?.requestid ?? row?.id) ?? '';
+            if (rid && seen.has(rid))
+                continue;
+            if (rid)
+                seen.add(rid);
+            merged.push(row);
+            added += 1;
+        }
+        if (!options.pageThrough)
+            break;
+        const bound = totalCount;
+        if (bound !== null && merged.length >= bound)
+            break;
+        // 本页无新增或不满一页 → 已到末页（来源：Python _plan_execute_regular_group 的 added==0 判定）
+        if (added === 0 || rows.length < size)
+            break;
+        current += 1;
+        size = PLAN_FETCH_PAGE_SIZE;
+    }
+    const effectiveTotal = totalCount ?? firstPageTotal ?? merged.length;
+    const mergedResponse = {
+        data: {
+            data: {
+                displayData: merged,
+                total: effectiveTotal,
+                current: 1,
+                pageSize: merged.length || 1,
+                hasMore: false,
+            },
+        },
+    };
+    return {
+        records: merged,
+        normalized: normalizeListResponse(mergedResponse, category, CATEGORY_NAMES[category], options.baseUrl),
+    };
+}
+/** smart 纯卡片渲染：展示窗口截断到 pageCap（来源：Python _plan_render_first_page）。 */
+function renderPlanCards(normalized, pageCap) {
+    const cards = normalized.cardItems || [];
+    return renderListMarkdown({ ...normalized, cardItems: cards.slice(0, Math.max(0, pageCap)) });
+}
+// ---------------------------------------------------------------------------
+// workflow.search --plan-json 批量编排（来源：cmd_workflow_search_plan / _plan_execute_regular_group）
+// ---------------------------------------------------------------------------
+/**
+ * plan 展开组的**错误兜底**：条件解析失败只判该组 `error`，不让整份 plan 失败。
+ *
+ * 对齐 V11.3：`_plan_execute_regular_group` 对 `condition` 解析失败一律
+ * `return {"groupName": group_name, "status": "error", "error": err}`（L13316-13322），
+ * 文档侧口径见 `workflow-search.md:225`「0 命中或多命中判该组 `error`（plan 内不做澄清）」。
+ *
+ * 只吞 `validation` 类错误——认证/网络错误必须原样抛出（否则登录过期会被伪装成"这组条件有问题"）。
+ * 非 `WorkflowCliError` 一律重抛：那是程序缺陷，不该被降级成数据结论。
+ */
+function planGroupError(groupName, error) {
+    if (!(error instanceof WorkflowCliError) || error.type !== 'validation')
+        throw error;
+    const details = (error.details ?? {});
+    const clarification = error.subtype === CLARIFICATION_SUBTYPE;
+    return {
+        groupName,
+        status: 'error',
+        collapsed: false,
+        // 与 V11.3 的组内文案同口径（`_plan_system_field_form_datas`：
+        // 「plan 内不做澄清，请改用 名称(ID) 形式」）——否则模型会把澄清问题当成"该组没有数据"。
+        error: clarification
+            ? `${error.message}（plan 内不做澄清：请把候选原样交给用户确认，再用「名称(ID)」重跑该组）`
+            : error.message,
+        ...(clarification
+            ? {
+                clarificationType: details.clarificationType ?? null,
+                clarificationKeyword: details.clarificationKeyword ?? null,
+                candidates: Array.isArray(details.candidates) ? details.candidates : [],
+            }
+            : {}),
+    };
+}
+/**
+ * 执行一个**展开组**（plan 阶段二）。组内所有错误由调用方 `planGroupError` 兜底成 `status:'error'`。
+ *
+ * 返回 `{groupName,status,total,hasMore,finalMarkdown,pureDraft,draftCount,nonDraftCount}`。
+ */
+async function executeRegularPlanGroup(env, group, groupName, category, pageCap, countDetails, excludeIds, baseUrl) {
+    // 纯草稿组：stat 计数已证明全组草稿 —— 零明细请求，直接返回折叠元数据
+    // （来源：Python _plan_draft_precheck + _plan_execute_regular_group 的 pure 分支）
+    const precheck = planDraftPrecheck(group, countDetails);
+    if (precheck.verdict === 'pure') {
+        return {
+            groupName,
+            status: 'ok',
+            collapsed: false,
+            total: precheck.totalSum,
+            hasMore: false,
+            finalMarkdown: '',
+            pureDraft: true,
+            draftCount: precheck.draftSum,
+            nonDraftCount: 0,
+        };
+    }
+    const condition = normalizePlanCondition(group.condition);
+    const subArgs = { ...condition, category };
+    // 排除集 = 特殊组自动收集 ∪ 本组 condition.exRequestIds（来源：Python _plan_execute_regular_group
+    // 的 `list(exclude_ids) + scope_ex + group_ex`）
+    const mergedExRequestIds = [...new Set([...excludeIds, ...splitRequestIds(condition.exRequestId)])];
+    if (mergedExRequestIds.length)
+        subArgs.exRequestId = mergedExRequestIds.join(',');
+    else
+        delete subArgs.exRequestId;
+    const { query } = await buildSearchQuery(env, subArgs, 'list');
+    // 组总数走独立总数接口（列表接口 total 口径不等于组内条数，不可作为翻页上界）；明细按该总数封顶。
+    // 无草稿组只取展示窗口；混合/未知组翻页取全，以便逐条判定草稿并精确剔除
+    // （来源：Python _plan_execute_regular_group）。
+    const groupTotal = await planTotalCount(env, query, category);
+    const noDraftFastChannel = precheck.verdict === 'none';
+    const fetchOptions = {
+        firstPageSize: noDraftFastChannel ? pageCap : PLAN_FETCH_PAGE_SIZE,
+        pageThrough: !noDraftFastChannel,
+        maxPages: PLAN_GROUP_FETCH_MAX_PAGES,
+        operation: 'workflow.search.plan.group',
+        listKey: 'TODO_LIST',
+        baseUrl,
+    };
+    let collected = await planCollectRecords(env, query, category, groupTotal, fetchOptions);
+    // 快速通道页内粗检草稿：stat 过期（宣称无草稿但明细有）→ 降级为大页翻页取全
+    // （来源：Python _plan_execute_regular_group 的 mixed 降级分支）
+    let degradationUsed = false;
+    if (noDraftFastChannel && planHasDraftItem(collected.normalized)) {
+        collected = await planCollectRecords(env, query, category, groupTotal, {
+            ...fetchOptions,
+            firstPageSize: PLAN_FETCH_PAGE_SIZE,
+            pageThrough: true,
+        });
+        degradationUsed = true;
+    }
+    const effectiveGroupTotal = asInt(collected.normalized.total) ?? groupTotal ?? 0;
+    const normalized = collected.normalized;
+    // 草稿卡片不逐条展示：从渲染列表剔除，数量单独上报（来源：Python 展开组 draft_flags 处理）
+    const cardItems = normalized.cardItems || [];
+    const itemList = normalized.items || [];
+    const draftFlags = cardItems.map((_card, position) => PLAN_GROUP_DRAFT_LABELS.has(asString(itemList[position]?.flowStatus) ?? ''));
+    const draftCount = draftFlags.filter(Boolean).length;
+    const nonDraftCount = cardItems.length - draftCount;
+    const pureDraft = cardItems.length > 0 && nonDraftCount === 0;
+    let hasMore;
+    if (pureDraft) {
+        hasMore = false;
+    }
+    else if (noDraftFastChannel && !degradationUsed) {
+        // 快速通道只取了展示窗口：未展示的非草稿 = 组总数 - 页内已渲染条数
+        hasMore = effectiveGroupTotal > nonDraftCount;
+    }
+    else {
+        hasMore = nonDraftCount > pageCap;
+    }
+    const rendered = {
+        ...normalized,
+        items: normalized.items.filter((_item, position) => !draftFlags[position]),
+        cardItems: cardItems.filter((_card, position) => !draftFlags[position]),
+    };
+    return {
+        groupName,
+        status: 'ok',
+        collapsed: false,
+        total: effectiveGroupTotal,
+        hasMore,
+        finalMarkdown: pureDraft ? '' : renderPlanCards(rendered, pageCap),
+        pureDraft,
+        draftCount,
+        nonDraftCount,
+    };
+}
+async function executePlanSearch(env, plan, planPageSize = 10) {
+    const category = (asString(plan.category) || 'todo');
+    if (category !== 'todo') {
+        throw workflowValidationError('plan_category', 'plan.category 目前仅支持 todo');
+    }
+    const pageCap = Math.max(1, Math.min(asInt(planPageSize) ?? 10, 100));
+    const groups = plan.groups;
+    if (!Array.isArray(groups) || !groups.length) {
+        throw workflowValidationError('plan_groups', 'plan.groups 必须是非空分组数组');
+    }
+    if (groups.length > PLAN_MAX_GROUPS) {
+        throw workflowValidationError('plan_groups', `plan.groups 展开+折叠组总数不能超过 ${PLAN_MAX_GROUPS}`, { groupCount: groups.length });
+    }
+    // 特殊组类型必须合法（来源：Python cmd_workflow_search_plan 的 unknown_special 校验）——
+    // 静默丢弃会让"模型声明了却没生效"无从排查。
+    const rawSpecialGroups = plan.specialGroups;
+    if (rawSpecialGroups !== undefined && rawSpecialGroups !== null && !Array.isArray(rawSpecialGroups)) {
+        throw workflowValidationError('plan_special_groups', 'plan.specialGroups 必须是数组（如 ["urgentOvertime", "forwardToSelf"]）');
+    }
+    const specialGroups = Array.isArray(rawSpecialGroups) ? rawSpecialGroups : [];
+    const unknownSpecial = specialGroups.filter((sg) => !PLAN_SPECIAL_GROUP_TYPES.includes(asString(sg) ?? ''));
+    if (unknownSpecial.length) {
+        throw workflowValidationError('plan_special_groups', `plan.specialGroups 含不支持的类型 ${JSON.stringify(unknownSpecial)}（支持：${JSON.stringify(PLAN_SPECIAL_GROUP_TYPES)}）`, { supported: PLAN_SPECIAL_GROUP_TYPES });
+    }
+    // 每个分组必须带非空 groupName（来源：Python 同名校验）——否则分组标题无从渲染
+    groups.forEach((group, i) => {
+        if (!group || typeof group !== 'object' || !(asString(group.groupName) ?? '').trim()) {
+            throw workflowValidationError('plan_group_name', `plan.groups 第 ${i + 1} 项必须是含非空 groupName 的对象`, { index: i + 1 });
+        }
+    });
+    const session = await env.host.getSession();
+    // 取最近待办统计快照（countDetails）：折叠组据其代码统计、特殊组据其有货探测。
+    // 与 Python _plan_load_count_details 等价（Python 读 last_stat.json；此处对 TodoStat 接口取全量快照）。
+    const countDetails = await fetchPlanStatSnapshot(env, plan);
+    const specialOutputs = [];
+    const groupOutputs = [];
+    // 阶段一：特殊组（有货才跑；urgent 槽带 requestlevel=2）
+    const excludeIds = [];
+    for (const sg of specialGroups) {
+        if (sg === 'urgentOvertime' || sg === 'forwardToSelf') {
+            if (countDetails.length && !planSpecialHasData(sg, countDetails))
+                continue;
+            const slots = [];
+            const slotTypes = sg === 'urgentOvertime' ? ['overtime', 'urgent'] : ['forward'];
+            for (const slotType of slotTypes) {
+                const tabid = PLAN_SLOT_TABID[slotType];
+                const { query } = await buildSearchQuery(env, { ...normalizePlanCondition(plan.condition), tabid, category }, 'list');
+                if (slotType === 'urgent') {
+                    query.searchParams = query.searchParams || {};
+                    query.searchParams.formDatas = query.searchParams.formDatas || {};
+                    query.searchParams.formDatas.requestlevel = [{ content: '2' }];
+                }
+                // 槽位总数走独立总数接口（列表 total 口径不可靠）；同槽翻页取全 requestId 作为排除集。
+                const slotTotal = await planTotalCount(env, query, category);
+                const collected = await planCollectRecords(env, query, category, slotTotal, {
+                    firstPageSize: PLAN_FETCH_PAGE_SIZE,
+                    pageThrough: true,
+                    maxPages: PLAN_SLOT_FETCH_MAX_PAGES,
+                    operation: 'workflow.search.plan.special',
+                    listKey: 'TODO_LIST',
+                    baseUrl: session.baseUrl ?? '',
+                });
+                for (const record of collected.records) {
+                    const rid = asString(record?.requestId ?? record?.requestid ?? record?.id);
+                    if (rid && !excludeIds.includes(rid))
+                        excludeIds.push(rid);
+                }
+                slots.push({
+                    slotType,
+                    total: slotTotal ?? collected.records.length,
+                    hasMore: slotTotal !== null && slotTotal > pageCap,
+                    finalMarkdown: renderPlanCards(collected.normalized, pageCap),
+                });
+            }
+            if (slots.length) {
+                specialOutputs.push({
+                    groupType: sg,
+                    displayName: sg === 'urgentOvertime' ? '紧急/超时' : '转发给您',
+                    slots,
+                    excludeCount: excludeIds.length,
+                });
+            }
+        }
+    }
+    // 阶段二：常规组（折叠组按 stat 快照代码统计、不调列表接口；展开组取明细并注入特殊组排除集）。
+    //
+    // **逐组隔离**：某一组的条件解析不出来（名称 0 命中/多命中、字段名未识别…）只把该组标成
+    // `status:'error'` 并把原因与候选带回，不能让整份 plan 失败——这是 V11.3 的既定口径
+    // （`_plan_execute_regular_group` → `{"groupName":..., "status":"error", "error":err}`），
+    // 也是 plan 的意义所在：组是彼此独立的子查询，坏一组不能毁掉其余组的结果。
+    for (const group of groups) {
+        const collapsed = asBool(group.collapsed, false);
+        if (collapsed) {
+            groupOutputs.push(planCollapseGroup(group, countDetails));
+            continue;
+        }
+        const groupName = asString(group.groupName) || '未命名分组';
+        try {
+            groupOutputs.push(await executeRegularPlanGroup(env, group, groupName, category, pageCap, countDetails, excludeIds, session.baseUrl ?? ''));
+        }
+        catch (error) {
+            groupOutputs.push(planGroupError(groupName, error));
+        }
+    }
+    return workflowSuccess('workflow.search', await enforceSearchStdoutBudget({
+        type: 'workflowSearchPlan',
+        category,
+        specialGroups: specialOutputs,
+        groups: groupOutputs,
+        excludeRequestIdCount: excludeIds.length,
+        statCount: countDetails.length,
+        displayRules: [
+            'plan 返回为批量编排结果：特殊组/展开组各段 finalMarkdown 均为纯卡片列表（无顶部行），原样粘贴到对应分组标题与一行汇总摘要下',
+            '紧急/超时组标题计数：N=该组各槽 total 之和、M=urgent 槽 total、K=overtime 槽 total（0 项省略），如 ## 紧急/超时（2 条｜紧急 1 条｜超时 1 条）',
+            '折叠组（collapsed=true）只返回 total 与 byWorkflow 数量，不展开明细；status=error 的组未取数，按 error 提示修正后可单独作为单条 workflow.search 查询',
+            'status=error 的组：原样把 error 交给用户。若该组同时带 clarificationType/candidates，说明是**名称没对上**（不是"该组没有数据"）——请把候选按「名称(ID)」摆给用户确认，再用该组条件单独发一次 workflow.search，禁止当作 0 条渲染或自行挑一个候选',
+            '任一流程只出现在一个分组：特殊组流程已注入 exRequestIds 从展开组排除',
+            '展开组 pureDraft=true：该组卡片全部为本人待提交草稿（draftCount=total），不要渲染其 finalMarkdown（为空），全部并入折叠组「待提交草稿（N 条）」（N=各 pureDraft 组 draftCount 之和）',
+            '展开组 pureDraft=false：其 finalMarkdown 已只渲染非草稿卡片（草稿卡片被剔除、数量见 draftCount），直接整段原样粘贴；组内草稿数量在标题/汇总注明即可，无需再逐条展示草稿',
+            '分组标题格式：## 组名（N 条）；分组顺序：紧急/超时 → 转发给您 → 需要您重点关注的流程 → 业务域展开组 → 待提交草稿 → 知会类折叠组',
+            '分组卡片渲染中禁止把卡片输出成 Markdown 表格、或压成连续文本编号列表（**仅约束卡片渲染**，不影响发起表单预览的明细表与批量操作结果表）；卡片必须原样保留标题链接、状态徽标与「标签：值」元信息行',
+        ],
+    }, env, { json: 'last_plan.json', md: 'last_plan.md' }));
+}
+/** requestId 条件值 → 逗号分隔文本（数组或已分隔字符串都接受）。 */
+function requestIdListText(value) {
+    if (Array.isArray(value))
+        return value.map((v) => String(v ?? '').trim()).filter(Boolean).join(',');
+    if (value === undefined || value === null)
+        return '';
+    return String(value).trim();
+}
+/** plan condition 键归一（来源：Python _plan_request_id_list / _plan_execute_regular_group）。
+ *
+ * 契约键是复数 `requestIds` / `exRequestIds`（V11.3 plan 规范），而 buildSearchQuery 读的是
+ * 单数 `requestId` / `exRequestId`。若不做归一，模型按契约传复数键会被**静默丢弃**——
+ * 实测 condition.requestIds=["<某条>"] 直接退化成全量待办（total 926 而非 1），
+ * 会让「需要您重点关注的流程」组失效。此处复数/单数两种写法都接受。
+ */
+function normalizePlanCondition(condition) {
+    const source = condition && typeof condition === 'object' ? { ...condition } : {};
+    const requestIds = source.requestIds !== undefined ? source.requestIds : source.requestId;
+    if (requestIds !== undefined) {
+        const text = requestIdListText(requestIds);
+        if (text)
+            source.requestId = text;
+        else
+            delete source.requestId;
+    }
+    delete source.requestIds;
+    const exRequestIds = source.exRequestIds !== undefined ? source.exRequestIds : source.exRequestId;
+    if (exRequestIds !== undefined) {
+        const text = requestIdListText(exRequestIds);
+        if (text)
+            source.exRequestId = text;
+        else
+            delete source.exRequestId;
+    }
+    delete source.exRequestIds;
+    return source;
+}
+/** 逗号分隔 requestId 文本 → 去重数组。 */
+function splitRequestIds(text) {
+    return requestIdListText(text)
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+/** 快速通道页内草稿粗检（来源：Python _plan_execute_regular_group 的 none 分支页内检查，
+ *  明细层判定口径为 flowStatus ∈ {草稿,待提交}）。 */
+function planHasDraftItem(normalized) {
+    const items = normalized.items || [];
+    return items.some((item) => PLAN_GROUP_DRAFT_LABELS.has(asString(item?.flowStatus) ?? ''));
+}
+/** 展开组草稿构成预判（来源：Python _plan_draft_precheck；仅依据 stat 计数，不发明细查询）。
+ *
+ * pure = draftCount 合计 > 0 且 == totalCount 合计（纯草稿）；
+ * none = draftCount 合计 == 0（无草稿）；mixed = 介于两者之间；unknown = 组无 workflow 成员或未命中 stat 行。
+ */
+function planDraftPrecheck(group, countDetails) {
+    const condition = group?.condition && typeof group.condition === 'object' ? group.condition : {};
+    const members = condition.workflow;
+    const memberList = Array.isArray(members) ? members : members ? [members] : [];
+    if (!memberList.length)
+        return { verdict: 'unknown', totalSum: 0, draftSum: 0 };
+    const workflowIds = new Set();
+    for (const member of memberList) {
+        const parsed = parseNameWithId(asString(member) ?? '');
+        if (!parsed.id)
+            return { verdict: 'unknown', totalSum: 0, draftSum: 0 };
+        workflowIds.add(parsed.id);
+    }
+    const rows = (countDetails || []).filter((row) => row && typeof row === 'object' && workflowIds.has(asString(row.workflowId) ?? ''));
+    if (!rows.length)
+        return { verdict: 'unknown', totalSum: 0, draftSum: 0 };
+    let totalSum = 0;
+    let draftSum = 0;
+    for (const row of rows) {
+        totalSum += asInt(row.totalCount) ?? 0;
+        draftSum += asInt(row.draftCount) ?? 0;
+    }
+    if (draftSum > 0 && draftSum === totalSum)
+        return { verdict: 'pure', totalSum, draftSum };
+    if (draftSum === 0)
+        return { verdict: 'none', totalSum, draftSum };
+    return { verdict: 'mixed', totalSum, draftSum };
+}
+// plan 折叠组/特殊组相关的参与身份集合（来源：Python _PLAN_FOLD_REMARK_NAMES / _PLAN_FORWARD_REMARK_NAMES，L12859）
+const PLAN_FOLD_REMARK_NAMES = new Set([
+    '传阅接收人', '传阅接收人(委托)', '传阅接收人不需反馈', '传阅接收人不需反馈(委托)',
+    '抄送接收人', '抄送接收人(委托)', '抄送接收人不需反馈', '抄送接收人不需反馈(委托)',
+]);
+const PLAN_FORWARD_REMARK_NAMES = new Set([
+    '转发接收人', '转发接收人(委托)', '转发接收人不需反馈', '转发接收人不需反馈(委托)',
+]);
+async function fetchPlanStatSnapshot(env, plan) {
+    // 优先复用最近一次 workflow.todoStat 的落盘快照（来源：Python _plan_load_count_details）——
+    // 与模型规划分组用的是同一份口径，且省一次统计请求；快照缺失/过期再回退到实时查询。
+    try {
+        const text = await readStateFile('last_stat.json', env.ctx);
+        if (text) {
+            const parsed = JSON.parse(text);
+            const rows = toArray(parsed?.countDetails ?? parsed?.data?.countDetails ?? []);
+            if (rows.length)
+                return rows;
+        }
+    }
+    catch {
+        // 快照不可用 → 走实时查询
+    }
+    try {
+        const { query } = await buildSearchQuery(env, { ...normalizePlanCondition(plan.condition), category: 'todo' }, 'stat');
+        const response = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS.TODO_GROUP_STAT,
+            operation: 'workflow.todoStat',
+            body: query,
+        });
+        const data = responseData(response);
+        return toArray(data?.countDetails ?? []);
+    }
+    catch (error) {
+        // 认证/网络错误不得被当成"该组无数据"——否则登录过期会被伪装成「特殊组为空」静默少渲染
+        rethrowAuthOrNetworkError(error);
+        return [];
+    }
+}
+function planSpecialHasData(groupType, countDetails) {
+    if (groupType === 'urgentOvertime') {
+        return countDetails.some((row) => (asInt(row?.urgentCount) ?? 0) > 0) ||
+            countDetails.some((row) => (asInt(row?.overtimeCount) ?? 0) > 0);
+    }
+    if (groupType === 'forwardToSelf') {
+        return countDetails.some((row) => {
+            const name = asString(row?.isRemarkName);
+            return PLAN_FORWARD_REMARK_NAMES.has(name ?? '') && ((asInt(row?.forwardToSelfCount) ?? 0) > 0 || (asInt(row?.totalCount) ?? 0) > 0);
+        });
+    }
+    return false;
+}
+function planCollapseGroup(group, countDetails) {
+    const groupName = asString(group?.groupName) || '未命名折叠组';
+    const condition = group?.condition || {};
+    // 折叠组只支持 workflow（数量按统计快照口径统计，不发明细查询）；其余键一律判 error。
+    // 单数/复数两种写法都拒（与 Python _PLAN_COLLAPSED_CONDITION_KEYS 一致）。
+    const unsupported = [
+        'receiveTime', 'createTime', 'requestLevel', 'filterFields',
+        'requestIds', 'exRequestIds', 'requestId', 'exRequestId', 'creator', 'workflowType',
+    ].filter((k) => condition[k]);
+    if (unsupported.length) {
+        return { groupName, status: 'error', collapsed: true, error: `折叠组按统计快照数量统计，不支持 ${unsupported.join('/')}——需要该条件时请改为展开组` };
+    }
+    let memberIds = null;
+    const wf = condition.workflow;
+    if (wf) {
+        const members = Array.isArray(wf) ? wf : [wf];
+        memberIds = new Set();
+        for (const m of members) {
+            const parsed = parseNameWithId(asString(m) ?? '');
+            if (parsed.id)
+                memberIds.add(parsed.id);
+        }
+    }
+    const matched = (countDetails || []).filter((row) => {
+        if (!row || typeof row !== 'object')
+            return false;
+        if (!PLAN_FOLD_REMARK_NAMES.has(asString(row.isRemarkName) ?? ''))
+            return false;
+        if (memberIds && !memberIds.has(asString(row.workflowId) ?? ''))
+            return false;
+        return true;
+    });
+    const total = matched.reduce((sum, row) => sum + (asInt(row.totalCount) ?? 0), 0);
+    const byWorkflow = {};
+    for (const row of matched) {
+        const wfName = asString(row.workflowName) || asString(row.workflowId) || '未知';
+        byWorkflow[wfName] = (byWorkflow[wfName] ?? 0) + (asInt(row.totalCount) ?? 0);
+    }
+    const result = {
+        groupName,
+        status: 'ok',
+        collapsed: true,
+        total,
+        byWorkflow: Object.keys(byWorkflow).map((name) => ({ workflowName: name, count: byWorkflow[name] })),
+    };
+    if (total === 0) {
+        result.warning = '按折叠身份口径（传阅/抄送接收人及委托）未在 countDetails 命中数据——请核对成员工作流或考虑改为展开组';
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// workflow.todoStat（来源：cmd_workflow_todo_stat，TODO_GROUP_STAT，必带 category=todo）
+// ---------------------------------------------------------------------------
+/** todoStat 输出安全线（来源：Python WORKFLOW_SEARCH_STDOUT_SAFE_BYTES）。 */
+const TODO_STAT_STDOUT_SAFE_BYTES = 50_000;
+/** 行内 requestIds（逗号分隔 CSV）超过该长度就只留条数，明细留在 resultFile。
+ *
+ *  抄送/传阅类行的 requestIds 可达数百条（≈17KB），是另一处截断隐患。 */
+const TODO_STAT_ROW_ID_LIST_MAX_CHARS = 1_000;
+/** 行内 requestIds 超长时退化为条数（全量仍在 resultFile）。 */
+function todoStatTrimRowDetail(row) {
+    if (!row || typeof row !== 'object')
+        return row;
+    const ids = row.requestIds;
+    if (typeof ids !== 'string' || ids.length <= TODO_STAT_ROW_ID_LIST_MAX_CHARS)
+        return row;
+    const trimmed = { ...row };
+    delete trimmed.requestIds;
+    trimmed.requestIdsCount = ids.split(',').filter((part) => part.trim()).length;
+    trimmed.requestIdsOmitted = true;
+    return trimmed;
+}
+/** 精简统计行保留的字段（来源：Python compact_todo_stat_count_details）。
+ *
+ *  去掉行内 formFields（体积主体），保留全部数量类字段与 requestIds/requestInfos
+ *  ——后者是「需要您重点关注的流程」逐条判定的依据。 */
+const TODO_STAT_COMPACT_KEYS = [
+    'workflowId', 'workflowName', 'workflowTypeId', 'workflowTypeName',
+    'nodeId', 'nodeName', 'nodeTypeName', 'isRemark', 'isRemarkName',
+    'totalCount', 'forwardToSelfCount', 'urgentCount', 'overtimeCount', 'managerForwardToSelfCount',
+    'pendingCount', 'draftCount', 'beRejectCount',
+    'requestIds', 'requestInfos',
+];
+/** requestInfos 条目保留字段：分组逐条判定只用 ID / 标题 / 发起时间 / 字段值前缀。 */
+const TODO_STAT_REQUEST_INFO_KEYS = ['requestId', 'requestNameTitle', 'createDateTime'];
+/** 条目字段值在 stdout 里保留的最大字符数（超出部分留在 resultFile）。
+ *
+ *  实测通知类条目的「留言内容」可达 2,800 字（占单行 22KB 的绝大部分），而逐条判定
+ *  需要的受众/执行要求都写在正文开头，保留前缀即可判定；完整正文按需从 resultFile 取。 */
+const TODO_STAT_FORM_FIELD_VALUE_MAX_CHARS = 200;
+function todoStatCompactRequestInfo(item) {
+    if (!item || typeof item !== 'object')
+        return item;
+    const kept = {};
+    for (const key of TODO_STAT_REQUEST_INFO_KEYS) {
+        if (key in item)
+            kept[key] = item[key];
+    }
+    const values = item.formFieldValues;
+    if (values && typeof values === 'object') {
+        const trimmed = {};
+        let truncated = false;
+        for (const [name, value] of Object.entries(values)) {
+            if (typeof value !== 'string' || value.length <= TODO_STAT_FORM_FIELD_VALUE_MAX_CHARS) {
+                trimmed[name] = value;
+                continue;
+            }
+            trimmed[name] = `${value.slice(0, TODO_STAT_FORM_FIELD_VALUE_MAX_CHARS)}…`;
+            truncated = true;
+        }
+        kept.formFieldValues = trimmed;
+        if (truncated)
+            kept.formFieldValuesTruncated = true;
+    }
+    return kept;
+}
+function todoStatCompactRow(item) {
+    if (!item || typeof item !== 'object')
+        return item;
+    const kept = {};
+    for (const key of TODO_STAT_COMPACT_KEYS) {
+        if (key in item)
+            kept[key] = item[key];
+    }
+    if (Array.isArray(kept.requestInfos)) {
+        kept.requestInfos = kept.requestInfos.map(todoStatCompactRequestInfo);
+    }
+    return todoStatTrimRowDetail(kept);
+}
+/**
+ * 统计结果过大时落盘 + 返回精简版（来源：Python enforce_todo_stat_stdout_budget）。
+ *
+ * 目的：避免 180KB+ 的 countDetails 全量进 stdout，逼模型现场写脚本解析
+ * （实测会多花 3~4 步且易解析错）。行**完整**返回、只去掉行内 formFields；
+ * 需要对某工作流做字段分组判断时才从 resultFile 针对性取该行 formFields。
+ * 落盘不可用时保持全量输出（宁大不丢数据），并给出提示。
+ */
+async function compactTodoStatOutput(result, env) {
+    const bytes = Buffer.byteLength(JSON.stringify(result), 'utf8');
+    if (bytes <= TODO_STAT_STDOUT_SAFE_BYTES)
+        return result;
+    const resultFile = await writeStateFileBestEffort('last_stat.json', JSON.stringify(result, null, 2), env.ctx);
+    if (!resultFile) {
+        return {
+            ...result,
+            outputBytes: bytes,
+            largeOutputNotice: '统计结果较大且本地落盘不可用，已按原样返回全量 countDetails（行内含 formFields）。',
+        };
+    }
+    const compact = withLeadingMeta({
+        type: result.type || 'workflowTodoStat',
+        resultFile,
+        persistedResult: true,
+        outputBytes: bytes,
+        largeOutputNotice: '统计结果较大且含表单/留言正文，完整数据已写入 resultFile；'
+            + `上方 countDetails 各行完整（数量字段 + requestInfos 的 ID/标题/发起时间/字段值都在），`
+            + `仅移出体积大的行级 formFields，并把超长条目字段值截到前 ${TODO_STAT_FORM_FIELD_VALUE_MAX_CHARS} 字`
+            + '（判定所需的受众/执行要求写在正文开头，前缀已够用；带 formFieldValuesTruncated 标记的行如需全文再读 resultFile）。'
+            + '需要某工作流的字段清单时从 resultFile 里该元素针对性提取，不要把全量内容搬入上下文。'
+            + '读取本输出时请一次读完：不要用 head/tail 等管道截断（截断会破坏 JSON，并导致重复执行同一命令）。',
+    }, {
+        ...result,
+        countDetails: toArray(result.countDetails).map(todoStatCompactRow),
+    });
+    if (Buffer.byteLength(JSON.stringify(compact), 'utf8') <= TODO_STAT_STDOUT_SAFE_BYTES)
+        return compact;
+    // 极端兜底（分组行极多）：只保留路径与总量信息
+    const trimmed = { ...compact, countDetailsTruncated: true };
+    delete trimmed.countDetails;
+    return trimmed;
+}
+const workflowTodoStat = {
+    name: 'workflow.todoStat',
+    resource: 'workflow',
+    method: 'todoStat',
+    action: 'workflow.todoStat',
+    summary: '按工作流/参与节点/参与身份三元组统计当前用户待办分组计数（智能分组第一步）',
+    capability: 'search',
+    risk: 'read',
+    inputSchema: schemaOf({
+        category: { const: 'todo' },
+        subCategory: { type: 'string' },
+        tabid: { type: 'string' },
+        tabName: { type: 'string' },
+        creator: { type: 'string' },
+        creatorDept: { type: 'string' },
+        workflowType: { type: 'string' },
+        workflow: { type: 'array', items: { type: 'string' } },
+        requestLevel: { type: 'string' },
+        requestName: { type: 'string' },
+        requestMark: { type: 'string' },
+        createTime: { type: 'string' },
+        receiveTime: { type: 'string' },
+        finishTime: { type: 'string' },
+        filterFields: { type: 'array', items: { type: 'object' } },
+        nodeId: { type: 'string' },
+        requestId: { type: 'string' },
+        exRequestId: { type: 'string' },
+        conditionType: { type: 'string', enum: ['and', 'or'] },
+        sort: { type: 'string' },
+    }, { required: ['category'] }),
+    handler: async (args, env) => {
+        // 版本门禁：todoStat 的统计口径（tabid=0 全部 + 参与身份三元组）只在智能分组模式成立。
+        // 来源：Python 无独立 todoStat operation，只有 cmd_workflow_search_plan 的 smart 门禁 +
+        // execute_workflow_search_legacy 的分组输出——低版本待办统计由 workflow.search 的 legacy 分组输出承担。
+        // 低版本直接拒绝，避免模型拿到"全部(0)"口径统计（与 legacy"待处理(7)"口径矛盾）后按错误口径规划分组。
+        const mode = await resolveSearchMode(env, args);
+        if (mode !== 'smart') {
+            throw workflowValidationError('todo_stat_requires_smart_mode', `workflow.todoStat 仅支持智能分组模式（OA ≥ ${formatOaVersion(SMART_GROUPING_MIN_OA_VERSION)}）；低版本请直接走 workflow.search（CLI 会自动输出分组统计）`, { retryAllowed: false, renderMode: mode });
+        }
+        const { query } = await buildSearchQuery(env, { ...args, category: 'todo' }, 'stat');
+        const response = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS.TODO_GROUP_STAT,
+            operation: 'workflow.todoStat',
+            body: query,
+        });
+        const data = responseData(response);
+        const countDetails = toArray(data?.countDetails ?? []);
+        let total = 0;
+        let draftTotal = 0;
+        let pendingTotal = 0;
+        let beRejectTotal = 0;
+        for (const item of countDetails) {
+            if (!item || typeof item !== 'object')
+                continue;
+            total += asInt(item.totalCount) ?? 0;
+            draftTotal += asInt(item.draftCount) ?? 0;
+            pendingTotal += asInt(item.pendingCount) ?? 0;
+            beRejectTotal += asInt(item.beRejectCount) ?? 0;
+        }
+        return workflowSuccess('workflow.todoStat', await compactTodoStatOutput({
+            type: 'workflowTodoStat',
+            query,
+            total,
+            draftTotal,
+            pendingTotal,
+            beRejectTotal,
+            countDetails,
+            displayRules: [
+                'countDetails 数组元素按接口原样透传；模型据汇报式分组骨架做分组规划，再分别调用 workflow.search 取明细',
+                '折叠组（≤3 个）只显示数量——数量来自 countDetails 的 totalCount/urgentCount/overtimeCount/forwardToSelfCount/managerForwardToSelfCount 等字段，不需要再走 workflow.search 查数量',
+                'countDetails 行含 nodeTypeName（节点类型名）、pendingCount（标准待处理身份且非草稿数量）、draftCount（待办列表草稿口径命中数量，flowStatus∈{草稿,待提交}）、beRejectCount（被退回数量）。行 totalCount 与三者非严格相等，分组标题主计数仍用 totalCount；新字段用于草稿折叠预判与草稿/退回注记',
+                'draftTotal/pendingTotal/beRejectTotal 为各分组新计数字段的累加；汇报时可注明其中草稿 M 条、被退回 K 条，但不要据以改写主计数 total',
+            ],
+        }, env));
+    },
+};
+// ---------------------------------------------------------------------------
+// workflow.detail（来源：cmd_workflow_detail / normalize_workflow_detail_response）
+// ---------------------------------------------------------------------------
+const workflowDetail = {
+    name: 'workflow.detail',
+    resource: 'workflow',
+    method: 'detail',
+    action: 'workflow.detail',
+    summary: '按 requestId 或列表序号查看流程完整详情（基础信息 + 表单数据 + 签字意见）',
+    capability: 'view',
+    risk: 'read',
+    inputSchema: schemaOf({
+        requestId: SCHEMA_REQUEST_ID,
+        index: SCHEMA_INDEX,
+        group: { type: 'string', description: '分组标识（urgent/overdue/batch/pending），配合 index' },
+        requestLogCurrent: { type: 'integer', minimum: 1, default: 1 },
+        requestLogPageSize: { type: 'integer', minimum: 1, maximum: 50, default: 10 },
+    }),
+    handler: async (args, env) => {
+        const requestId = await resolveTargetRequestId(env, args);
+        const session = await env.host.getSession();
+        const payload = {
+            requestId,
+            isGetRequestBaseInfo: true,
+            isGetRequestLog: false,
+            isGetFormData: true,
+            isReadRequest: true,
+        };
+        if (session.userId)
+            payload.userId = session.userId;
+        const response = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS.REQUEST_DETAIL,
+            operation: 'workflow.detail',
+            body: payload,
+        });
+        const normalized = normalizeDetailResponse(response);
+        // 签字意见按页查询（来源：cmd_detail / attach_request_log_page）
+        const logCurrent = asInt(args.requestLogCurrent) ?? 1;
+        const logPageSize = Math.min(asInt(args.requestLogPageSize) ?? 10, 50);
+        const logPage = await fetchRequestLogPage(env, requestId, logCurrent, logPageSize);
+        normalized.requestLog = logPage;
+        normalized.renderMarkdown = renderDetailMarkdown(normalized);
+        return workflowSuccess('workflow.detail', {
+            type: 'workflowDetail',
+            basicInfo: normalized.basicInfo,
+            formData: normalized.formData,
+            requestLog: normalized.requestLog,
+            renderMarkdown: normalized.renderMarkdown,
+            warnings: normalized.warnings,
+            displayRules: [
+                '查看流程内容时必须直接输出单个 Markdown 详情面板，不要放进代码块，不要拆成多个独立卡片，不要输出 Markdown 表格',
+                '基础信息区、表单内容区、签字意见区必须在同一个 Markdown 面板内，用小标题区分，而不是渲染成多个卡片',
+                '流程标题下方不要添加分隔线或下划线；第一条分隔线只能出现在基础信息区之后',
+                '基础信息区展示流程编号、发起人/申请人、发起时间、当前节点、紧急程度和流程状态；字段缺失就不展示',
+                '表单内容区只展示核心业务字段，跳过空值、技术字段、可编辑、操作按钮、岗位、部门、最后反馈时间等非必要字段',
+                '表单字段值必须原样展示 value，不能摘要、改写、删减；字段含 valueHtml/links 时优先渲染为可点击超链接，不要把长 URL 直接作为普通文本换行展示',
+                'displayMode=longTextBlock 或 fullWidth=true 的表单字段必须全宽展示，保留原文、标点和换行；不要保留接口富文本里的背景色、字号和大段空白',
+                '签字意见是查看流程内容的固定组成部分，必须以意见块展示，不要压成表格或和表单字段混在一起；每条按三行展示（操作人/方式/时间、接收人、签字意见内容）',
+                '签字意见区标题写成「签字意见（{{paginationText}}）」；只有 requestLog.hasMore=true 时才显示 nextPagePrompt',
+                '不要展示 requestId；不要展示 workflowName，用户明确询问所属工作流时才展示为「工作流名称」；不要翻译、音译或改写接口返回文本',
+                '详情面板后不要输出固定建议列表或「如果想进一步操作」类尾巴；用户要求摘要/总结时改为围绕表单业务内容提炼，不要渲染详情表',
+            ],
+        });
+    },
+};
+function normalizeDetailResponse(response) {
+    const record = responseData(response);
+    const data = record?.data && typeof record.data === 'object' ? record.data : {};
+    const base = data.workflowBaseInfo && typeof data.workflowBaseInfo === 'object' ? data.workflowBaseInfo : {};
+    const other = data.otherInfo && typeof data.otherInfo === 'object' ? data.otherInfo : {};
+    const currentNodes = toArray(base.currentNodeList ?? []);
+    const currentNode = currentNodes
+        .map((n) => pickText(n, 'nodeName', 'name'))
+        .filter(Boolean)
+        .join('、');
+    const basicInfo = {
+        requestTitle: pickText(base, 'requestName', 'requestNameTitle') || pickText(other, 'multiReqName'),
+        flowName: pickText(base, 'requestName', 'requestNameTitle') || pickText(other, 'multiReqName'),
+        workflowName: pickText(base, 'workflowName'),
+        requestMark: pickText(base, 'requestmark', 'requestMark', 'requestCode'),
+        creatorName: pickText(base, 'creatorLastName', 'createrName', 'creatorName'),
+        createdAt: pickText(base, 'createDateTime', 'createTime'),
+        currentNode: currentNode || pickText(base, 'currentNodeName', 'nodeName'),
+        requestLevel: pickText(base, 'requestLevelShow', 'requestlevelShow', 'requestLevelTitle', 'requestlevelTitle') || asString(base.requestLevel),
+        flowStatus: pickText(base, 'flowstatusShow', 'status') || asString(base.flowStatus),
+    };
+    const formFields = extractFormFields(data);
+    const formLogs = extractRequestLogs(data);
+    return {
+        basicInfo,
+        formData: {
+            available: formFields.length > 0,
+            fieldCount: formFields.length,
+            fields: formFields,
+        },
+        requestLog: { available: formLogs.length > 0, items: formLogs },
+        warnings: [],
+    };
+}
+// 去 HTML 标签 + 反转义（来源：Python strip_html，L681）。模块级共用。
+function stripHtml(value) {
+    if (value === null || value === undefined)
+        return '';
+    const text = String(value).replace(/<[^>]+>/g, '');
+    const map = {
+        '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&apos;': "'", '&nbsp;': ' ',
+    };
+    return text.replace(/&[a-z]+;/gi, (m) => map[m.toLowerCase()] ?? m).replace(/\s+/g, ' ').trim();
+}
+function stringifyDetailValue(value) {
+    if (value === null || value === undefined)
+        return '';
+    if (typeof value === 'string')
+        return stripHtml(value);
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    if (Array.isArray(value)) {
+        const parts = [];
+        for (const item of value) {
+            const text = item && typeof item === 'object'
+                ? pickText(item, 'name', 'showName', 'label', 'title', 'value', 'content')
+                : stringifyDetailValue(item);
+            if (text)
+                parts.push(text);
+        }
+        return parts.join('、');
+    }
+    if (typeof value === 'object') {
+        const text = pickText(value, 'showValue', 'displayValue', 'name', 'showName', 'label', 'title', 'value', 'content');
+        if (text)
+            return text;
+        if (Array.isArray(value.browserDatas))
+            return stringifyDetailValue(value.browserDatas);
+    }
+    return '';
+}
+function stringifyDetailDataText(value) {
+    if (!value || typeof value !== 'object')
+        return stripHtml(value);
+    for (const key of ['content', 'richContent', 'text', 'value', 'displayValue', 'showValue']) {
+        const raw = value[key];
+        if (raw !== undefined && raw !== null && raw !== '' && !(Array.isArray(raw) && raw.length === 0) && !(typeof raw === 'object' && Object.keys(raw).length === 0)) {
+            const text = stripHtml(raw);
+            if (text)
+                return text;
+        }
+    }
+    return '';
+}
+// 详情表单字段容器：data 下所有键名含 "form" 且非空的键（来源：Python detail_form_source_keys，L2029）。
+function detailFormSourceKeys(data) {
+    if (!data || typeof data !== 'object')
+        return [];
+    return Object.keys(data).filter((k) => {
+        if (typeof k !== 'string' || !k.toLowerCase().includes('form'))
+            return false;
+        const v = data[k];
+        if (v === null || v === '' || (Array.isArray(v) && v.length === 0) || (typeof v === 'object' && Object.keys(v).length === 0))
+            return false;
+        return true;
+    });
+}
+function detailFormFieldValue(obj, formField) {
+    const dataKey = pickText(formField, 'dataKey', 'fieldKey', 'key');
+    const fieldId = pickText(formField, 'id', 'fieldId');
+    const fieldName = pickText(formField, 'title', 'fieldName', 'name', 'label');
+    const formData = obj?.formData;
+    if (formData && typeof formData === 'object') {
+        for (const k of [dataKey, fieldId, fieldName]) {
+            if (k && k in formData) {
+                const v = stringifyDetailValue(formData[k]);
+                if (v)
+                    return v;
+            }
+        }
+    }
+    const dataOptions = obj?.dataOptions;
+    if (Array.isArray(dataOptions) && dataOptions.length) {
+        const v = stringifyDetailValue(dataOptions);
+        if (v)
+            return v;
+    }
+    const dataText = obj?.dataText;
+    if (dataText && typeof dataText === 'object') {
+        const v = stringifyDetailDataText(dataText);
+        if (v)
+            return v;
+    }
+    for (const k of ['showValue', 'displayValue', 'fieldValue', 'value', 'content', 'text']) {
+        if (k in obj) {
+            const v = stringifyDetailValue(obj[k]);
+            if (v)
+                return v;
+        }
+    }
+    return '';
+}
+// 递归收集：命中 obj.formField（{title/fieldName/name/label}）即为一个表单字段（来源：Python
+// collect_detail_form_fields_from_obj，L2040），并继续下钻 dataDetails/details/mainData/... 等容器。
+function collectDetailFormFields(obj, fields, limit = 80) {
+    if (fields.length >= limit)
+        return;
+    if (Array.isArray(obj)) {
+        for (const item of obj)
+            collectDetailFormFields(item, fields, limit);
+        return;
+    }
+    if (!obj || typeof obj !== 'object')
+        return;
+    const formField = obj.formField;
+    if (formField && typeof formField === 'object') {
+        const fieldName = pickText(formField, 'title', 'fieldName', 'name', 'label');
+        if (fieldName) {
+            fields.push({
+                fieldId: pickText(formField, 'id', 'fieldId'),
+                fieldName,
+                componentKey: pickText(formField, 'componentKey', 'type'),
+                value: detailFormFieldValue(obj, formField),
+            });
+        }
+    }
+    for (const key of ['dataDetails', 'details', 'mainData', 'detailData', 'subData', 'rows', 'children', 'items', 'list']) {
+        if (key in obj) {
+            collectDetailFormFields(obj[key], fields, limit);
+        }
+    }
+}
+function extractFormFields(data) {
+    const sourceKeys = detailFormSourceKeys(data);
+    const fields = [];
+    for (const key of sourceKeys) {
+        collectDetailFormFields(data[key], fields);
+        if (fields.length >= 80)
+            break;
+    }
+    return fields;
+}
+function extractRequestLogs(data) {
+    const logKeys = ['requestLogList', 'requestLogs', 'logs', 'logList', 'signList', 'records'];
+    const out = [];
+    for (const key of logKeys) {
+        const arr = toArray(data?.[key]);
+        if (arr.length)
+            out.push(...arr.map((l) => normalizeLogItem(l)).filter((l) => l && detailLogHasContent(l)));
+    }
+    return out;
+}
+function detailLogHasContent(log) {
+    return Boolean(log && (log.operator || log.action || log.time || log.opinion || log.receivers));
+}
+// ---------------------------------------------------------------------------
+// 签字意见归一化（来源：normalize_detail_log_item / fetch_request_log_page）
+// ---------------------------------------------------------------------------
+async function fetchRequestLogPage(env, requestId, current, pageSize) {
+    const session = await env.host.getSession();
+    const payload = { requestId, current: Math.max(1, current), pageSize: Math.max(1, Math.min(50, pageSize)) };
+    if (session.userId)
+        payload.userId = session.userId;
+    const response = await env.host.workflowRequest({
+        method: 'POST',
+        path: WORKFLOW_ENDPOINTS.REQUEST_LOG,
+        operation: 'workflow.requestLog',
+        body: payload,
+    });
+    const data = responseData(response);
+    const items = toArray(data?.data?.list ?? data?.data?.records ?? data?.list ?? data?.records ?? data?.records ?? [])
+        .map((l) => normalizeLogItem(l))
+        .filter((l) => detailLogHasContent(l));
+    const total = extractTotal(response);
+    const totalReliable = total !== null;
+    const hasMore = asBool(data?.hasMore ?? data?.data?.hasMore, false) ||
+        (totalReliable ? current * pageSize < total : items.length >= pageSize);
+    return {
+        available: items.length > 0,
+        current,
+        pageSize,
+        currentPageCount: items.length,
+        total,
+        totalReliable,
+        hasMore,
+        nextCurrent: hasMore ? current + 1 : null,
+        nextPagePrompt: hasMore ? `可继续查看第 ${current + 1} 页签字意见` : '',
+        items,
+        paginationText: `第 ${current} 页，每页 ${pageSize} 条`,
+        paginationNote: '签字意见按页展示；只有 hasMore=true 时才提示查看下一页',
+    };
+}
+function normalizeLogItem(item) {
+    if (!item || typeof item !== 'object')
+        return {};
+    const operator = pickText(item, 'operatorName', 'operator', 'operatorUser', 'userName', 'handlerName', 'creatorName', 'handleUser');
+    const action = pickText(item, 'commentName', 'operateType', 'operateTypeName', 'operationType', 'actionName', 'typeName', 'status', 'statusName');
+    const time = pickText(item, 'operateTime', 'operateDateTime', 'handlerTime', 'createTime', 'createdatetime', 'createDateTime', 'time');
+    let opinion = pickText(item, 'opinion', 'remark', 'signRemark', 'content', 'comment', 'message');
+    const receivers = pickText(item, 'receiverName', 'receivers', 'receivePersonName', 'receiver');
+    const operatorDisplay = operator || '未返回';
+    const actionDisplay = action || '未返回';
+    const timeDisplay = time || '未返回';
+    const opinionDisplay = opinion || '未填写意见';
+    return {
+        operator,
+        operatorDisplay,
+        time,
+        timeDisplay,
+        action,
+        actionDisplay,
+        operatorActionTime: `${operatorDisplay} · ${actionDisplay} · ${timeDisplay}`,
+        receiverDisplay: receivers || '未返回',
+        opinion,
+        opinionDisplay,
+        displayLines: {
+            line1: `${operatorDisplay} · ${actionDisplay} · ${timeDisplay}`,
+            line2: `接收人：${receivers || '未返回'}`,
+            line3: opinionDisplay,
+        },
+        displayLayout: 'threeLineSignatureOpinion',
+    };
+}
+/** 详情字段取值：有 links 时优先渲染为可点击超链接（来源：Python detail_field_markdown_value） */
+function detailFieldMarkdownValue(field) {
+    const links = field.links;
+    if (Array.isArray(links) && links.length) {
+        const rendered = links
+            .map((link) => {
+            if (!link || typeof link !== 'object')
+                return '';
+            const url = asString(link.url) ?? asString(link.href) ?? '';
+            const label = asString(link.label) ?? asString(link.name) ?? '查看链接';
+            return url ? `[${label}](${url})` : '';
+        })
+            .filter(Boolean);
+        if (rendered.length)
+            return rendered.join('、');
+    }
+    return asString(field.value) ?? '';
+}
+function renderDetailMarkdown(normalized) {
+    const basic = normalized.basicInfo || {};
+    const lines = [`## ${asString(basic.flowName) || asString(basic.requestTitle) || '流程详情'}`, '', '### 基础信息'];
+    const baseItems = [
+        ['流程编号', basic.requestMark],
+        ['发起人', basic.creatorName],
+        ['发起时间', basic.createdAt],
+        ['当前节点', basic.currentNode],
+        ['紧急程度', basic.requestLevel],
+        ['流程状态', basic.flowStatus],
+    ];
+    for (const [label, value] of baseItems) {
+        const text = asString(value);
+        if (text)
+            lines.push(`- **${label}**：${text}`);
+    }
+    lines.push('', '---', '', '### 表单内容');
+    const fields = normalized.formData?.fields || [];
+    if (fields.length) {
+        for (const f of fields) {
+            const name = asString(f.fieldName);
+            const value = detailFieldMarkdownValue(f);
+            if (!name || !value)
+                continue;
+            // 长文本字段全宽展示：值用轻量正文阅读区承载，保留原文、标点和换行
+            if (f.displayMode === 'longTextBlock' || f.fullWidth === true || value.includes('\n')) {
+                const block = value.split('\n').map((part) => (part ? `  > ${part}` : '  >')).join('\n');
+                lines.push(`- **${name}**：`, '', block);
+            }
+            else {
+                lines.push(`- **${name}**：${value}`);
+            }
+        }
+    }
+    else {
+        lines.push('- 本次详情接口未返回可展示的表单字段。');
+    }
+    const log = normalized.requestLog || {};
+    const pagination = asString(log.paginationText) || '第 1 页，每页 10 条';
+    lines.push('', '---', '', `### 签字意见（${pagination}）`);
+    const logItems = log.items || [];
+    if (logItems.length) {
+        for (const it of logItems) {
+            const dl = it.displayLines || {};
+            let line1 = asString(dl.line1) ?? '';
+            let line2 = asString(dl.line2) ?? '';
+            let line3 = asString(dl.line3) ?? '';
+            if (!line1) {
+                const operator = asString(it.operatorDisplay) ?? '未返回';
+                const action = asString(it.actionDisplay) ?? '未返回';
+                const timeText = asString(it.timeDisplay) ?? asString(it.createdAt) ?? '未返回';
+                line1 = `${operator} · ${action} · ${timeText}`;
+            }
+            if (!line2)
+                line2 = `接收人：${asString(it.receiverDisplay) ?? '未返回'}`;
+            if (!line3) {
+                const opinion = asString(it.opinionDisplay) ?? asString(it.contentDisplay) ?? asString(it.content) ?? '未填写意见';
+                line3 = `签字意见：${opinion}`;
+            }
+            lines.push(`> **${line1}**`, '>', `> ${line2}`, '>', `> ${line3}`, '>');
+        }
+        if (lines[lines.length - 1] === '>')
+            lines.pop();
+    }
+    else {
+        lines.push('- 本页没有签字意见/流转日志。');
+    }
+    if (log.hasMore === true && log.nextPagePrompt)
+        lines.push('', asString(log.nextPagePrompt) ?? '');
+    return lines.join('\n').trim();
+}
+// ---------------------------------------------------------------------------
+// workflow.summary（来源：cmd_workflow_summary / select_detail_summary_fields / generate_business_summary）
+// ---------------------------------------------------------------------------
+const workflowSummary = {
+    name: 'workflow.summary',
+    resource: 'workflow',
+    method: 'summary',
+    action: 'workflow.summary',
+    summary: '按 requestId 或列表序号生成流程业务摘要上下文（不标记已读）',
+    capability: 'view',
+    risk: 'read',
+    inputSchema: schemaOf({
+        requestId: SCHEMA_REQUEST_ID,
+        index: SCHEMA_INDEX,
+        group: { type: 'string' },
+        summaryFields: { type: 'integer', minimum: 1, default: 12 },
+    }),
+    handler: async (args, env) => {
+        const requestId = await resolveTargetRequestId(env, args);
+        const session = await env.host.getSession();
+        const payload = {
+            requestId,
+            isGetRequestBaseInfo: true,
+            isGetRequestLog: false,
+            isGetFormData: true,
+            isReadRequest: false,
+        };
+        if (session.userId)
+            payload.userId = session.userId;
+        const response = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS.REQUEST_DETAIL,
+            operation: 'workflow.summary',
+            body: payload,
+        });
+        const normalized = normalizeDetailResponse(response);
+        const limit = Math.max(1, asInt(args.summaryFields) ?? 12);
+        const summaryFields = selectSummaryFields(normalized.formData.fields, limit);
+        const summaryText = generateBusinessSummary(summaryFields);
+        return workflowSuccess('workflow.summary', {
+            type: 'workflowSummary',
+            requestId,
+            basicInfo: normalized.basicInfo,
+            summaryFields,
+            summary: summaryText,
+            formDataAvailable: normalized.formData.available,
+        });
+    },
+};
+// 摘要字段过滤（来源：Python DETAIL_SUMMARY_* 常量与 select_detail_summary_fields，L862-894 / L989）
+const DETAIL_SUMMARY_EXCLUDED_TITLES = new Set([
+    '流程名称', '所属工作流', '流程编号', '发起人', '提交人', '创建人', '制单人', '填报人', '申请人',
+    '发起时间', '提交时间', '创建时间', '当前节点', '当前审批节点', '当前处理节点', '审批节点', '处理节点',
+    '流转节点', '流程节点', '节点名称', '紧急程度', '流程状态', '审批状态', '待办状态', '当前状态', '状态',
+    '停留时长', '停留时间', '文档', '附件', '相关文档', '相关附件', '相关客户', '相关项目', '相关人员',
+    '相关供应商', '相关订单', '相关合同', '相关人员信息', '相关商品', '相关产品',
+]);
+const SUMMARY_AMOUNT_FIELD_PATTERN = /(金额|总额|合计|预算|成本|收入|付款|收款|借款|费用总计|费用合计)/;
+const SUMMARY_REASON_FIELD_PATTERN = /(事由|原因|说明|概述|描述|内容|背景|价值|需求|事项)/;
+const SUMMARY_TYPE_FIELD_PATTERN = /(类型|类别|分类|方式|性质|用途)$/;
+const SUMMARY_DATE_FIELD_PATTERN = /(日期|时间|预计)/;
+const SUMMARY_DAY_FIELD_PATTERN = /(天数|人天|工时|时长|期限|周期)$/;
+const SUMMARY_PERSON_FIELD_PATTERN = /^(负责人|责任人|主管|审批人|经手人)$/;
+const CORE_FIELD_PATTERNS = [
+    SUMMARY_REASON_FIELD_PATTERN, SUMMARY_AMOUNT_FIELD_PATTERN, SUMMARY_TYPE_FIELD_PATTERN,
+    SUMMARY_DATE_FIELD_PATTERN, SUMMARY_DAY_FIELD_PATTERN, SUMMARY_PERSON_FIELD_PATTERN,
+];
+const DETAIL_SUMMARY_NOISE_FIELD_PATTERN = /文档|附件|链接|地址|url|URL/;
+const DETAIL_SUMMARY_BOOLEAN_FIELD_PATTERN = /是否|开关|启用/;
+const DETAIL_SUMMARY_RELATED_FIELD_PATTERN = /^相关/;
+const DETAIL_SUMMARY_PERSON_ROLE_PATTERN = /(负责人|责任人|处理人|经手人|审批人|接收人|联系人|办理人)/;
+const DETAIL_SUMMARY_META_TIME_PATTERN = /(?:最晚|期望|要求|承诺|截止|时限|期限|截至|提交|创建|更新|发起)\S{0,10}?(?:时间|日期|时限|期限)/;
+const DETAIL_SUMMARY_BOOL_QUESTION_PATTERN = /^(是否|是否为|是否包含|有无|是否需要)/;
+const DETAIL_SUMMARY_REGISTER_META_PATTERN = /(备案|环境|版本|基线|编号|序号|编码|流水号|工单|紧急|优先级|级别|程度|渠道|来源|状态)/;
+const DETAIL_SUMMARY_WORKFLOW_META_PATTERN = /^(发起|提交|创建|制单|填报).*(人|时间)$|(当前|审批|处理|流转|流程|待办).*(节点|状态)|(停留|超时|到达当前节点).*(时间|时长)|^(节点|状态|审批中|已结束|草稿)$/;
+const SUMMARY_MEANINGLESS_VALUES = new Set(['0', '无', '暂无', '无内容', '-', '--', 'null', 'none', 'undefined', '请填写', '请选择']);
+function normalizeDetailSummaryValue(_name, value) {
+    let text = stripHtml(value);
+    text = text.replace(/https?:\/\/\S+/gi, '').trim();
+    text = text.replace(/\s+/g, ' ').replace(/[：:;；,.，。]/g, '').trim();
+    if (text.length > 180)
+        text = text.slice(0, 180);
+    return text;
+}
+function isMeaninglessSummaryValue(value) {
+    const text = (value || '').trim();
+    if (!text)
+        return true;
+    if (SUMMARY_MEANINGLESS_VALUES.has(text.toLowerCase()))
+        return true;
+    try {
+        return parseFloat(text) === 0.0;
+    }
+    catch {
+        return false;
+    }
+}
+function looksLikeUrlOrDoc(value) {
+    const text = stripHtml(value);
+    if (!text)
+        return false;
+    if (/^https?:\/\/\S+$/i.test(text))
+        return true;
+    if (!/https?:\/\/|\/doc\/share\/|\/share\/view\/|fileId=/i.test(text))
+        return false;
+    const stripped = text.replace(/https?:\/\/\S+/gi, '').trim().replace(/[：:;；,.，。"'“” \t\r\n]/g, '');
+    return stripped.length < 20;
+}
+function selectSummaryFields(fields, limit = 12) {
+    const candidates = [];
+    const seen = new Set();
+    const collectField = (field) => {
+        const name = stripHtml(field?.fieldName ?? '');
+        const rawValue = stripHtml(field?.value ?? '');
+        const value = normalizeDetailSummaryValue(name, rawValue);
+        if (!name || !value)
+            return false;
+        if (isMeaninglessSummaryValue(rawValue))
+            return false;
+        if (DETAIL_SUMMARY_EXCLUDED_TITLES.has(name))
+            return false;
+        if (DETAIL_SUMMARY_RELATED_FIELD_PATTERN.test(name))
+            return false;
+        if (DETAIL_SUMMARY_WORKFLOW_META_PATTERN.test(name))
+            return false;
+        if (DETAIL_SUMMARY_PERSON_ROLE_PATTERN.test(name))
+            return false;
+        if (DETAIL_SUMMARY_META_TIME_PATTERN.test(name))
+            return false;
+        if (DETAIL_SUMMARY_BOOL_QUESTION_PATTERN.test(name))
+            return false;
+        if (DETAIL_SUMMARY_REGISTER_META_PATTERN.test(name))
+            return false;
+        if (looksLikeUrlOrDoc(rawValue))
+            return false;
+        if (DETAIL_SUMMARY_NOISE_FIELD_PATTERN.test(name))
+            return false;
+        if (DETAIL_SUMMARY_BOOLEAN_FIELD_PATTERN.test(name) && ['是', '否', '有', '无', 'true', 'false', 'True', 'False'].includes(value))
+            return false;
+        const key = `${name}:${value}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        candidates.push({ fieldId: asString(field?.fieldId), fieldName: name, componentKey: asString(field?.componentKey), value });
+        return true;
+    };
+    for (const field of fields) {
+        if (CORE_FIELD_PATTERNS.some((p) => p.test(stripHtml(field?.fieldName ?? '')))) {
+            if (candidates.length >= limit)
+                break;
+            collectField(field);
+        }
+    }
+    for (const field of fields) {
+        if (CORE_FIELD_PATTERNS.some((p) => p.test(stripHtml(field?.fieldName ?? ''))))
+            continue;
+        if (candidates.length >= limit)
+            break;
+        collectField(field);
+    }
+    return candidates;
+}
+function generateBusinessSummary(fields) {
+    if (!fields.length)
+        return '该流程暂无可用表单数据，暂时无法生成摘要';
+    return fields.map((f) => `${f.fieldName}：${f.value}`).join('；');
+}
+// ---------------------------------------------------------------------------
+// workflow.open（来源：cmd_workflow_open / build_workflow_open_url）
+// ---------------------------------------------------------------------------
+const workflowOpen = {
+    name: 'workflow.open',
+    resource: 'workflow',
+    method: 'open',
+    action: 'workflow.open',
+    summary: '按 requestId 或列表序号生成流程详情打开动作（URL + clientAction）',
+    capability: 'view',
+    risk: 'read',
+    inputSchema: schemaOf({
+        requestId: SCHEMA_REQUEST_ID,
+        index: SCHEMA_INDEX,
+        group: { type: 'string' },
+        openMode: { type: 'string', enum: ['auto', 'localBrowser', 'clientAction', 'url'], default: 'auto' },
+        noOpen: { type: 'boolean', default: false },
+    }),
+    handler: async (args, env) => {
+        const requestId = await resolveTargetRequestId(env, args);
+        const session = await env.host.getSession();
+        const baseUrl = (session.baseUrl || '').replace(/\/+$/, '');
+        if (!baseUrl) {
+            throw workflowValidationError('missing_oa_base_url', '打开流程需要 OA 前端地址（session.baseUrl 为空），请先确认 E10 登录域名。');
+        }
+        const url = `${baseUrl}/sp/workflow/flowpage/view/${encodeURIComponent(String(requestId))}`;
+        const openMode = asString(args.openMode) || 'auto';
+        const noOpen = asBool(args.noOpen, false);
+        const requiresHostAction = openMode === 'clientAction' || (openMode === 'auto' && noOpen === false);
+        return workflowSuccess('workflow.open', {
+            success: true,
+            requestId,
+            openMode,
+            url,
+            pathTemplate: '/sp/workflow/flowpage/view/{requestId}',
+            networkRequest: false,
+            requiresHostAction,
+            clientAction: { type: 'openUrl', url },
+            runtimeMode: session.agentType ? 'internal' : 'third_party',
+            baseUrl,
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// workflow.requestLog（来源：cmd_request_log / fetch_request_log_page）
+// ---------------------------------------------------------------------------
+const workflowRequestLog = {
+    name: 'workflow.requestLog',
+    resource: 'workflow',
+    method: 'requestLog',
+    action: 'workflow.requestLog',
+    summary: '按页查询流程签字意见/流转日志',
+    capability: 'view',
+    risk: 'read',
+    inputSchema: schemaOf({
+        requestId: SCHEMA_REQUEST_ID,
+        current: { type: 'integer', minimum: 1, default: 1 },
+        pageSize: { type: 'integer', minimum: 1, maximum: 50, default: 10 },
+    }, { required: ['requestId'] }),
+    handler: async (args, env) => {
+        const requestId = asString(args.requestId);
+        if (!requestId) {
+            throw workflowValidationError('request_id_required', 'workflow.requestLog 必须提供 requestId');
+        }
+        const logPage = await fetchRequestLogPage(env, requestId, asInt(args.current) ?? 1, Math.min(asInt(args.pageSize) ?? 10, 50));
+        return workflowSuccess('workflow.requestLog', {
+            success: true,
+            type: 'workflowRequestLogPage',
+            requestLog: logPage,
+            displayRules: [
+                '签字意见按页展示，不要一次性拉取所有页',
+                '渲染签字意见区标题时写成"签字意见（{{paginationText}}）"',
+                '只有 hasMore=true 时，才在签字意见区内显示 nextPagePrompt',
+            ],
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// workflow.pageOpen（来源：cmd_page_open / COMMON_OA_PAGES）
+// ---------------------------------------------------------------------------
+const COMMON_OA_PAGES = {
+    center: 'workflow/list/center',
+    todo: 'workflow/list/todo',
+    done: 'workflow/list/done',
+    mine: 'workflow/list/mine',
+    share: 'workflow/list/share',
+    attention: 'workflow/list/attention',
+    draft: 'workflow/list/draft',
+    subordinates: 'workflow/list/subordinates',
+    all: 'workflow/list/all',
+    newflow: 'workflow/newflow',
+    monitor: 'workflow/list/monitor',
+};
+// 常用 OA 页面的中文名（来源：Python COMMON_OA_PAGE_LABELS）
+const COMMON_OA_PAGE_LABELS = {
+    center: '流程首页',
+    todo: '待办流程列表',
+    done: '已办流程列表',
+    mine: '我发起的流程列表',
+    share: '共享流程列表',
+    attention: '关注流程列表',
+    draft: '草稿流程列表',
+    subordinates: '下属待办列表',
+    all: '全部流程列表',
+    newflow: '提交申请列表（显示所有可发起流程的页面）',
+    monitor: '流程监控列表',
+};
+const workflowPageOpen = {
+    name: 'workflow.pageOpen',
+    resource: 'workflow',
+    method: 'pageOpen',
+    action: 'workflow.pageOpen',
+    summary: '生成常用 OA 页面（待办/已办/我发起/草稿/监控等）或动态页（create/view）的打开地址',
+    capability: 'page',
+    risk: 'read',
+    inputSchema: schemaOf({
+        page: { type: 'string', description: '页面 key：center/todo/done/mine/share/attention/draft/subordinates/all/newflow/monitor；动态页 create（配合 workflowId）、view（配合 requestId）' },
+        workflowId: { type: 'string', description: '打开发起流程页（page=create）时的工作流 ID' },
+        requestId: { type: 'string', description: '打开流程详情页（page=view）时的流程 requestId' },
+        openMode: { type: 'string', enum: ['auto', 'localBrowser', 'clientAction', 'url'], default: 'auto' },
+        noOpen: { type: 'boolean', default: false },
+    }, { required: ['page'] }),
+    handler: async (args, env) => {
+        const session = await env.host.getSession();
+        const baseUrl = (session.baseUrl || '').replace(/\/+$/, '');
+        if (!baseUrl) {
+            throw workflowValidationError('missing_oa_base_url', '打开 OA 页面需要 OA 前端地址（session.baseUrl 为空），请先确认 E10 登录域名。');
+        }
+        const page = (asString(args.page) || '').toLowerCase();
+        let url;
+        let pageLabel;
+        if (COMMON_OA_PAGES[page]) {
+            url = `${baseUrl}/${COMMON_OA_PAGES[page]}`;
+            pageLabel = COMMON_OA_PAGE_LABELS[page] ?? page;
+        }
+        else if (page === 'create' || page === 'new' || page === '发起流程') {
+            const workflowId = asString(args.workflowId);
+            if (!workflowId) {
+                throw workflowValidationError('workflow_id_required', '打开发起流程页（page=create）必须提供 workflowId');
+            }
+            url = `${baseUrl}/sp/workflow/flowpage/create/${encodeURIComponent(workflowId)}`;
+            pageLabel = '发起流程/新建流程';
+        }
+        else if (page === 'view' || page === 'detail' || page === '详情') {
+            const requestId = asString(args.requestId);
+            if (!requestId) {
+                throw workflowValidationError('request_id_required', '打开流程详情页（page=view）必须提供 requestId');
+            }
+            url = `${baseUrl}/sp/workflow/flowpage/view/${encodeURIComponent(requestId)}`;
+            pageLabel = '流程详情';
+        }
+        else {
+            throw workflowValidationError('page_unknown', `未知的 page：${page}`, { available: Object.keys(COMMON_OA_PAGES).concat(['create', 'view']) });
+        }
+        const openMode = asString(args.openMode) || 'auto';
+        const noOpen = asBool(args.noOpen, false);
+        const requiresHostAction = openMode === 'clientAction' || (openMode === 'auto' && !noOpen);
+        return workflowSuccess('workflow.pageOpen', {
+            success: true,
+            page,
+            pageLabel,
+            url,
+            requiresHostAction,
+            clientAction: { type: 'openUrl', url },
+            baseUrl,
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// workflow.memoryPrompt（来源：cmd_memory_prompt / memory_chat_params）
+// ---------------------------------------------------------------------------
+const workflowMemoryPrompt = {
+    name: 'workflow.memoryPrompt',
+    resource: 'workflow',
+    method: 'memoryPrompt',
+    action: 'workflow.memoryPrompt',
+    summary: '读取用户记忆提示词（工作流消歧、摘要字段优先级、展示偏好等）；顺带返回 OA 版本与当前用户身份（岗位/部门/分部），无需再单独查询',
+    capability: 'memory',
+    risk: 'read',
+    inputSchema: schemaOf({
+        workflowId: { type: 'string', description: '工作流维度记忆的 workflowId（可选）' },
+        memoryAppId: { type: 'string', description: '记忆应用 ID（可选；默认取 E10_MEMORY_APP_ID 或内置默认值）' },
+        dynamicContext: { type: 'object', description: '动态上下文参数（可选，合并进 dynamicContextParams）' },
+    }),
+    handler: async (args, env) => {
+        // 记忆接口契约（来源：Python memory_chat_params）：
+        //   { appid: <记忆应用 ID>, dynamicContextParams: { workflowId?, ...额外上下文 } }
+        // 缺 appid 时接口判为无效应用，直接返回空 promptText（available=false）——
+        // 表现为「记忆永远读不到」，用户的展示偏好/别名/字段偏好全部丢失。
+        const workflowId = asString(args.workflowId);
+        const dynamicContextParams = {};
+        if (args.dynamicContext && typeof args.dynamicContext === 'object') {
+            Object.assign(dynamicContextParams, args.dynamicContext);
+        }
+        if (workflowId)
+            dynamicContextParams.workflowId = workflowId;
+        const payload = {
+            appid: resolveMemoryAppId(asString(args.memoryAppId)),
+            dynamicContextParams,
+        };
+        const response = await env.host.workflowRequest({
+            method: 'POST',
+            path: WORKFLOW_ENDPOINTS.MEMORY_PROMPT,
+            operation: 'workflow.memoryPrompt',
+            body: payload,
+        });
+        // 解包层数（关键）：该接口原始返回是 {code,msg,status,data:"<markdown>",fail}，
+        // 业务成功标志是 status/fail **不是 success**。此处**不能**用 responseData 解包
+        // （会把 data 里的 markdown 当主体，导致 promptText 恒空）。
+        const body = (response && typeof response === 'object' ? response : {});
+        let promptText = '';
+        if (typeof body.data === 'string')
+            promptText = body.data;
+        else if (typeof body.msg === 'string')
+            promptText = body.msg;
+        const businessOk = body.fail !== true && body.status !== false && body.success !== false;
+        const result = {
+            type: 'memoryPrompt',
+            available: Boolean(businessOk && promptText),
+            promptText,
+            workflowId: workflowId || '',
+            memoryAppId: payload.appid,
+            memoryNotSupported: String(body?.stopReason || '') === 'memory_not_supported',
+            displayRules: [
+                '记忆提示词只作为内部上下文使用，不要原文展示给用户',
+                '如果本轮决策使用了历史记忆（工作流消歧/展示偏好/每页条数/关注字段/审批建议），最终回复必须用自然语言简要说明依据了哪类历史偏好或规则',
+                '内部记忆读取失败或 available=false 时，把本次会话当作新用户继续处理，不追问、不重试',
+                '记忆偏好中的「每页条数」用于列表查询的 pageSize；本次用户明确指定的条数优先于记忆偏好',
+                '记忆与当前系统解析结果冲突时以当前系统为准（流程改名/ID 变更不套用过期记忆标签）',
+            ],
+        };
+        if (!result.available)
+            result.diagnosis = { code: body?.code, status: body?.status, fail: body?.fail, dataEmpty: !promptText };
+        // oaContext：OA 版本 + 当前用户身份（岗位/部门/分部）。原 Python 由登录技能 whoami
+        // 提供；CLI 侧等价信息由会话自身承载，无需额外请求。
+        const session = await env.host.getSession();
+        const user = {};
+        const userCandidates = [
+            ['employeeId', session.userId],
+            ['department', session.department],
+            ['subcompany', session.subcompany],
+            ['position', session.position],
+        ];
+        for (const [key, value] of userCandidates) {
+            const text = value === undefined || value === null ? '' : String(value).trim();
+            if (text)
+                user[key] = text;
+        }
+        const oaContext = {};
+        const version = session.version === undefined ? '' : String(session.version).trim();
+        if (version)
+            oaContext.version = version;
+        if (Object.keys(user).length)
+            oaContext.user = user;
+        const hasOaContext = Object.keys(oaContext).length > 0;
+        result.oaContext = hasOaContext ? oaContext : null;
+        result.oaContextMissing = !hasOaContext;
+        if (!hasOaContext) {
+            result.oaContextMissingReason = '当前 E10 会话中未包含 OA 版本与用户身份信息。请先运行 weaver-work-cli auth status 确认登录态；若会话确已失效，请用 weaver-work-cli auth login --base-url <域名> --agent_type <当前智能体名称> 重新登录后重试。';
+        }
+        return workflowSuccess('workflow.memoryPrompt', result, {
+            oaContextMissing: !hasOaContext,
+        });
+    },
+};
+export const workflowReadOperations = [
+    workflowSearch,
+    workflowTodoStat,
+    workflowDetail,
+    workflowSummary,
+    workflowOpen,
+    workflowRequestLog,
+    workflowPageOpen,
+    workflowMemoryPrompt,
+];