weaver-work-cli 0.1.40 → 0.1.42

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

@@ -5,7 +5,7 @@ import { cacheRoots, readCacheFile, writeCacheFile, SUMMARY_CACHE_PRUNE_INTERVAL
  * 规则（用户 2026-10-26 定稿；条目格式 2026-10-30 升 v2）：
  *  - 键：`requestId__lastFeedBackDateTime`（与该条待办的业务时间绑定——流程一动就换键）；
  *  - 有效期：7 天，与摘要缓存一致；读的时候逻辑过期，超过清理间隔（3 天）时物理剔除；
- *  - **条目带格式版本 `v`**：v2 起素材 = 排除清单过滤后的 formData + 全量 basicInfo；
+ *  - **条目带格式版本 `v`**：v4（2026-11-03）起素材 = 排除清单过滤后的 formData **+ 仅 workflowName**；
  *    旧格式条目（无 `v`）读取时视为无效，被新条目逐步覆盖；排除清单变化靠 `excludeTag` 失效；
  *  - 详情为空的条目**也写**（`fields: []`），否则这类条目每次都要重拉；
  *  - 缓存文件缺失 ⇒ 视为从未缓存过，正常走接口。
@@ -18,29 +18,28 @@ export const DETAIL_CACHE_TTL_MS = SUMMARY_CACHE_TTL_MS;
 /** 与摘要缓存一致：清理间隔 3 天。 */
 export const DETAIL_CACHE_PRUNE_INTERVAL_MS = SUMMARY_CACHE_PRUNE_INTERVAL_MS;
 /**
- * 缓存条目格式版本。v2（2026-10-30）：
- *  - 素材改为「排除清单过滤后的 formData `fieldName:value` + 全量 basicInfo」，
- *    取代旧版「selectSummaryFields 投影 + 8 字段/80 字截断」；
- *  - 新增 `excludeTag`（排除清单原文拼接）——清单一变旧条目整体失效；
- *  - v1 条目（无 `v` 键）读取时直接视为无效并逐步被覆盖。
+ * 缓存条目格式版本。
+ *  - v2（2026-10-30）：素材 = 排除清单过滤后的 formData + 全量 basicInfo，新增 `excludeTag`；
+ *  - v3（2026-11-01）：basicInfo 剔除 `requestTitle` / `flowName`；
+ *  - **v4（2026-11-03，用户定）**：基础信息**只留 `workflowName`**，其余 basic 字段（creatorName /
+ *    createdAt / currentNode / flowStatus / requestLevel …）既不入缓存也不入素材；
+ *    `dv` 相应改为**只对 fields 哈希**。v3 及更早条目读取时视为无效、自动重拉。
  */
-export const DETAIL_CACHE_ENTRY_VERSION = 3;
+export const DETAIL_CACHE_ENTRY_VERSION = 4;
 export function detailCacheKey(requestId, lastFeedBackDateTime) {
     const stamp = String(lastFeedBackDateTime ?? '').trim();
     return `${requestId}__${stamp}`;
 }
 /**
- * 详情素材特征值（2026-11-01 根治「素材升级后旧摘要继续命中」）：对 `basicInfo + fields`
- * 的稳定序列化做 djb2 哈希。任何素材变化——详情管线升级、`excludeOriginFormDataFields`
- * 调整、字段增减——都会让它改变；摘要缓存条目的 `dv` 与之比对即可自动失效重写。
+ * 详情素材特征值 `dv`（2026-11-01 根治「素材升级后旧摘要继续命中」）：对**清洗后的 fields**
+ * 做稳定序列化 + djb2 哈希。任何素材变化——详情管线升级、`excludeOriginFormDataFields` 调整、
+ * 字段增减——都会让它改变；摘要缓存条目的 `dv` 与之比对即可自动失效重写。
+ * （v4 起 basic 只剩 workflowName 且不进素材，故不再参与哈希。）
  */
 export function detailMaterialTagOf(entry) {
-    const basic = entry.basicInfo ?? {};
-    const basicKeys = Object.keys(basic).sort();
-    const material = JSON.stringify([
-        basicKeys.map((key) => [key, basic[key]]),
-        (entry.fields ?? []).map((field) => [field.fieldName, field.value]),
-    ]);
+    // v4 起 basic 只剩 workflowName 且不进素材 ⇒ dv 只对**清洗后的 fields** 哈希；
+    // workflowName 的变化不影响摘要内容，故不参与（改由 pk 侧的口径与分组处理）。
+    const material = JSON.stringify((entry.fields ?? []).map((field) => [field.fieldName, field.value]));
     let hash = 5381;
     for (let i = 0; i < material.length; i += 1)
         hash = ((hash << 5) + hash + material.charCodeAt(i)) >>> 0;
@@ -57,13 +56,7 @@ function normalizeEntry(raw) {
         return null;
     if (typeof value.excludeTag !== 'string')
         return null;
-    const basicInfo = {};
-    if (value.basicInfo && typeof value.basicInfo === 'object') {
-        for (const [key, item] of Object.entries(value.basicInfo)) {
-            if (typeof item === 'string')
-                basicInfo[key] = item;
-        }
-    }
+    const workflowName = typeof value.workflowName === 'string' ? value.workflowName : '';
     const fields = Array.isArray(value.fields)
         ? value.fields
             .filter((item) => Boolean(item) && typeof item.fieldName === 'string'
@@ -73,7 +66,7 @@ function normalizeEntry(raw) {
     const metrics = value.metrics && typeof value.metrics === 'object' ? value.metrics : {};
     return {
         v: DETAIL_CACHE_ENTRY_VERSION,
-        basicInfo,
+        workflowName,
         fields,
         metrics,
         excludeTag: value.excludeTag,

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

@@ -110,6 +110,12 @@ function isRetryable(error) {
         return true;
     return structured?.retryable === true && structured?.type !== 'authentication';
 }
+/** 列表行上的发起人（**只用于内部留言的「发起人」行**，basic 已丢弃后由它兜底）。 */
+function userIdToCreatorName(options, requestId) {
+    const name = options.rowMeta?.get(requestId)?.createrName;
+    const text = String(name ?? '').trim();
+    return text === '' ? undefined : text;
+}
 /**
  * 单条详情取数。后续切换批量接口时，保持本文件对外的批量结果契约即可。
  */
@@ -134,15 +140,14 @@ async function fetchOneDetail(env, requestId, userId, options) {
     const normalized = normalizeDetailResponse(response);
     const base = (normalized?.basicInfo ?? {});
     const rawFields = Array.isArray(normalized?.formData?.fields) ? normalized.formData.fields : [];
-    // ⓪ basicInfo 里**无条件剔除** requestTitle / flowName（2026-11-01 用户定稿：给 AI 的素材与
-    //    本地缓存都不允许出现这两个字段）——标题在素材里出现会诱导模型"按标题写摘要"、
-    //    甚至产出"标题未体现"这类降级话术；标题本身已由列表行（requestNameTitle）承载，素材里不需要。
-    const basicInfo = Object.fromEntries(Object.entries(base).filter(([key]) => key !== 'requestTitle' && key !== 'flowName'));
+    // ⓪ 基础信息**只留 workflowName**（2026-11-03 用户定）：其余 basic 字段丢弃，不进缓存也不进素材。
+    //    `requestTitle` / `flowName` 这类标题字段自然也在丢弃之列。
+    const workflowName = String(base.workflowName ?? '').trim();
     // ① 分发类字段（`主送` …）**无条件丢弃**：值是几十个部门的收件人清单，对摘要零信息量，
     //    还会撑大喂给模型的上下文。必须在排除清单之前丢（技术卫生，用户不可在 JSON 里恢复）。
     const usableFields = dropDistributionDetailFields(rawFields);
     // ② 内部留言类：只保留 留言内容 / 发起人 / 发起时间（其余是分发元数据，见 `detailFieldRules.ts`）。
-    const internalMessage = isInternalMessageDetail(base.workflowName, usableFields.map((field) => field?.fieldName));
+    const internalMessage = isInternalMessageDetail(workflowName, usableFields.map((field) => field?.fieldName));
     // ③ 字段值只清洗（实体解码 / 富文本残留 / 压缩空白），不在这一步截断。
     const cleanedFields = usableFields.map((field) => ({
         ...field,
@@ -150,10 +155,10 @@ async function fetchOneDetail(env, requestId, userId, options) {
     }));
     // ④ 规则排除清单（aigroup JSON `excludeOriginFormDataFields`）：按 fieldName 精确匹配剔除，
     //    两侧都过 `normalizeDetailFieldName`，防【】包裹 / 空白等排版差异绕过精确匹配。
-    const excludeFields = excludeFieldsFor(base.workflowName);
+    const excludeFields = excludeFieldsFor(workflowName);
     const excludeSet = new Set(excludeFields.map((name) => normalizeDetailFieldName(name)));
     const picked = (internalMessage
-        ? pickInternalMessageFieldPairs(cleanedFields, base)
+        ? pickInternalMessageFieldPairs(cleanedFields, {}, userIdToCreatorName(options, requestId))
         : cleanedFields.filter((field) => !excludeSet.has(normalizeDetailFieldName(field?.fieldName))))
         .slice(0, DETAIL_MATERIAL_FIELD_LIMIT)
         .map((field) => ({
@@ -167,7 +172,7 @@ async function fetchOneDetail(env, requestId, userId, options) {
     const metrics = extractRowMetrics(usableFields);
     return {
         requestId,
-        basicInfo,
+        workflowName,
         formFields: picked,
         contextAvailable: picked.length > 0,
         excludeTag: excludeTagOf(excludeFields),
@@ -240,7 +245,7 @@ export async function fetchRequestDetailsBatch(env, requestIds, options = {}) {
                 failures.push({ requestId, error: reason });
                 details.set(requestId, {
                     requestId,
-                    basicInfo: {},
+                    workflowName: '',
                     formFields: [],
                     contextAvailable: false,
                     excludeTag: '',

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

@@ -124,6 +124,46 @@ export async function collectRawTodos(args, env) {
         if (pageRows.length < pageSize)
             break;
     }
+    // ① 详情回填（2026-11-03 用户定：取完列表**紧接着**拉流程详情）
+    //    目的：`getTodoListData.displayData` 可能没有 `workflowName`，缺了分组会整片落到 UNKNOWN_GROUP；
+    //    这里全量拉一遍详情（缓存优先，热缓存 0 请求），列表缺名时用详情 basic 的 workflowName 回填。
+    //    清洗口径照旧（分发字段 / excludeOriginFormDataFields / 200 字段 / 500 字），
+    //    但 basic 只保留 workflowName，其余字段丢弃（见 todoDetailFetcher + todoDetailCache v4）。
+    const workflowNames = new Map();
+    const createrNames = new Map();
+    for (const row of items) {
+        if (!row.requestId)
+            continue;
+        const name = String(row.workflowName ?? '').trim();
+        if (name)
+            workflowNames.set(row.requestId, name);
+        if (row.createrName)
+            createrNames.set(row.requestId, { createrName: row.createrName });
+    }
+    const detailBackfill = { requested: 0, cacheHit: 0, fetched: 0, failed: 0, nameFilled: 0 };
+    let allFacts = new Map();
+    if (items.length > 0) {
+        const detailIds = [...new Set(items.map((row) => row.requestId).filter(Boolean))];
+        const { facts, stats } = await fetchDetailFacts(env, detailIds, args, stampsOfRows(items), workflowNames, createrNames);
+        allFacts = facts;
+        detailBackfill.requested = stats.requested;
+        detailBackfill.cacheHit = stats.cacheHit;
+        detailBackfill.fetched = stats.fetched;
+        detailBackfill.failed = stats.failed;
+        for (const row of items) {
+            const fact = facts.get(row.requestId);
+            if (!fact)
+                continue;
+            if (!String(row.workflowName ?? '').trim() && fact.workflowName) {
+                row.workflowName = fact.workflowName;
+                workflowNames.set(row.requestId, fact.workflowName);
+                detailBackfill.nameFilled += 1;
+            }
+        }
+        if (detailBackfill.nameFilled > 0) {
+            warnings.push(`有 ${detailBackfill.nameFilled} 条列表数据缺少工作流名称，已用流程详情数据（basic.workflowName）回填`);
+        }
+    }
     // 刷新本地查询快照（本地写文件，不联网）：批量写门禁以「最近一次查询结果」为准，
     // 不写会让 todoSmartConvert 取到的 ID 在 workflow.batch* 那里被判成「不在快照里」。
     await saveSearchIndex({
@@ -197,8 +237,9 @@ export async function collectRawTodos(args, env) {
         // 详情是流水线中间数据，smartGroup / summaryContext 需要时现场拉取（带缓存）。
         // 例外：**有意图时**，ai二次分组要先看到表单字段，这里就把素材准备好（见下）。
         detailStats = {
-            deferred: true,
-            note: '详情不预取：smartGroup / summaryContext 会在需要时现场拉取（详情缓存优先）',
+            deferred: false,
+            note: '详情已在 collect 阶段全量回填（缓存优先）：仅 basic.workflowName 保留，其余 basic 字段与素材无关',
+            detailBackfill,
             summaryCached: cachedSummaryIds.size,
             summaryCacheFile: summaryCache.file,
             summaryCachePruned: summaryCache.pruned,
@@ -214,16 +255,17 @@ export async function collectRawTodos(args, env) {
                 .flatMap((group) => group.requestDatas ?? []);
             const targetIds = [...new Set(targetRows.map((row) => row.requestId).filter(Boolean))];
             if (targetIds.length > 0) {
-                const { facts, stats } = await fetchDetailFacts(env, targetIds, args, stampsOfRows(targetRows));
-                for (const [requestId, fact] of facts) {
-                    if (fact.fields.length > 0)
+                // 复用 ① 已回填的 facts（不再二次取数）
+                for (const requestId of targetIds) {
+                    const fact = allFacts.get(requestId);
+                    if (fact && fact.fields.length > 0)
                         fieldsById.set(requestId, fact.fields);
                 }
                 detailStats.groupingMaterial = {
                     requested: targetIds.length,
-                    cacheHit: stats.cacheHit,
-                    fetched: stats.fetched,
-                    failed: stats.failed,
+                    cacheHit: detailBackfill.cacheHit,
+                    fetched: detailBackfill.fetched,
+                    failed: detailBackfill.failed,
                     withFields: fieldsById.size,
                 };
             }

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

@@ -7,7 +7,7 @@ export const UNKNOWN_DATE = '未知日期';
 export const DEFAULT_TOP_N = 10;
 export const STAGE_VALUES = [
     'auto', 'collect', 'group', 'smartGroup',
-    'summaryContext', 'summary', 'groupSummaryContext', 'groupSummary',
+    'summaryContext', 'summary', 'subGroup', 'groupSummaryContext', 'groupSummary',
     'aggregate',
 ];
 export function asRecord(value) {
@@ -137,6 +137,7 @@ export const ALLOWED_INPUT_KEYS = [
     'aiGroupSummaries',
     'withDetailContext',
     'withGroupSummaryContext',
+    'withSubGroup',
     'detailPrefetch',
     'maxCharsPerBatch',
     'maxItemsPerBatch',

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

@@ -3,17 +3,16 @@ import { readBoundedInt } from './todoSmartConvert.core.js';
 import { openDetailCache, DETAIL_CACHE_ENTRY_VERSION } from './todoDetailCache.js';
 import { excludeTagFor } from './aigroupRules.js';
 /**
- * 把「全量 basicInfo + 排除清单过滤后的 formData 字段」拼成喂模型的文本（2026-10-30 用户定稿）。
+ * 把「排除清单过滤后的 formData 字段」拼成喂模型的文本。
  *
- * 每行一条 `fieldName:value`——字段归属一目了然；basicInfo 的键值同样按 `key:value` 逐行放在最前。
+ * 每行一条 `fieldName:value`；2026-11-03 起基础信息（basic）整体丢弃、只有 `workflowName` 保留在
+ * `DetailFact` 上用于分组回填，**不进素材**。
  * 字段来源与截断口径见 `todoDetailFetcher`（排除清单 → ≤200 个字段 → 单值 ≤500 字）。
  */
 export function contextOfDetail(detail) {
-    const basicLines = Object.entries(detail.basicInfo ?? {})
-        .filter(([, value]) => String(value ?? '').trim() !== '')
-        .map(([key, value]) => `${key}:${String(value).trim()}`);
-    const fieldLines = (detail.formFields ?? []).map((field) => `${field.fieldName}:${field.value}`);
-    return [...basicLines, ...fieldLines].join('\n');
+    // 2026-11-03 用户定：流程详情接口返回的 basic 基础信息直接丢弃（只留 workflowName 用于分组回填，
+    // 且不进素材）。因此素材就是清洗后的表单字段，逐行 `fieldName:value`。
+    return (detail.formFields ?? []).map((field) => `${field.fieldName}:${field.value}`).join('\n');
 }
 const EMPTY_DETAIL_STATS = {
     requested: 0,
@@ -57,7 +56,11 @@ function materialFieldsOf(detail) {
  *
  * 失败不致命：返回已拿到的部分 + warning，调用方按「无详情」降级。
  */
-export async function fetchDetailFacts(env, requestIds, args, stamps) {
+export async function fetchDetailFacts(env, requestIds, args, stamps, 
+/** 列表行的 `requestId → workflowName`（详情回填与 excludeTag 校验用） */
+names, 
+/** 列表行的 `requestId → createrName`（内部留言「发起人」行兜底） */
+createrNames) {
     const unique = [...new Set(requestIds.filter(Boolean))];
     const facts = new Map();
     const warnings = [];
@@ -72,15 +75,16 @@ export async function fetchDetailFacts(env, requestIds, args, stamps) {
     const missing = [];
     for (const requestId of unique) {
         const hit = cache.get(requestId, stamps?.get(requestId));
-        if (!hit || hit.excludeTag !== excludeTagFor(hit.basicInfo.workflowName ?? '')) {
+        if (!hit || hit.excludeTag !== excludeTagFor(hit.workflowName ?? names?.get(requestId) ?? '')) {
             missing.push(requestId);
             continue;
         }
         facts.set(requestId, {
-            context: contextOfDetail({ basicInfo: hit.basicInfo, formFields: hit.fields }),
+            context: contextOfDetail({ formFields: hit.fields }),
             contextAvailable: hit.fields.length > 0,
             metrics: hit.metrics,
             fields: hit.fields,
+            workflowName: hit.workflowName || (names?.get(requestId) ?? ''),
         });
         stats.cacheHit += 1;
     }
@@ -91,6 +95,7 @@ export async function fetchDetailFacts(env, requestIds, args, stamps) {
             const { details, stats: fetchStats } = await fetchRequestDetailsBatch(env, missing, {
                 concurrency: readBoundedInt(args.detailConcurrency, 'detailConcurrency', 10, 1, 32),
                 timeoutMs: readBoundedInt(args.detailTimeoutMs, 'detailTimeoutMs', 10_000, 1_000, 60_000),
+                ...(createrNames ? { rowMeta: createrNames } : {}),
             });
             stats.failed = fetchStats.failed;
             stats.concurrency = fetchStats.concurrency;
@@ -100,6 +105,7 @@ export async function fetchDetailFacts(env, requestIds, args, stamps) {
                     contextAvailable: detail.formFields.length > 0,
                     metrics: detail.metrics ?? {},
                     fields: materialFieldsOf(detail),
+                    workflowName: detail.workflowName || (names?.get(requestId) ?? ''),
                 };
                 facts.set(requestId, fact);
                 stats.fetched += 1;
@@ -110,7 +116,7 @@ export async function fetchDetailFacts(env, requestIds, args, stamps) {
                 // 详情为空也写缓存：否则这类条目每次都要重拉
                 if (cache.set(requestId, stamps?.get(requestId), {
                     v: DETAIL_CACHE_ENTRY_VERSION,
-                    basicInfo: detail.basicInfo,
+                    workflowName: fact.workflowName,
                     metrics: fact.metrics,
                     fields: fact.fields,
                     excludeTag: detail.excludeTag,

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

@@ -1,5 +1,4 @@
 import { workflowValidationError } from '../../errors.js';
-import { generalRules } from './aigroupRules.js';
 import { UNKNOWN_GROUP, groupKeyOf, readGroupBy, readItems, readTopN, assertKnownKeys, } from './todoSmartConvert.core.js';
 import { intentAppliesToKind, } from './businessRules.js';
 /** 紧急程度以 requestLevel=2 或显示文本「紧急」为准；1 级是「重要」。 */
@@ -327,16 +326,11 @@ export function runGroup(args) {
     const { rawCount, rows, duplicateCount, unreadableCount } = readItems(args.items);
     const groupBy = readGroupBy(args.groupBy);
     const topN = readTopN(args.topN);
-    // 优先组是叠加视图：筛出的条目**不从**工作流分组剔除，两个视图各自完整。
-    // 2026-11-03：标题与入选规则可在 default.json 的 generalRules.priorityGroup 配置；缺省 = 内置全量规则。
-    const pgConfig = generalRules()?.priorityGroup ?? null;
-    const pgTitle = pgConfig?.title?.trim() || PRIORITY_GROUP_TITLE;
-    const pgRules = new Set(pgConfig?.rules ?? ['overdue', 'levelFallback']);
-    const priority = selectPriorityRows(rows, pgRules);
-    const priorityRows = sortPriorityRows(priority.rows);
-    const restRows = rows;
+    // 2026-11-03 用户定：分组阶段**不再**产出「建议优先处理的流程」——它是最终结构上的一个置顶
+    // 视图，等摘要全部回填后用 `assemblePriorityGroup()` 按同一条规则从成品数据里筛出来。
+    // 这样前期（摘要单位、闸门、统计）都只需处理一份数据，不必到处特判 topPriority。
     const buckets = new Map();
-    for (const row of restRows) {
+    for (const row of rows) {
         const key = groupKeyOf(row, groupBy);
         let bucket = buckets.get(key);
         if (!bucket) {
@@ -364,20 +358,8 @@ export function runGroup(args) {
         stats: statsOf(bucket.rows),
         ...(bucket.ids.length > 1 ? { workflowIds: bucket.ids } : {}),
     }));
-    const groups = priorityRows.length > 0 && groupBy === 'workflow'
-        ? [{
-                id: PRIORITY_GROUP_ID,
-                topPriority: true,
-                title: pgTitle,
-                count: priorityRows.length,
-                requestDatas: priorityRows.map((row) => toRequestData(row)),
-                stats: statsOf(priorityRows),
-            }, ...workflowGroups]
-        : workflowGroups;
-    const displayedWorkflow = workflowGroups.slice(0, topN);
-    const displayed = priorityRows.length > 0 && groupBy === 'workflow'
-        ? [groups[0], ...displayedWorkflow]
-        : displayedWorkflow;
+    const groups = workflowGroups;
+    const displayed = workflowGroups.slice(0, topN);
     const rest = workflowGroups.slice(topN);
     const restCount = rest.reduce((sum, group) => sum + group.count, 0);
     const overall = statsOf(rows);
@@ -394,20 +376,6 @@ export function runGroup(args) {
             ? `有 ${unknownGroupCount} 条缺少工作流名称，已归入「${UNKNOWN_GROUP}」`
             : `有 ${unknownGroupCount} 条缺少分组字段，已归入「${UNKNOWN_GROUP}」`);
     }
-    if (priorityRows.length > 0 && groupBy === 'workflow') {
-        const levelText = priority.targetLevel === 2
-            ? '紧急（requestLevel=2）'
-            : priority.targetLevel === 1
-                ? '重要（requestLevel=1；本次无 2 级数据，已按规则降级取 1，0 级不取）'
-                : '无等级（本次整批没有 ≥1 级的条目，只按超时筛）';
-        warnings.push(`「${pgTitle}」筛出 ${priorityRows.length} 条：超时 ${priority.overdueCount} 条 / ` +
-            `等级命中 ${priority.levelCount} 条（两者都满足 ${priority.bothCount} 条），等级口径=${levelText}；` +
-            `这 ${priorityRows.length} 条同时保留在各自工作流分组中（叠加视图：Σcount 会大于 totalCount，` +
-            `totalCount 按去重条数计 = ${rows.length}）`);
-    }
-    else if (priorityRows.length === 0 && groupBy === 'workflow') {
-        warnings.push(`本次没有超时条目，也没有 requestLevel≥1 的条目，故不输出「${PRIORITY_GROUP_TITLE}」分组`);
-    }
     if (rest.length > 0) {
         warnings.push(`markdown 只展示前 ${topN} 个工作流分组，其余 ${rest.length} 组共 ${restCount} 条仍在 wfIdGroup 中（未截断）`);
     }
@@ -442,7 +410,7 @@ export function runGroup(args) {
         },
         wfIdGroup: groups,
         /** 第二部分（非优先组）的总条数与组数，前端折叠/分页直接用它，不用自己减 */
-        restTotal: restRows.length,
+        restTotal: rows.length,
         restGroupCount: workflowGroups.length,
         restGroups: rest.length > 0 ? { groupCount: rest.length, count: restCount } : null,
         warnings,

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

@@ -69,8 +69,9 @@ export function collectGroupSummaryBatches(groups, isCtxEmpty, maxCharsFor = ()
             continue;
         const kind = detectBusinessKind(group.title);
         for (const sub of groupItemsOf(group)) {
-            // CLI 已经写好固定文案 ⇒ 不需要模型再写一遍
-            if (isDeterministicGroupKind(kind) && (sub.summary ?? '').trim() !== '')
+            // 已有摘要就不产批次：①CLI 固定文案（needAI:false）；②模型随 aiGroups 一起给的
+            // 子组摘要（2026-11-03 合并交互）——两者都不需要再问一次模型。
+            if ((sub.summary ?? '').trim() !== '')
                 continue;
             const allRows = Array.isArray(sub.requestDatas) ? sub.requestDatas : [];
             const rows = isCtxEmpty ? allRows.filter((row) => !isCtxEmpty(row.requestId)) : allRows;

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

@@ -5,8 +5,9 @@ import { collectRawTodos } from './todoSmartConvert.collect.js';
 import { runSmartConvert } from './todoSmartConvert.aggregate.js';
 import { runGroup } from './todoSmartConvert.group.js';
 import { inferStage, readStage } from './todoSmartConvert.pipeline.js';
-import { runSmartGroup } from './todoSmartConvert.smartGroup.js';
+import { runSmartGroup, assemblePriorityGroup } from './todoSmartConvert.smartGroup.js';
 import { runSummary, runSummaryContext } from './todoSmartConvert.summary.js';
+import { runSubGroup } from './todoSmartConvert.subGroup.js';
 import { runGroupSummary, runGroupSummaryContext } from './todoSmartConvert.groupSummary.js';
 import { schemaOf, } from '../types.js';
 const inputSchema = schemaOf({
@@ -58,6 +59,7 @@ const inputSchema = schemaOf({
         },
     },
     withDetailContext: { type: 'boolean', description: 'smartGroup 是否同进程生成单条摘要上下文。' },
+    withSubGroup: { type: 'boolean', description: 'summary 回填后是否同进程接着做 ai 二次分组（stage=subGroup 等价）。' },
     withGroupSummaryContext: { type: 'boolean', description: 'summary 是否同进程生成组摘要上下文。' },
     detailPrefetch: { type: 'boolean', description: '废弃兼容参数，已忽略；collect 只在给了 groupFocus 且意图适用于本组时按需预取分组字段（走详情缓存）。' },
     groupBy: { type: 'string', enum: [...GROUP_BY_VALUES], default: 'workflow' },
@@ -140,6 +142,19 @@ export const workflowTodoSmartConvertOperations = [{
                 : readStage(args.stage);
             const hasItems = Array.isArray(args.items);
             const resumed = stage === 'collect' && hasItems;
+            /**
+             * 把「建议优先处理的流程」拼到**最终结构**上（2026-11-03 用户定：放到最后生成）。
+             * 只在会产出成品结构的阶段（summary / groupSummary）调用；幂等，重复调用不会叠加。
+             */
+            const withPriorityView = (data, extraWarnings) => {
+                if ((args.groupBy ?? 'workflow') !== 'workflow')
+                    return { data, warnings: extraWarnings };
+                const { groups, warning } = assemblePriorityGroup(data.wfIdGroup ?? []);
+                return {
+                    data: { ...data, wfIdGroup: groups },
+                    warnings: warning ? [...extraWarnings, warning] : extraWarnings,
+                };
+            };
             if ((stage === 'group' || stage === 'smartGroup' || stage === 'aggregate') && !hasItems) {
                 throw workflowValidationError('items_required', 'stage=' + stage + ' 需要 items：先执行 stage=collect，再回灌 data.items', { retryAllowed: false });
             }
@@ -167,28 +182,48 @@ export const workflowTodoSmartConvertOperations = [{
                     throw workflowValidationError('ai_summaries_required', 'stage=summary 需要 aiSummaries：先执行 stage=summaryContext', { retryAllowed: false });
                 }
                 const result = await runSummary(args, env);
+                // 2026-11-03 用户定：**ai 二次分组后移到单条摘要之后**（两者不再耦合）。
+                // `withSubGroup` 时在同一次进程内接着做二次分组，省掉一轮 CLI 启动（≈6~7s）。
+                // 顺序：summary(回填单条摘要) → subGroup(切子组) → priority 装配 → 组摘要批次。
+                let baseData = result.data;
+                let baseWarnings = result.warnings;
+                let subGrouped = false;
+                if (args.withSubGroup === true) {
+                    const sub = await runSubGroup({ ...args, wfIdGroup: baseData.wfIdGroup }, env);
+                    baseData = { ...baseData, wfIdGroup: sub.data.wfIdGroup };
+                    baseWarnings = [...baseWarnings, ...sub.warnings];
+                    subGrouped = true;
+                }
+                const final = withPriorityView(baseData, baseWarnings);
                 if (args.withGroupSummaryContext === true) {
                     const context = await runGroupSummaryContext({
-                        wfIdGroup: result.data.wfIdGroup,
-                        smartSummaryTitle: result.data.smartSummaryTitle,
-                        totalCount: result.data.totalCount,
+                        wfIdGroup: final.data.wfIdGroup,
+                        smartSummaryTitle: final.data.smartSummaryTitle,
+                        totalCount: final.data.totalCount,
                     }, env);
                     if (Array.isArray(context.data.groupSummaryBatches) && context.data.groupSummaryBatches.length === 0) {
-                        return finish(env, args, startedAt, stage, result.data, {
-                            branch: 'todo-smart-convert', stage, aiSummarized: true, withGroupSummaryContext: true, ...result.meta,
-                        }, result.warnings);
+                        return finish(env, args, startedAt, stage, final.data, {
+                            branch: 'todo-smart-convert', stage, aiSummarized: true, subGrouped, withGroupSummaryContext: true, ...result.meta,
+                        }, final.warnings);
                     }
                     return finish(env, args, startedAt, stage, {
-                        ...result.data,
+                        ...final.data,
                         groupSummaryBatches: context.data.groupSummaryBatches,
                         groupSummaryStats: context.data.groupSummaryStats,
                     }, {
-                        branch: 'todo-smart-convert', stage, aiSummarized: true, withGroupSummaryContext: true, ...result.meta,
-                    }, [...result.warnings, ...context.warnings]);
+                        branch: 'todo-smart-convert', stage, aiSummarized: true, subGrouped, withGroupSummaryContext: true, ...result.meta,
+                    }, [...final.warnings, ...context.warnings]);
                 }
-                return finish(env, args, startedAt, stage, result.data, {
-                    branch: 'todo-smart-convert', stage, aiSummarized: true, ...result.meta,
-                }, result.warnings);
+                return finish(env, args, startedAt, stage, final.data, {
+                    branch: 'todo-smart-convert', stage, aiSummarized: true, subGrouped, ...result.meta,
+                }, final.warnings);
+            }
+            if (stage === 'subGroup') {
+                const result = await runSubGroup(args, env);
+                const final = withPriorityView(result.data, result.warnings);
+                return finish(env, args, startedAt, stage, final.data, {
+                    branch: 'todo-smart-convert', stage, aiGrouped: Array.isArray(args.aiGroups), subGrouped: true,
+                }, final.warnings);
             }
             if (stage === 'groupSummaryContext') {
                 const result = await runGroupSummaryContext(args, env);
@@ -201,9 +236,10 @@ export const workflowTodoSmartConvertOperations = [{
                     throw workflowValidationError('ai_group_summaries_required', 'stage=groupSummary 需要 aiGroupSummaries：先执行 stage=groupSummaryContext', { retryAllowed: false });
                 }
                 const result = await runGroupSummary(args, env);
-                return finish(env, args, startedAt, stage, result.data, {
+                const final = withPriorityView(result.data, result.warnings);
+                return finish(env, args, startedAt, stage, final.data, {
                     branch: 'todo-smart-convert', stage, aiSummarized: true, ...result.meta,
-                }, result.warnings);
+                }, final.warnings);
             }
             if (stage === 'group' || resumed) {
                 return finish(env, args, startedAt, 'group', runGroup(args), {

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

@@ -32,7 +32,22 @@ export function inferStage(args) {
         return 'groupSummary';
     if (Array.isArray(args.aiSummaries))
         return 'summary';
-    return hasAnyRequestSummary(args.wfIdGroup) ? 'groupSummaryContext' : 'summaryContext';
+    if (hasAnyRequestSummary(args.wfIdGroup)) {
+        // 2026-11-03：ai 二次分组后移到单条摘要之后。
+        // 单条摘要已填、但结构里还没有汇总项（`type:"group"`）⇒ 下一步是 subGroup；
+        // 已经有汇总项 ⇒ 说明二次分组做过，下一步才是组摘要。
+        return hasAnySubGroup(args.wfIdGroup) ? 'groupSummaryContext' : 'subGroup';
+    }
+    return 'summaryContext';
+}
+/** 结构里是否已经存在汇总项（`displayItems[].type === "group"`）。 */
+export function hasAnySubGroup(groups) {
+    for (const raw of groups) {
+        const items = raw?.displayItems;
+        if (Array.isArray(items) && items.some((item) => item?.type === 'group'))
+            return true;
+    }
+    return false;
 }
 /** 从**未经校验**的分组对象里摊平出条目（推断阶段用，同时兼容新旧两种结构）。 */
 export function rowsOfRawGroup(group) {