weaver-work-cli 0.1.26 → 0.1.29

package/dist/shortcuts/workflow/operations/todoSmartConvert/todoSmartConvert.summary.js

@@ -0,0 +1,540 @@
+import { workflowValidationError } from '../../errors.js';
+import { asRecord, readBoundedInt } from './todoSmartConvert.core.js';
+import { orderGroupsByIntent, readGroupOrder } from './todoSmartConvert.group.js';
+import { detectBusinessKind, needsRequestSummary, usesTitleSummary } from './businessRules.js';
+import { openSummaryCache } from './summaryCache.js';
+import { loadDetailContextProvider, stampsOfRows } from './todoSmartConvert.detail.js';
+import { requestItemsOf, rowsOfGroup, runSmartGroup, totalTodoCount, } from './todoSmartConvert.smartGroup.js';
+const DEFAULT_MAX_CHARS_PER_BATCH = 24_000;
+const DEFAULT_MAX_ITEMS_PER_BATCH = 100;
+const DEFAULT_REQUEST_SUMMARY_MAX = 50;
+const INTERNAL_MESSAGE_SUMMARY_HINT = '内部留言：只按原文直接概括「谁说了什么」，不要过度解读、不要推测动机或影响，严格按本批 suggestedMaxChars 控制字数';
+/** 兼容两种拼写：新结构用 `smartSummaryTitle`，早前产物里是 `smartSmmaryTitle`（少一个 m）。 */
+export function readSmartSummaryTitle(args, fallback) {
+    const value = args.smartSummaryTitle ?? args.smartSmmaryTitle;
+    return typeof value === 'string' && value.trim() !== '' ? value : fallback;
+}
+/**
+ * 读 `displayItems`，同时兼容旧回灌结构。
+ *
+ * 新结构：`[{type:"request",requestData}|{type:"group",id,title,count,summary,defaultExpanded,requestDatas}]`
+ * 旧结构：优先组 `requestDatas[]`、普通组 `smartGroup[]`（无 `type`、无 `defaultExpanded`）。
+ *
+ * 旧结构只可能出现在回灌数据里。这里统一归一成新结构，
+ * 免得为了几个字段名把已有产物全部作废。`defaultExpanded` 一律**重算**、不信任输入值。
+ */
+export function readDisplayItems(record, index, title, topPriority) {
+    if (Array.isArray(record.displayItems)) {
+        return record.displayItems.map((rawItem, itemIndex) => {
+            const label = `wfIdGroup[${index}]「${title}」.displayItems[${itemIndex}]`;
+            const item = asRecord(rawItem);
+            if (!item) {
+                throw workflowValidationError('wfidgroup_invalid', `${label} 必须是对象`, { retryAllowed: false });
+            }
+            if (item.type === 'request') {
+                const requestData = asRecord(item.requestData);
+                if (!requestData) {
+                    throw workflowValidationError('wfidgroup_invalid', `${label} 是 type:"request"，必须带 requestData 对象（一条待办的完整字段）`, { retryAllowed: false });
+                }
+                return { type: 'request', requestData: requestData };
+            }
+            if (item.type === 'group') {
+                const requestDatas = Array.isArray(item.requestDatas) ? item.requestDatas : null;
+                if (!requestDatas) {
+                    throw workflowValidationError('wfidgroup_invalid', `${label} 是 type:"group"，必须带 requestDatas 数组（折叠的明细）`, { retryAllowed: false });
+                }
+                return {
+                    type: 'group',
+                    id: typeof item.id === 'string' ? item.id : '',
+                    title: typeof item.title === 'string' ? item.title : '',
+                    count: requestDatas.length,
+                    summary: typeof item.summary === 'string' ? item.summary : '',
+                    defaultExpanded: false,
+                    requestDatas,
+                };
+            }
+            throw workflowValidationError('wfidgroup_invalid', `${label}.type 只支持 "request"（单独一条）/ "group"（汇总项），收到 ${JSON.stringify(item.type)}`, { retryAllowed: false });
+        });
+    }
+    // —— 旧结构兜底 ——
+    if (topPriority) {
+        const requestDatas = Array.isArray(record.requestDatas) ? record.requestDatas : null;
+        if (!requestDatas) {
+            throw workflowValidationError('wfidgroup_invalid', `wfIdGroup[${index}]「${title}」是优先组，必须带 displayItems 或旧结构的 requestDatas 数组`, { retryAllowed: false });
+        }
+        return requestItemsOf(requestDatas);
+    }
+    const legacy = Array.isArray(record.smartGroup) ? record.smartGroup : null;
+    if (!legacy) {
+        throw workflowValidationError('wfidgroup_invalid', `wfIdGroup[${index}]「${title}」是普通组，必须带 displayItems 或旧结构的 smartGroup 数组（先跑 stage=smartGroup）`, { retryAllowed: false });
+    }
+    return legacy.map((rawSub, subIndex) => {
+        const requestDatas = Array.isArray(rawSub?.requestDatas) ? rawSub.requestDatas : [];
+        return {
+            type: 'group',
+            id: typeof rawSub?.id === 'string' ? rawSub.id : `${record.id}-${subIndex + 1}`,
+            title: typeof rawSub?.title === 'string' ? rawSub.title : '',
+            count: requestDatas.length,
+            summary: typeof rawSub?.summary === 'string' ? rawSub.summary : '',
+            defaultExpanded: false,
+            requestDatas,
+        };
+    });
+}
+/**
+ * 最终结构的轻量校验：只认上面那两种组形态（优先组 / 普通组），其它一律报错（不静默修正）。
+ * `count` 一律**重算**成 `displayItems` 摊平后的条数——这是唯一计数规则，不采信输入里的 count。
+ */
+export function validateFinalGroups(value) {
+    return value.map((raw, index) => {
+        const record = asRecord(raw);
+        if (!record) {
+            throw workflowValidationError('wfidgroup_invalid', `wfIdGroup[${index}] 必须是对象`, { retryAllowed: false });
+        }
+        const id = typeof record.id === 'string' ? record.id.trim() : '';
+        const title = typeof record.title === 'string' ? record.title : '';
+        if (!id) {
+            throw workflowValidationError('wfidgroup_invalid', `wfIdGroup[${index}].id 必填且必须是字符串（19 位 id 用数字会失真）`, { retryAllowed: false });
+        }
+        const topPriority = record.topPriority === true;
+        const displayItems = readDisplayItems(record, index, title, topPriority);
+        const count = displayItems.reduce((sum, item) => sum + (item.type === 'group' ? item.requestDatas.length : 1), 0);
+        return topPriority
+            ? { id, topPriority: true, title, count, defaultExpanded: true, displayItems }
+            : { id, topPriority: false, title, count, defaultExpanded: false, displayItems };
+    });
+}
+/**
+ * 取最终结构：优先用回灌进来的 `wfIdGroup`（`stage=smartGroup` / `stage=summaryContext` 的产出），
+ * 否则由 `items` 现场重建（有 `aiGroups` 走兼容模式，没有就走确定性模式）。两条路都落到同一种
+ * `FinalWfIdGroup[]`。
+ *
+ * 重建要从详情里读指标（请假天数/金额），所以这里是 `async`——指标由 `runSmartGroup` 内部
+ * 现拉详情得到（详情缓存已删除），本函数不再自己算一份。
+ */
+export async function readFinalGroups(args, env) {
+    if (Array.isArray(args.wfIdGroup)) {
+        // 回灌的结构通常已经是排好序的；这里再套一次 `groupOrder` 只是为了「顺序意图在后续阶段才给出」
+        // 也能生效（重排是幂等的，顺序一致时结果不变）。
+        return orderGroupsByIntent(validateFinalGroups(args.wfIdGroup), readGroupOrder(args)).groups;
+    }
+    if (Array.isArray(args.items)) {
+        const { data } = await runSmartGroup(args, env);
+        return data.wfIdGroup;
+    }
+    throw workflowValidationError('final_groups_required', '缺少最终结构：用 --input-ref 回灌上一步（stage=smartGroup 或 stage=summaryContext）的输出，'
+        + '或传 items 现场重建（传 aiGroups 走 AI 分组，不传按业务类型确定性分组）', { retryAllowed: false });
+}
+export function collectSummaryUnits(groups) {
+    const units = [];
+    for (const group of groups) {
+        if (group.topPriority) {
+            if (!needsRequestSummary(detectBusinessKind(group.title)))
+                continue;
+            units.push({
+                groupId: group.id,
+                groupTitle: group.title,
+                // 优先组没有汇总项，用组自身 id 当键——组摘要那一步同样按这个键取
+                subGroupId: group.id,
+                subGroupTitle: group.title,
+                kind: detectBusinessKind(group.title),
+                rows: rowsOfGroup(group),
+            });
+            continue;
+        }
+        const kind = detectBusinessKind(group.title);
+        if (!needsRequestSummary(kind))
+            continue;
+        for (const item of group.displayItems) {
+            if (item.type === 'group') {
+                units.push({
+                    groupId: group.id,
+                    groupTitle: group.title,
+                    subGroupId: item.id,
+                    subGroupTitle: item.title,
+                    kind,
+                    rows: item.requestDatas,
+                });
+                continue;
+            }
+            // 单独展示的一条：键用 `request-<requestId>`，只参与单条摘要批次，不出组摘要
+            units.push({
+                groupId: group.id,
+                groupTitle: group.title,
+                subGroupId: `request-${item.requestData.requestId}`,
+                subGroupTitle: item.requestData.requestNameTitle ?? '',
+                kind,
+                rows: [item.requestData],
+            });
+        }
+    }
+    return units;
+}
+/**
+ * `stage=summaryContext`：按最终分组打包摘要批次，并按需获取详情。
+ *
+ *  - **详情为空的条目不喂给 AI**：不进批次，CLI 直接把 `requestNameTitle` 复制到它的
+ *    `summary`（单条数据也需要摘要，但没有上下文可概括，标题即摘要）；
+ *  - 某个分组下**详情全空** ⇒ 整组不产生批次，结构上保留父组。
+ *
+ * 输出带着完整的最终结构，因为下一步 `stage=summary`
+ * 既要摘要也要结构，而 `--input-ref` 一次只能回灌一份 data —— 把两者放在同一份里，
+ * 回灌链才只需要一次引用。
+ */
+export async function runSummaryContext(args, env, prefetched) {
+    const groups = await readFinalGroups(args, env);
+    const units = collectSummaryUnits(groups);
+    const skippedSatisfaction = groups
+        .filter((group) => usesTitleSummary(detectBusinessKind(group.title)))
+        .reduce((sum, group) => sum + rowsOfGroup(group).length, 0);
+    // 优先组是叠加视图 ⇒ 同一条待办会在两个位置各出现一次，统计口径必须去重。
+    const requestIds = [...new Set(units.flatMap((unit) => unit.rows.map((row) => row.requestId)))].filter(Boolean);
+    // 单条摘要目标字数：用户给了口径（如「每条 30 字」）就用用户的，没给才用默认 50。
+    const summaryMaxChars = readBoundedInt(args.summaryMaxChars, 'summaryMaxChars', DEFAULT_REQUEST_SUMMARY_MAX, 10, 500);
+    // 摘要缓存命中时直接回填，未命中的条目才进入 AI 批次。
+    //   预填必须在「准备详情」之前做——已有摘要的条目根本不需要详情（详情只为写摘要服务）。
+    const summaryCache = await openSummaryCache(env.ctx);
+    /** 已有摘要（缓存命中 / collect 已回填）而跳过 AI 的条数 */
+    let prefilled = 0;
+    const prefilledIds = new Set();
+    const needsDetail = [];
+    for (const unit of units) {
+        for (const row of unit.rows) {
+            const cached = summaryCache.get(row.requestId, row.lastFeedBackDateTime, summaryMaxChars);
+            if (cached) {
+                row.summary = cached;
+                prefilled += 1;
+                prefilledIds.add(row.requestId);
+                continue;
+            }
+            needsDetail.push(row.requestId);
+        }
+    }
+    // 详情缓存键依赖 lastFeedBackDateTime：从本轮条目里建 stamps，否则缓存永远 miss。
+    const stamps = stampsOfRows(units.flatMap((unit) => unit.rows));
+    const provider = await loadDetailContextProvider(env, [...new Set(needsDetail)], args, prefetched, stamps);
+    const maxChars = readBoundedInt(args.maxCharsPerBatch, 'maxCharsPerBatch', DEFAULT_MAX_CHARS_PER_BATCH, 500, 200_000);
+    const maxItems = readBoundedInt(args.maxItemsPerBatch, 'maxItemsPerBatch', DEFAULT_MAX_ITEMS_PER_BATCH, 1, 500);
+    const batches = [];
+    let contextAvailable = 0;
+    let contextEmpty = 0;
+    let titleCopied = 0;
+    /**
+     * 已经进过 AI 批次的 requestId。
+     *
+     * 优先组是叠加视图 ⇒ 同一条待办会先在优先组出现、再在工作流组出现。同一条只喂一次模型，
+     * 另一份副本由 `stage=summary` 回填时按 requestId 一并写上（`runSummary` 就是按 id 遍历的），
+     * 所以这里跳过不会让任何一份摘要空缺，只是省掉一次重复的上下文。
+     */
+    const claimed = new Set();
+    for (const unit of units) {
+        let bucket = [];
+        let chars = 0;
+        let seq = 0;
+        const flush = () => {
+            if (bucket.length === 0)
+                return;
+            seq += 1;
+            batches.push({
+                batchId: `${unit.subGroupId}#${seq}`,
+                groupId: unit.groupId,
+                groupTitle: unit.groupTitle,
+                subGroupId: unit.subGroupId,
+                subGroupTitle: unit.subGroupTitle,
+                itemCount: bucket.length,
+                charCount: chars,
+                kind: unit.kind,
+                ...(unit.kind === 'internal-message' ? { hint: INTERNAL_MESSAGE_SUMMARY_HINT } : {}),
+                suggestedMaxChars: summaryMaxChars,
+                items: bucket,
+            });
+            bucket = [];
+            chars = 0;
+        };
+        for (const row of unit.rows) {
+            // 摘要缓存已命中（上一步预填）⇒ 不再喂 AI
+            if (prefilledIds.has(row.requestId))
+                continue;
+            const { context, contextAvailable: available } = provider.get(row.requestId);
+            if (!available) {
+                // ★ 详情为空 ⇒ 不喂 AI，summary 直接复制标题（确定性操作，不走模型）。
+                //   这里**不做** claimed 跳过：叠加视图下每个副本各自持有 summary 字段，都得填一次。
+                const firstSeen = !row.requestId || !claimed.has(row.requestId);
+                if (!(row.summary ?? '').trim()) {
+                    row.summary = row.requestNameTitle ?? '';
+                    if (firstSeen)
+                        titleCopied += 1;
+                }
+                // 统计按 requestId 去重，避免同一条在优先组和工作流组里被数两遍
+                if (firstSeen) {
+                    contextEmpty += 1;
+                    if (row.requestId)
+                        claimed.add(row.requestId);
+                }
+                continue;
+            }
+            // 叠加视图：这条已经在别处进过批次，跳过当前副本（摘要回填按 requestId 覆盖两份）
+            if (row.requestId && claimed.has(row.requestId))
+                continue;
+            if (row.requestId)
+                claimed.add(row.requestId);
+            contextAvailable += 1;
+            const item = {
+                requestId: row.requestId,
+                requestNameTitle: row.requestNameTitle,
+                context,
+                contextAvailable: true,
+            };
+            const itemChars = context.length + row.requestNameTitle.length + 40;
+            if (bucket.length > 0 && (bucket.length >= maxItems || chars + itemChars > maxChars))
+                flush();
+            bucket.push(item);
+            chars += itemChars;
+        }
+        flush();
+    }
+    const warnings = [...provider.warnings];
+    if (skippedSatisfaction > 0) {
+        warnings.push(`有 ${skippedSatisfaction} 条满意度类待办不走 AI，summary 将在回填阶段直接使用条目标题`);
+    }
+    if (titleCopied > 0) {
+        warnings.push(`有 ${titleCopied} 条详情数据为空，已不喂给 AI，summary 直接使用标题（requestNameTitle）填充`);
+    }
+    if (prefilled > 0) {
+        warnings.push(`有 ${prefilled} 条已有本地摘要（key=requestId__lastFeedBackDateTime），未再调用 AI；`
+            + `本次需要 AI 写摘要的只剩 ${requestIds.length - prefilled - titleCopied} 条`);
+    }
+    return {
+        data: {
+            smartSummaryTitle: readSmartSummaryTitle(args, `您当前有 ${totalTodoCount(groups)} 条待办，清单如下：`),
+            totalCount: totalTodoCount(groups),
+            wfIdGroup: groups,
+            summaryBatches: batches,
+            summaryStats: {
+                requestTotal: requestIds.length,
+                /** 本次真正发出去的详情请求条数（摘要缓存命中的不发） */
+                detailFetched: provider.stats.fetched + provider.reused,
+                /** 其中由上一阶段（smartGroup）facts 直接复用、未发请求的条数 */
+                detailReused: provider.reused,
+                /** 其中真正走了 HTTP 的条数 */
+                detailNetworkFetched: provider.stats.fetched,
+                contextAvailable,
+                contextEmpty,
+                failed: provider.stats.failed,
+                titleCopied,
+                /** 本地摘要命中、跳过 AI 的条数 */
+                prefilled,
+                /** 单条摘要的目标字数（默认 50，可由 summaryMaxChars 覆盖） */
+                suggestedMaxChars: summaryMaxChars,
+                /** 内部留言类批次：摘要要按「最低推理强度」写 */
+                internalMessageBatches: batches.filter((batch) => batch.kind === 'internal-message').length,
+                skippedSatisfaction,
+                summaryCacheFile: summaryCache.file,
+                batchCount: batches.length,
+                /** 本次详情取数的并发与耗时（现场拉，不再是占位值） */
+                concurrency: provider.stats.concurrency,
+                durationMs: provider.stats.durationMs,
+                maxCharsPerBatch: maxChars,
+                maxItemsPerBatch: maxItems,
+            },
+        },
+        warnings,
+    };
+}
+/** 校验并索引 `aiSummaries`：扁平 `[{ requestId, summary }]`（与 `aiGroups` 同风格）。 */
+export function readAiSummaries(value) {
+    if (!Array.isArray(value)) {
+        throw workflowValidationError('ai_summaries_invalid', 'aiSummaries 必须是数组，每项形如 { requestId, summary }', { retryAllowed: false });
+    }
+    const map = new Map();
+    value.forEach((raw, index) => {
+        const label = `aiSummaries[${index}]`;
+        const record = asRecord(raw);
+        if (!record) {
+            throw workflowValidationError('ai_summaries_invalid', `${label} 必须是对象 { requestId, summary }`, { retryAllowed: false });
+        }
+        const unknownKeys = Object.keys(record).filter((key) => !['requestId', 'summary'].includes(key));
+        if (unknownKeys.length > 0) {
+            throw workflowValidationError('ai_summaries_invalid', `${label} 不接受字段：${unknownKeys.join(', ')}；只支持 requestId / summary`, { retryAllowed: false, details: { unknownKeys } });
+        }
+        const requestId = typeof record.requestId === 'string' ? record.requestId.trim() : '';
+        if (!requestId) {
+            throw workflowValidationError('ai_summaries_invalid', `${label}.requestId 必填且必须是字符串（19 位 id 用数字会失真）`, { retryAllowed: false });
+        }
+        if (typeof record.summary !== 'string') {
+            throw workflowValidationError('ai_summaries_invalid', `${label}.summary 必须是字符串`, { retryAllowed: false });
+        }
+        if (map.has(requestId)) {
+            throw workflowValidationError('ai_summary_duplicate_request', `requestId「${requestId}」在 aiSummaries 里出现了多次，一条数据只能有一个摘要`, { retryAllowed: true, details: { requestId } });
+        }
+        map.set(requestId, record.summary.trim());
+    });
+    return map;
+}
+/**
+ * `stage=summary`：把模型写的摘要填进最终结构中对应待办的 `summary`。
+ *
+ * 输出沿用目标 demo 的唯一业务结构：`smartSummaryTitle + totalCount + wfIdGroup`。
+ * 摘要只写入对应条目的 `summary`；后续组摘要直接消费 `wfIdGroup`，不额外输出重复映射。
+ *
+ * 漏写不报错（记 warning、留空串）——模型漏几条不该让整批 300 条重跑；但 id 不存在、
+ * 重复出现属于「结果与源数据对不上」，硬失败。
+ */
+export async function runSummary(args, env) {
+    const groups = await readFinalGroups(args, env);
+    const summaries = readAiSummaries(args.aiSummaries);
+    // 单条摘要目标字数：与 `runSummaryContext` 保持同一口径（用户给了就用用户的）。
+    const summaryMaxChars = readBoundedInt(args.summaryMaxChars, 'summaryMaxChars', DEFAULT_REQUEST_SUMMARY_MAX, 10, 500);
+    // ★ 本次 AI 写出来的摘要顺手进缓存（key=requestId__lastFeedBackDateTime），
+    //   下次同一条流程的待办再来时可以复用摘要。
+    const summaryCache = await openSummaryCache(env.ctx);
+    let cacheWritten = 0;
+    // 缓存预填（与 `summaryContext` 同口径）：只跑 `summary` 阶段时也能拿到已写好的摘要，
+    // 否则重跑 finish（不带 aiSummaries）会把整份摘要清成空串。
+    // 满意度类不走 AI、也不读缓存：直接用标题当摘要，保证 `summary` 不为空。
+    let titleSummary = 0;
+    for (const group of groups) {
+        if (usesTitleSummary(detectBusinessKind(group.title))) {
+            for (const row of rowsOfGroup(group)) {
+                if ((row.summary ?? '').trim())
+                    continue;
+                row.summary = row.requestNameTitle ?? '';
+                if ((row.summary ?? '').trim())
+                    titleSummary += 1;
+            }
+            continue;
+        }
+        for (const row of rowsOfGroup(group)) {
+            if (!row?.requestId || (row.summary ?? '').trim())
+                continue;
+            const cached = summaryCache.get(row.requestId, row.lastFeedBackDateTime, summaryMaxChars);
+            if (cached) {
+                row.summary = cached;
+            }
+        }
+    }
+    const knownRequestIds = new Set();
+    for (const group of groups) {
+        for (const row of rowsOfGroup(group)) {
+            if (row?.requestId)
+                knownRequestIds.add(row.requestId);
+        }
+    }
+    for (const requestId of summaries.keys()) {
+        if (!knownRequestIds.has(requestId)) {
+            throw workflowValidationError('ai_summary_unknown_request', `aiSummaries 里的 requestId「${requestId}」不在本次最终结构里（可能 id 传错，或摘要是上一轮数据留下的）`, { retryAllowed: true, details: { requestId } });
+        }
+    }
+    const warnings = [];
+    let filled = 0;
+    let empty = 0;
+    let tooLong = 0;
+    /** 详情为空、CLI 已用标题填充并被本次保留的条数 */
+    let titleKept = 0;
+    /** 本地摘要缓存命中（不是标题兜底）并被本次保留下来的条数 */
+    let prefilledKept = 0;
+    /** 统计用：同一条待办在叠加视图里出现两次，计数只算一次 */
+    const countedIds = new Set();
+    const applyAll = (rows) => {
+        for (const row of rows) {
+            const summary = summaries.get(row.requestId) ?? '';
+            const firstTime = !row.requestId || !countedIds.has(row.requestId);
+            if (row.requestId)
+                countedIds.add(row.requestId);
+            if (!summary && (row.summary ?? '').trim() !== '') {
+                // 没有 AI 摘要，但结构里已经有摘要：
+                //  - 详情为空 ⇒ CLI 用标题填的（确定性操作、不覆盖、不计空）；
+                //  - 本地缓存命中 ⇒ 已经是写过的摘要，同样保留。
+                if (firstTime) {
+                    if ((row.summary ?? '').trim() === (row.requestNameTitle ?? '').trim())
+                        titleKept += 1;
+                    else
+                        prefilledKept += 1;
+                }
+                continue;
+            }
+            if (summary) {
+                if (firstTime) {
+                    filled += 1;
+                    if (summary.length > summaryMaxChars)
+                        tooLong += 1;
+                }
+                if (summaryCache.set(row.requestId, row.lastFeedBackDateTime, summary, summaryMaxChars))
+                    cacheWritten += 1;
+            }
+            else if (firstTime) {
+                empty += 1;
+            }
+            // 空串就是空串：不拿标题凑、不编造
+            row.summary = summary;
+        }
+    };
+    for (const group of groups) {
+        if (!needsRequestSummary(detectBusinessKind(group.title)))
+            continue;
+        if (group.topPriority) {
+            applyAll(rowsOfGroup(group));
+            continue;
+        }
+        for (const item of group.displayItems) {
+            if (item.type === 'group') {
+                applyAll(item.requestDatas);
+                continue;
+            }
+            // 单独展示的一条：只回填它自己
+            applyAll([item.requestData]);
+        }
+    }
+    if (empty > 0) {
+        warnings.push(`有 ${empty} 条没有拿到 AI 摘要，summary 保持空串（未用标题兜底、未编造）`);
+    }
+    if (titleKept > 0) {
+        warnings.push(`有 ${titleKept} 条详情为空的条目保留 CLI 填充的标题摘要（不参与 AI 回填）`);
+    }
+    if (tooLong > 0) {
+        warnings.push(`有 ${tooLong} 条摘要超过目标长度 ${summaryMaxChars} 字（可按用户口径调整），已原样保留；`
+            + '如需控制长度请重跑模型侧（CLI 不改写文案）');
+    }
+    if (prefilledKept > 0) {
+        warnings.push(`有 ${prefilledKept} 条沿用本地摘要缓存（未重新生成）`);
+    }
+    const titleSummaryCount = groups
+        .filter((group) => usesTitleSummary(detectBusinessKind(group.title)))
+        .reduce((sum, group) => sum + rowsOfGroup(group).length, 0);
+    if (titleSummaryCount > 0) {
+        warnings.push(`有 ${titleSummaryCount} 条满意度类待办不调用 AI，summary 直接使用条目标题（保证非空）`);
+    }
+    // 缓存写不进去不致命：只是下次还得重新问 AI，不能因此让本轮结果失败。
+    let summaryCacheFile = summaryCache.file;
+    if (cacheWritten > 0) {
+        const written = await summaryCache.save();
+        if (written)
+            summaryCacheFile = written;
+        else
+            warnings.push(`摘要缓存写入失败（${cacheWritten} 条），本次结果不受影响；下次仍会重新生成`);
+    }
+    return {
+        data: {
+            smartSummaryTitle: readSmartSummaryTitle(args, `您当前有 ${totalTodoCount(groups)} 条待办，清单如下：`),
+            totalCount: totalTodoCount(groups),
+            wfIdGroup: groups,
+        },
+        meta: {
+            summarized: filled,
+            empty,
+            /** 单条摘要的目标字数（默认 50，可由 summaryMaxChars 覆盖） */
+            suggestedMaxChars: summaryMaxChars,
+            titleCopied: titleKept,
+            /** 本地摘要缓存命中、未重新生成的条数 */
+            prefilled: prefilledKept,
+            skippedSatisfaction: titleSummaryCount,
+            /** 满意度类用条目标题当摘要、未调用 AI 的条数 */
+            titleSummary,
+            /** 本次新写入缓存的条数 */
+            summaryCacheWritten: cacheWritten,
+            summaryCacheFile,
+        },
+        warnings,
+    };
+}
+// ---------------------------------------------------------------------------

package/dist/shortcuts/workflow/stdout-compact.js

@@ -34,6 +34,13 @@ export const COMPACT_STDOUT_PATHS = {
         'data.systemFields',
         'data.data',
     ],
+    // `createRequestDirect`（2026-10-22 起只取数、不发起）：返回面就是「fields + historyRequestData +
+    // userMemory」，前两个同样是"逐条长、层级深"的数组 —— 压掉缩进省 24%~31%，直接把大量表单从
+    // 触线降到线下。`userMemory` 是单行 Markdown 字符串，本身没有缩进可压，不必登记。
+    'workflow.createRequestDirect': [
+        'data.fields',
+        'data.historyRequestData',
+    ],
 };
 /** 该 operation 的紧凑路径（不声明 = 维持全量缩进）。导出让用例锁住接线。 */
 export function compactStdoutPaths(operation) {

package/docs/SKILL.md

@@ -32,7 +32,7 @@ skills/weaver-e10-<name>/
 ## 已内置业务模块
 
 - `invoice`：E10 业票通发票管理。源码说明先读 `docs/invoice.md`；面向 Agent 时先读 `skills/weaver-e10-yepiaotong/SKILL.md`，再按入口路由读取对应 reference。
-- `fna`：E10 齐业成费控中心（预算查询/费用中心/借款管理/发票核销）。源码说明先读 `docs/fna.md`；面向 Agent 时先读 `skills/weaver-e10-qiyecheng/SKILL.md`，再按入口路由读取对应 reference。写操作（提醒还款/催票）走 prepare/apply 确认链。
+- `fna`：E10 齐业成费控中心（预算查询/费用中心/报销报表 AI 问答/借款管理/发票核销）。源码说明先读 `docs/fna.md`；面向 Agent 时先读 `skills/weaver-e10-qiyecheng/SKILL.md`，再按入口路由读取对应 reference。写操作（提醒还款/催票）走 prepare/apply 确认链。
 - `plan`：E10 计划报告（报告查询/新建/修改/发布/撤回/提交提醒/评论），自动适配标准版与 e10-ebuilder 两套报告接口链路。源码说明先读 `docs/plan.md`；面向 Agent 时先读 `skills/weaver-e10-plan/SKILL.md`，再按入口路由读取对应 reference。写操作走 prepare/apply 确认链。
 - `esb`：E10 ESB 中心自定义触发动作流（入参模板查询 + 触发）。源码说明先读 `docs/esb.md`；面向 Agent 时先读 `skills/weaver-e10-esb/SKILL.md`，再按入口路由读取对应 reference。触发动作流是写操作，走 prepare/apply 确认链。
 - `okr`：E10 OKR 目标管理（目标分页查询/详情、关键成果查询与保存、目标对齐、目标评论、详情页链接），按 `ver_name` 自动适配 e10 标准版与 e10-ebuilder 两套接口链路。源码说明先读 `docs/okr.md`；面向 Agent 时先读 `skills/weaver-e10-okr/SKILL.md`，再按入口路由读取对应 reference。写操作（新建/编辑目标、保存关键成果、添加目标对齐）走 prepare/apply 确认链。

package/docs/_catalog.md

@@ -10,12 +10,13 @@
 | 业票通发票管理、报销填单、智能开票、invoice operation、写操作 prepare/apply | `docs/invoice.md` |
 | E10 会议管理（标准版：查询/冲突/预约/回执/签到）、meeting operation、写操作 prepare/apply | `docs/meeting.md` |
 | 聚才林人事云（人事档案/出勤/薪酬）、ehr operation、写操作 prepare/apply | `docs/ehr.md` |
-| 齐业成费控中心（预算/费用中心/借款管理/发票核销）、fna operation、提醒还款与催票 prepare/apply | `docs/fna.md` |
+| 齐业成费控中心（预算/费用中心/报销报表 AI 问答/借款管理/发票核销）、fna operation、提醒还款与催票 prepare/apply | `docs/fna.md` |
 | 文书定档案管理（全宗/检索/借阅车/借阅单/发起借阅/预归档上传）、wenshuding operation | `docs/wenshuding.md` |
 | 计划报告管理（报告查询/新建/修改/发布/撤回/提交提醒/评论）、plan operation、写操作 prepare/apply | `docs/plan.md` |
 | OKR 目标管理（目标查询/详情、关键成果、目标对齐、评论）、okr operation、标准版与 ebuilder 双链路、写操作 prepare/apply | `docs/okr.md` |
 | eBuilder 表单（菜单定位、List/NList、字段/浏览、OpenAPI 与自定义接口）、ebuilder-form operation、写操作 prepare/apply | `docs/ebuilder-form.md` |
 | E10 ESB 中心自定义触发动作流（入参模板查询 / prepare-apply 触发）、esb operation | `docs/esb.md` |
+| 待办智能汇总（workflow 内独立分支：跨条目取数/分组/摘要/金额合计，与列表查询解耦） | `docs/todo-smart-convert/README.md` |
 | 事井然项目管理（项目/任务/字典/字段解析）、project operation、写操作 prepare/apply | `docs/project.md` |
 | 快速安装 CLI，并使用 CLI/Skill Maker 生成、验证、打包和安装业务模块 Skill | `docs/operation-manual.md` |
 | 把随包 Agent Skill 安装/升级到本机 Agent（Codex/WorkBuddy 目录、从本地仓库发布最新版） | `docs/agent-skill-install.md` |

package/docs/agent-invoice.md

@@ -67,7 +67,7 @@ weaver-work-cli --json invoice run invoice.list --input-json '{"page_size":10,"s
 
 删除、编辑、新增同样必须使用 `prepare -> apply`。出现 `partial/write_uncertain` 时停止，不能自动重试写操作。
 
-处理“把发票填进流程表单”的场景，使用 `invoice.browse-field.data` 生成浏览按钮控件所需 JSON。处理“报销发票/自动填单”时，先读取 `invoice-reim.md`，用报销相关只读 operation 获取事前申请、工作流、表单结构、预填信息和人员上级；Agent 组装报销单结构化 JSON 后，必须通过 `invoice.reim.flow.create.prepare/apply` 或 `invoice.reim.flow.update.prepare/apply` 写入，创建报销单的 `work_flow_id/mainFormId/request_name/main_fields/detail_rows` 等字段在 operation 顶层传入，不包通用 `payload`。处理“开票/存台账”时，先读取 `invoice-issuing.md` 和 `invoice-issuing-field-rules.md`，从用户输入或附件提取购方、税号、明细、税率和金额；资料不足时追问用户补齐，再走 `invoice.issuing.make.prepare/apply`。当前修正资料包没有客户档案查询或红字发票红冲接口，`invoice.customer.*` 和 `invoice.red.*` 不能调用或绕过。
+处理“把发票填进流程表单”的场景，使用 `invoice.browse-field.data` 生成浏览按钮控件所需 JSON。处理“报销发票/自动填单”时，先读取 `invoice-reim.md`，用报销相关只读 operation 获取事前申请、工作流、表单结构、预填信息和人员上级；Agent 组装报销单结构化 JSON 后，必须通过 `invoice.reim.flow.create.prepare/apply` 或 `invoice.reim.flow.update.prepare/apply` 写入，创建报销单的 `work_flow_id/mainFormId/request_name/main_fields/detail_rows` 等字段在 operation 顶层传入，不包通用 `payload`。处理“开票”时默认读取 `invoice-issuing-workflow.md`：用 `invoice.issuing.qys.list` 的 `groups` 按合同号选定一组，确认后调用 `weaver-e10-workflow` 的 `workflow.createForm` / `workflow.createRequest`（`action` 固定 `draft`）发起开票流程草稿。只有用户明确要求“直接开票/不走流程/存待开台账”时，才读取 `invoice-issuing-qys-ledger.md`（台账行）或 `invoice-issuing.md` + `invoice-issuing-field-rules.md`（口述字段），走 `invoice.issuing.make.prepare/apply`。当前修正资料包没有客户档案查询或红字发票红冲接口，`invoice.customer.*` 和 `invoice.red.*` 不能调用或绕过。
 
 ## 暂缓能力
 

package/docs/caizhilian.md

@@ -4,7 +4,7 @@
 
 源码位于 `src/shortcuts/caizhilian`。命令注册、`operation manifest` 和业务执行逻辑分离：`manifest.ts` 汇总对外契约（含 `withheldOperations`），`operations/registry.ts` 由 `operations/specs.ts` 的 60 条操作规格展开成 87 条对外 operation（写操作展开为 `.prepare` / `.apply`），具体执行逻辑在 `src/shortcuts/caizhilian/operations/handlers` 中按业务分组维护（document、folder、collab、search、fileops、system），公共能力在 `operations/api.ts`、`operations/files.ts`、`operations/form.ts`、`operations/shared.ts`。
 
-面向 Agent 的说明位于 `skills/weaver-e10-caizhilian`。入口 `SKILL.md` 只负责共享规则和 reference 路由；具体细节拆在 `skills/weaver-e10-caizhilian/references/`。
+面向 Agent 的说明位于 `skills/weaver-e10-caizhilian`。入口 `SKILL.md` 只负责接入前置和 reference 路由；具体细节拆在 `skills/weaver-e10-caizhilian/references/`。
 
 ## 公共前置
 

package/docs/e10-auth.md

@@ -69,7 +69,7 @@ E10 目标地址按“显式 `--base-url` → 专用 `WEAVER_XIAOE_*` E10 配置
 
 `auth xiaoe` 会先打印不含凭证的 preflight 摘要，给出 `authMode=xiaoe`、`credentialSourceDetected`、`attempted`、各凭据源检测结果和目标 `baseUrl`。进入脚本分支时会打印 `Trying XiaoE token script credential...`；进入内置 Node 会话分支时会打印 `Trying built-in XiaoE client session credential...`。成功结果和后续 `auth status` 会显示 `credentialSourceStep`、`credentialSourceType`、`credentialSourceLabel`。
 
-业务命令不会自动建立 XiaoE 登录态。桌面客户端需要 XiaoE 专属业务行为时，Agent 必须显式传全局参数，例如 `weaver-work-cli --runtime-agent xiaoe workflow ...`；网页端由原有环境变量规则自动识别，不要求补这个参数。`--runtime-agent` 只控制运行时行为，不携带也不选择凭据。WorkBuddy、Codex 及其他智能体使用 `auth login --base-url <url> --agent_type <agent_type>` 的浏览器 OAuth 流程。
+业务命令不会在缺少本地会话时主动建立 XiaoE 登录态，首次使用仍需显式执行 `auth xiaoe`。已有会话被 E10 接口明确拒绝为失效时，公共请求运行时会静默换票并重放原请求一次；不会打印中间登录步骤，不会自动打开浏览器，也不会对流式请求、网络错误、`partial` / `write_uncertain` 做重放。桌面客户端需要 XiaoE 专属业务行为时，Agent 必须显式传全局参数，例如 `weaver-work-cli --runtime-agent xiaoe workflow ...`；网页端由原有环境变量规则自动识别，不要求补这个参数。`--runtime-agent` 只控制运行时行为，不携带也不选择凭据。WorkBuddy、Codex 及其他智能体使用 `auth login --base-url <url> --agent_type <agent_type>` 的浏览器 OAuth 流程。
 
 无法使用浏览器回调时，可以用 `auth set` 直接写入浏览器中复制到的
 `ETEAMSID`。命令会调用 `teamsCheck` 解析当前用户、租户和组织信息，并写入