weaver-work-cli 0.1.39 → 0.1.42

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

@@ -96,6 +96,47 @@ export function validateRuleFile(raw) {
         errors.push('rules 必须是数组');
         return errors;
     }
+    // generalRules（2026-11-03）：可选区块，只做宽松类型校验；未知键忽略（向后兼容预留扩展）。
+    if (file.generalRules !== undefined) {
+        if (!file.generalRules || typeof file.generalRules !== 'object' || Array.isArray(file.generalRules)) {
+            errors.push('generalRules 必须是对象');
+        }
+        else {
+            const identity = file.generalRules.identityFilter;
+            if (identity !== undefined) {
+                if (!identity || typeof identity !== 'object' || Array.isArray(identity)) {
+                    errors.push('generalRules.identityFilter 必须是对象');
+                }
+                else if (identity.defaultIsremarks !== undefined
+                    && !/^\d+(,\d+)*$/.test(String(identity.defaultIsremarks).trim())) {
+                    errors.push('generalRules.identityFilter.defaultIsremarks 必须是「数字逗号拼接」格式，如 0,1,2');
+                }
+                if (identity?.excludedCodes !== undefined
+                    && (!Array.isArray(identity.excludedCodes)
+                        || identity.excludedCodes.some((c) => !/^\d+$/.test(String(c))))) {
+                    errors.push('generalRules.identityFilter.excludedCodes 必须是数字码数组');
+                }
+            }
+            const priority = file.generalRules.priorityGroup;
+            if (priority !== undefined) {
+                if (!priority || typeof priority !== 'object' || Array.isArray(priority)) {
+                    errors.push('generalRules.priorityGroup 必须是对象');
+                }
+                else {
+                    if (priority.title !== undefined && (typeof priority.title !== 'string' || !priority.title.trim())) {
+                        errors.push('generalRules.priorityGroup.title 必须是非空字符串');
+                    }
+                    if (priority.rules !== undefined) {
+                        const KNOWN_PRIORITY_RULES = ['overdue', 'levelFallback'];
+                        if (!Array.isArray(priority.rules) || priority.rules.length === 0
+                            || priority.rules.some((r) => !KNOWN_PRIORITY_RULES.includes(String(r)))) {
+                            errors.push(`generalRules.priorityGroup.rules 只支持 ${KNOWN_PRIORITY_RULES.join('、')}`);
+                        }
+                    }
+                }
+            }
+        }
+    }
     const defaultsExclude = validateExcludeFields(file.defaults?.excludeOriginFormDataFields, 'defaults.excludeOriginFormDataFields');
     if (defaultsExclude)
         errors.push(defaultsExclude);
@@ -253,7 +294,13 @@ export function loadRules(options = {}) {
         }
     }
     return {
-        file: { schemaVersion: base.file.schemaVersion, defaults: { ...FALLBACK_DEFAULTS, ...base.file.defaults }, rules },
+        file: {
+            schemaVersion: base.file.schemaVersion,
+            defaults: { ...FALLBACK_DEFAULTS, ...base.file.defaults },
+            rules,
+            // 通用规则区（2026-11-03）：仅取 default.json 的定义；用户意图文件不参与通用规则
+            ...(base.file.generalRules ? { generalRules: base.file.generalRules } : {}),
+        },
         warnings,
         dir,
     };
@@ -472,6 +519,10 @@ export function activeRuleFor(workflowName) {
         return null;
     return resolveRule(activeRules(), name)?.rule ?? null;
 }
+/** 通用规则区（2026-11-03）：未配置返回 null，消费方按内置默认兜底。 */
+export function generalRules() {
+    return activeRules().generalRules ?? null;
+}
 /** 清空进程内缓存（单测用）。 */
 export function resetActiveRules() {
     activeFile = null;

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

@@ -89,14 +89,16 @@ export function pickInternalMessageContentField(fields) {
  *
  * `留言内容` 为空 ⇒ 返回空数组：这是「表单没有业务内容」，不是「只有发起人」。
  */
-export function pickInternalMessageFieldPairs(fields, basicInfo = {}) {
+export function pickInternalMessageFieldPairs(fields, basicInfo = {}, 
+/** 兜底发起人（2026-11-03：汇总链路已不再保留 basic，改由列表行的 createrName 传入） */
+fallbackCreatorName) {
     const content = pickInternalMessageContentField(fields);
     const contentValue = String(content?.value ?? '').trim();
     if (!contentValue)
         return [];
     const name = normalizeDetailFieldName(content?.fieldName) || INTERNAL_MESSAGE_CONTENT_LABEL;
     const pairs = [{ fieldName: name, value: contentValue }];
-    const creatorName = String(basicInfo.creatorName ?? '').trim();
+    const creatorName = String(basicInfo.creatorName ?? fallbackCreatorName ?? '').trim();
     if (creatorName)
         pairs.push({ fieldName: INTERNAL_MESSAGE_INITIATOR_LABEL, value: creatorName });
     const createdAt = String(basicInfo.createdAt ?? '').trim();

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

@@ -123,19 +123,24 @@ export function promptTagOf(prompt) {
     return String(prompt ?? '').trim();
 }
 /**
- * 缓存条目是否与当前目标字数 / 口径 / 详情素材匹配。
+ * 缓存条目是否与当前口径/素材匹配。
  *
- *  - 不传 `maxChars` 时不按字数过滤；传入后必须与写入口径一致；
- *  - `pk`（口径特征值）同理：规则改了 `requestSummaryPrompt` ⇒ pk 变化 ⇒ 旧摘要自动失效；
- *  - `dv`（详情素材特征值，2026-11-01 根治）：
- *      条目没有 dv = 旧条目，兼容命中；
- *      条目有 dv 时必须与当前素材特征值一致——当前**没有**详情素材（无法核验）也视为失效
- *      （与「缓存没了就当从未生成过、直接走实时逻辑」的口径一致）。
+ * **失效条件：由 `requestSummaryPrompt`（default.json / 用户意图）调整触发**——
+ *  - `pk`：**严格比对**（2026-11-04 修正）。调用方只要传了 pk，条目缺 pk 或 pk 不等 ⇒ 一律失效重写。
+ *    旧口径（`entry.pk !== undefined` 才比对）等于「改 requestSummaryPrompt 对老条目永远不生效」：
+ *    条目是用旧口径写的，缺 pk 只能说明「口径未知」，不能证明「口径没变」。
+ *    空口径（`pk === ''`）会照常落库，因此「改空 / 改回非空」同样能触发失效，且空口径组不会抖动。
+ *  - `maxChars`：双方都存在时才比对，且调用方只在用户**显式**传字数时才传入
+ *    （`summary.ts` 的 `explicitMaxCharsFor`）——规则/默认字数变化不作废历史摘要；
+ *    用户显式要求「10 字以内」时仍会重写（2026-10-22 实测踩坑的保护保留）；
+ *  - `dv`：详情素材特征值仍比对——素材升级 / 排除清单调整后旧摘要缺信息（如安全工单缺行号），
+ *    不能继续命中；条目缺 dv = 旧条目，兼容命中（素材侧无法核验，属另一条口径，未随本次收紧）。
  */
 function entryMatches(entry, maxChars, pk, dv) {
-    if (maxChars !== undefined && (entry.maxChars ?? 50) !== maxChars)
+    // 调用方不传 pk（undefined）= 不做口径判定（保持对旧调用点的兼容）；传了就必须逐字符相等。
+    if (pk !== undefined && entry.pk !== pk)
         return false;
-    if (pk !== undefined && (entry.pk ?? '') !== pk)
+    if (maxChars !== undefined && entry.maxChars !== undefined && entry.maxChars !== maxChars)
         return false;
     if (entry.dv !== undefined && entry.dv !== dv)
         return false;
@@ -150,7 +155,9 @@ function normalizeSummaryEntry(raw) {
     if (typeof entry.cachedAt !== 'number' || !Number.isFinite(entry.cachedAt))
         return null;
     const maxChars = typeof entry.maxChars === "number" && Number.isFinite(entry.maxChars) ? entry.maxChars : undefined;
-    const pk = typeof entry.pk === 'string' && entry.pk !== '' ? entry.pk : undefined;
+    // 空串是有效口径（该组本来就没配 requestSummaryPrompt）：保留下来，
+    // 否则「空口径条目」会被当成「缺 pk 的旧条目」，收紧后每次都 miss。
+    const pk = typeof entry.pk === 'string' ? entry.pk : undefined;
     const dv = typeof entry.dv === 'string' && entry.dv !== '' ? entry.dv : undefined;
     return {
         summary: entry.summary,
@@ -235,7 +242,8 @@ export async function openSummaryCache(ctx) {
                 summary: text,
                 cachedAt: Date.now(),
                 ...(maxChars === undefined ? {} : { maxChars }),
-                ...(pk === undefined || pk === '' ? {} : { pk }),
+                // 空串同样落库（见 entryMatches 注释）：空口径与「缺 pk」必须能区分开。
+                ...(pk === undefined ? {} : { pk }),
                 ...(dv === undefined || dv === '' ? {} : { dv }),
             });
             dirty = true;

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

@@ -1,4 +1,7 @@
-import { activeRuleFor } from './aigroupRules.js';
+import { activeRuleFor, generalRules } from './aigroupRules.js';
+import { writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { WORKFLOW_ENDPOINTS } from '../../endpoints.js';
 import { saveSearchIndex } from '../../state.js';
 import { buildSearchQuery } from '../read.js';
@@ -19,16 +22,26 @@ export async function collectRawTodos(args, env) {
     // 取数阶段只允许 getTodoListData，getTodo* 分页/统计接口一律拦掉。
     const listEnv = guardListOnlyHost(env);
     const searchArgs = { category };
-    for (const key of ['tabid', 'tabName', 'subCategory', 'workflow', 'creator', 'requestName', 'receiveTime', 'requestLevel']) {
+    for (const key of ['tabid', 'tabName', 'subCategory', 'isremarks', 'workflow', 'creator', 'requestName', 'receiveTime', 'requestLevel']) {
         const value = args[key];
         if (value !== undefined && value !== null && value !== '')
             searchArgs[key] = value;
     }
+    // 通用规则（2026-11-03）：默认排除抄送类身份（generalRules.identityFilter.defaultIsremarks）。
+    // 用户显式传 isremarks 时不覆盖；「包含抄送 / 只要抄送」等诉求由调用方按提示词显式传 --isremarks。
+    // 注意：warnings 在下方声明，默认值注入放到声明之后（见「通用规则默认身份过滤」块）。
     // 显式给 tabid 才走平铺路径（见 DEFAULT_TABID 注释）；用户另有子分类条件时原样尊重。
     const explicitTab = ['tabid', 'tabName', 'subCategory'].some((key) => searchArgs[key] !== undefined && String(searchArgs[key]).trim() !== '');
     if (!explicitTab)
         searchArgs.tabid = DEFAULT_TABID;
     const warnings = [];
+    if (searchArgs.isremarks === undefined) {
+        const defaultIsremarks = generalRules()?.identityFilter?.defaultIsremarks?.trim();
+        if (defaultIsremarks) {
+            searchArgs.isremarks = defaultIsremarks;
+            warnings.push(`已按通用规则默认排除抄送类身份（isremarks=${defaultIsremarks}）；如需包含抄送，请在提示词中说明`);
+        }
+    }
     if (cappedFrom !== undefined) {
         // 超过上限时显式告知，避免调用方误以为已取全量。
         warnings.push(`单次最多只能取 ${MAX_FETCH_LIMIT} 条（${MAX_FETCH_PAGES} 次请求 × ${FETCH_PAGE_SIZE} 条），`
@@ -50,6 +63,19 @@ export async function collectRawTodos(args, env) {
     const listPath = LIST_ENDPOINT_BY_CATEGORY[category] ?? WORKFLOW_ENDPOINTS.TODO_LIST;
     for (let pageNo = 1; pageNo <= plannedPages; pageNo += 1) {
         const { query } = await buildSearchQuery(listEnv, { ...searchArgs, current: pageNo, pageSize }, 'list');
+        // 2026-11-02：isremarks（备注筛选，多个数字英文逗号拼接）只由汇总链路透传，放 params 层。
+        // 注入点故意放在 collect 内部而非共享的 buildSearchQuery，保证 workflow.search 的代码路径零改动。
+        const isremarks = String(searchArgs.isremarks ?? '').trim();
+        if (isremarks !== '') {
+            query.params = { ...(query.params || {}), isremarks };
+        }
+        // 调试留痕（环境变量开启才写）：把最终发往列表接口的 body 原样落盘，便于核对拼接结果。
+        if (process.env.WEAVER_WORK_CLI_DUMP_LIST_BODY) {
+            try {
+                writeFileSync(join(tmpdir(), `weaver-list-body-page${pageNo}.json`), JSON.stringify({ path: listPath, body: query }, null, 2));
+            }
+            catch { /* 留痕失败不影响主流程 */ }
+        }
         const response = await listEnv.host.workflowRequest({
             method: 'POST',
             path: listPath,
@@ -98,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({
@@ -171,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,
@@ -188,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',
@@ -154,6 +155,7 @@ export const ALLOWED_INPUT_KEYS = [
     'tabid',
     'tabName',
     'subCategory',
+    'isremarks',
     'workflow',
     'creator',
     'requestName',

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,