weaver-work-cli 0.1.38 → 0.1.40

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

@@ -20,7 +20,8 @@
  *
  * 归一再交给 `normalizeDetailResponse`（`read.ts`）→ `formData.fields[]` → 业务裁剪
  * （`detailFieldRules.ts`：丢掉 `主送` 这类分发字段；内部留言类只留 `留言内容/发起人/发起时间`）
- * → `selectSummaryFields`（业务字段筛选，剔除流程名称/发起人/时间/状态/节点等技术字段）。
+ * → aigroup 规则排除清单（`excludeOriginFormDataFields`，fieldName 精确匹配）
+ * → 字段名额（≤200 个）与单值截断（≤500 字，2026-10-30 用户定稿）。
  *
  * ★ `isReadRequest:false` 是硬要求：批量取数**不得**把用户的待办标成已读。`workflow.detail`
  *   传的是 `true`，所以它不能被这里复用。
@@ -33,16 +34,23 @@
  */
 import { WORKFLOW_ENDPOINTS } from '../../endpoints.js';
 import { extractRowMetrics } from './businessRules.js';
-import { dropDistributionDetailFields, isInternalMessageDetail, pickInternalMessageFieldPairs, } from './detailFieldRules.js';
-import { normalizeDetailResponse, selectSummaryFields } from '../read.js';
+import { dropDistributionDetailFields, isInternalMessageDetail, normalizeDetailFieldName, pickInternalMessageFieldPairs, } from './detailFieldRules.js';
+import { excludeFieldsFor, excludeTagOf } from './aigroupRules.js';
+import { normalizeDetailResponse } from '../read.js';
 /** 默认并发上限。 */
 export const DETAIL_BATCH_CONCURRENCY = 10;
 /** 单条详情默认超时。批量取数不是「补卡片」，不套用 5s 的短超时。 */
 export const DETAIL_BATCH_TIMEOUT_MS = 10_000;
 /** 默认重试次数（仅网络/超时；业务错误与登录失效不重试）。 */
 export const DETAIL_BATCH_RETRIES = 1;
-/** 单条最多取多少个业务字段（与 `workflow.summary` 的默认一致）。 */
-export const DETAIL_BATCH_FIELD_LIMIT = 12;
+/**
+ * 详情素材的字段裁剪口径（2026-10-30 用户定稿，取代旧 selectSummaryFields 投影）：
+ *  - 排除清单（aigroup JSON `excludeOriginFormDataFields`）按 fieldName 精确匹配剔除后，
+ *    **最多保留 200 个字段**（取前 200 个）；
+ *  - 单个字段值超过 **500 字只保留前 500 字**。
+ */
+export const DETAIL_MATERIAL_FIELD_LIMIT = 200;
+export const DETAIL_MATERIAL_VALUE_LIMIT = 500;
 /** 常见 HTML 实体 → 字符。`“` 这类 OA 富文本里到处都是，不解码会原样带进摘要。 */
 const HTML_ENTITIES = {
     amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ',
@@ -126,41 +134,43 @@ 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'));
     // ① 分发类字段（`主送` …）**无条件丢弃**：值是几十个部门的收件人清单，对摘要零信息量，
-    //    还会挤占 `summaryFields` 的字段名额。必须在挑选之前丢，名额才不会被它吃掉。
+    //    还会撑大喂给模型的上下文。必须在排除清单之前丢（技术卫生，用户不可在 JSON 里恢复）。
     const usableFields = dropDistributionDetailFields(rawFields);
     // ② 内部留言类：只保留 留言内容 / 发起人 / 发起时间（其余是分发元数据，见 `detailFieldRules.ts`）。
     const internalMessage = isInternalMessageDetail(base.workflowName, usableFields.map((field) => field?.fieldName));
-    // ③ 内部留言类只保留留言内容、发起人、发起时间；字段值只清洗不裁剪。
+    // ③ 字段值只清洗（实体解码 / 富文本残留 / 压缩空白），不在这一步截断。
     const cleanedFields = usableFields.map((field) => ({
         ...field,
         value: cleanFieldText(String(field?.value ?? '')),
     }));
-    const picked = internalMessage
-        ? pickInternalMessageFieldPairs(cleanedFields, { creatorName: base.creatorName, createdAt: base.createdAt })
-        : selectSummaryFields(cleanedFields, options.fieldLimit ?? DETAIL_BATCH_FIELD_LIMIT, undefined, { fullValue: true });
-    const summaryFields = picked
+    // ④ 规则排除清单（aigroup JSON `excludeOriginFormDataFields`）：按 fieldName 精确匹配剔除，
+    //    两侧都过 `normalizeDetailFieldName`，防【】包裹 / 空白等排版差异绕过精确匹配。
+    const excludeFields = excludeFieldsFor(base.workflowName);
+    const excludeSet = new Set(excludeFields.map((name) => normalizeDetailFieldName(name)));
+    const picked = (internalMessage
+        ? pickInternalMessageFieldPairs(cleanedFields, base)
+        : cleanedFields.filter((field) => !excludeSet.has(normalizeDetailFieldName(field?.fieldName))))
+        .slice(0, DETAIL_MATERIAL_FIELD_LIMIT)
         .map((field) => ({
         fieldName: String(field?.fieldName ?? '').trim(),
-        value: String(field?.value ?? ''),
+        value: String(field?.value ?? '').slice(0, DETAIL_MATERIAL_VALUE_LIMIT),
     }))
         .filter((field) => field.fieldName && field.value);
-    // ④ 结构化指标（请假天数 / 假别 / 金额 / 费用类别）：**只从流程详情数据的字段里取**，
+    // ⑤ 结构化指标（请假天数 / 假别 / 金额 / 费用类别）：**只从流程详情数据的字段里取**，
     //    不做标题兜底（2026-10-26 用户口径：详情取不到指标就不进阈值组，标题不能当证据）。
+    //    在排除清单**之前**的可用字段上取——排除只管「喂模型的素材」，不影响阈值判定。
     const metrics = extractRowMetrics(usableFields);
     return {
         requestId,
-        basicInfo: {
-            requestTitle: String(base.requestTitle ?? ''),
-            workflowName: String(base.workflowName ?? ''),
-            creatorName: String(base.creatorName ?? ''),
-            createdAt: String(base.createdAt ?? ''),
-            currentNode: String(base.currentNode ?? ''),
-            requestLevel: String(base.requestLevel ?? ''),
-            flowStatus: String(base.flowStatus ?? ''),
-        },
-        summaryFields,
-        contextAvailable: summaryFields.length > 0,
+        basicInfo,
+        formFields: picked,
+        contextAvailable: picked.length > 0,
+        excludeTag: excludeTagOf(excludeFields),
         metrics,
     };
 }
@@ -230,12 +240,10 @@ export async function fetchRequestDetailsBatch(env, requestIds, options = {}) {
                 failures.push({ requestId, error: reason });
                 details.set(requestId, {
                     requestId,
-                    basicInfo: {
-                        requestTitle: '', workflowName: '', creatorName: '', createdAt: '',
-                        currentNode: '', requestLevel: '', flowStatus: '',
-                    },
-                    summaryFields: [],
+                    basicInfo: {},
+                    formFields: [],
                     contextAvailable: false,
+                    excludeTag: '',
                     metrics: {},
                     error: reason,
                 });

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

@@ -1,10 +1,14 @@
-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';
 import { projectDisplayRows } from './todoListRows.js';
 import { responseData } from '../shared.js';
-import { openSummaryCache, SUMMARY_CACHE_FILE_NAME } from './summaryCache.js';
+import { openSummaryCache, promptTagOf, SUMMARY_CACHE_FILE_NAME } from './summaryCache.js';
+import { openDetailCache, detailMaterialTagOf } from './todoDetailCache.js';
 import { fetchDetailFacts, stampsOfRows } from './todoSmartConvert.detail.js';
 import { GROUP_MIN_ITEMS_FOR_SUBGROUP, isExpiringTodayRow, isOverdueRow, runGroup, } from './todoSmartConvert.group.js';
 import { DEFAULT_TABID, FETCH_PAGE_SIZE, LIST_ENDPOINT_BY_CATEGORY, MAX_FETCH_LIMIT, MAX_FETCH_PAGES, guardListOnlyHost, readBoundedInt, readCategory, readFetchLimit, readPageSize, rowFromAny, } from './todoSmartConvert.core.js';
@@ -18,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} 条），`
@@ -49,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,
@@ -144,11 +171,24 @@ export async function collectRawTodos(args, env) {
         wfIdGroup = (grouped.wfIdGroup ?? []);
         // 摘要缓存 key 为 requestId 与最后反馈时间；反馈变化会自然失效。
         const summaryCache = await openSummaryCache(env.ctx);
-        // 调用方指定摘要字数时不能命中其他字数口径的旧条目。
-        const collectSummaryMaxChars = readBoundedInt(args.summaryMaxChars, "summaryMaxChars", DEFAULT_REQUEST_SUMMARY_MAX, 10, 500);
+        // 字数口径按每条所属工作流的规则算（入参 > 规则 summaryMaxChars > 兜底），
+        // 否则不同口径的旧摘要会被错命中/错判失效。
+        const collectMaxCharsByGroup = new Map();
+        const collectMaxCharsFor = (workflowName) => {
+            const key = workflowName ?? '';
+            const hit = collectMaxCharsByGroup.get(key);
+            if (hit !== undefined)
+                return hit;
+            const value = readBoundedInt(args.summaryMaxChars ?? activeRuleFor(key)?.summaryMaxChars, "summaryMaxChars", DEFAULT_REQUEST_SUMMARY_MAX, 10, 500);
+            collectMaxCharsByGroup.set(key, value);
+            return value;
+        };
         const cachedSummaryIds = new Set();
+        // 摘要条目的素材特征值：详情素材变了 ⇒ 旧摘要失效、重新走 AI（2026-11-01 根治）
+        const detailCacheForTag = await openDetailCache(env.ctx);
         for (const row of items) {
-            const cached = summaryCache.get(row.requestId, row.lastFeedBackDateTime, collectSummaryMaxChars);
+            const detailEntry = detailCacheForTag.get(row.requestId, row.lastFeedBackDateTime);
+            const cached = summaryCache.get(row.requestId, row.lastFeedBackDateTime, collectMaxCharsFor(row.workflowName), promptTagOf(activeRuleFor(row.workflowName ?? '')?.requestSummaryPrompt ?? ''), detailEntry ? detailMaterialTagOf(detailEntry) : undefined);
             if (!cached)
                 continue;
             row.summary = cached;
@@ -237,8 +277,8 @@ export async function collectRawTodos(args, env) {
                 + `（缓存文件：${summaryCache.file ?? SUMMARY_CACHE_FILE_NAME}）`);
         }
         if (!summaryCache.inSkillDir) {
-            warnings.push('没有找到本机 Agent 的 weaver-e10-workflow skill 目录，摘要缓存已退回 CLI 状态目录；'
-                + '如需缓存落在 skill 目录，可用 WEAVER_WORK_CLI_SKILL_DIR 指定');
+            warnings.push('无当前 skill 上下文（WEAVER_WORK_CLI_SKILL_DIR 未设置）：摘要缓存与 aigroup 规则均未读写，'
+                + '本次按「从未生成过」走实时逻辑；请经 skill 的 tools 脚本调用');
         }
     }
     return {

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

@@ -154,6 +154,7 @@ export const ALLOWED_INPUT_KEYS = [
     'tabid',
     'tabName',
     'subCategory',
+    'isremarks',
     'workflow',
     'creator',
     'requestName',

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

@@ -1,13 +1,19 @@
 import { fetchRequestDetailsBatch } from './todoDetailFetcher.js';
 import { readBoundedInt } from './todoSmartConvert.core.js';
-import { openDetailCache } from './todoDetailCache.js';
+import { openDetailCache, DETAIL_CACHE_ENTRY_VERSION } from './todoDetailCache.js';
+import { excludeTagFor } from './aigroupRules.js';
 /**
- * 把详情字段拼成喂模型的文本。
+ * 把「全量 basicInfo + 排除清单过滤后的 formData 字段」拼成喂模型的文本（2026-10-30 用户定稿）。
  *
- * 直接拼装详情取数阶段已经清洗过的字段值。
+ * 每行一条 `fieldName:value`——字段归属一目了然；basicInfo 的键值同样按 `key:value` 逐行放在最前。
+ * 字段来源与截断口径见 `todoDetailFetcher`（排除清单 → ≤200 个字段 → 单值 ≤500 字）。
  */
 export function contextOfDetail(detail) {
-    return detail.summaryFields.map((field) => `${field.fieldName}：${field.value}`).join('；');
+    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');
 }
 const EMPTY_DETAIL_STATS = {
     requested: 0,
@@ -19,9 +25,8 @@ const EMPTY_DETAIL_STATS = {
     concurrency: 0,
     durationMs: 0,
 };
-/** 缓存里存的、也是 `DetailFact` 用的字段裁剪口径：最多 8 个、每个值 80 字。 */
-export const DETAIL_MATERIAL_FIELD_LIMIT = 8;
-export const DETAIL_MATERIAL_VALUE_LIMIT = 80;
+/** 缓存里存的、也是 `DetailFact` 用的字段裁剪口径：排除清单 → ≤200 个字段、单值 ≤500 字（定义在 `todoDetailFetcher.ts`）。 */
+export { DETAIL_MATERIAL_FIELD_LIMIT, DETAIL_MATERIAL_VALUE_LIMIT } from './todoDetailFetcher.js';
 /**
  * 从条目集合里建 `requestId → lastFeedBackDateTime`。
  *
@@ -44,10 +49,7 @@ export function stampsOfRows(rows) {
     return stamps;
 }
 function materialFieldsOf(detail) {
-    return detail.summaryFields
-        .filter((field) => field.value.length <= 200)
-        .slice(0, DETAIL_MATERIAL_FIELD_LIMIT)
-        .map((field) => ({ fieldName: field.fieldName, value: field.value.slice(0, DETAIL_MATERIAL_VALUE_LIMIT) }));
+    return detail.formFields.map((field) => ({ fieldName: field.fieldName, value: field.value }));
 }
 /**
  * 取流程详情数据：**缓存优先**（键 = `requestId__lastFeedBackDateTime`，7 天），
@@ -65,17 +67,18 @@ export async function fetchDetailFacts(env, requestIds, args, stamps) {
     const startedAt = Date.now();
     const cache = await openDetailCache(env.ctx);
     stats.cacheFile = cache.file;
-    // ① 缓存命中：不发请求
+    // ① 缓存命中：不发请求。命中还要核对排除口径：JSON 里的 excludeOriginFormDataFields
+    //    变了 ⇒ excludeTag 对不上 ⇒ 视为 miss，按新口径重拉重写（与摘要缓存的 pk 机制同思路）。
     const missing = [];
     for (const requestId of unique) {
         const hit = cache.get(requestId, stamps?.get(requestId));
-        if (!hit) {
+        if (!hit || hit.excludeTag !== excludeTagFor(hit.basicInfo.workflowName ?? '')) {
             missing.push(requestId);
             continue;
         }
         facts.set(requestId, {
-            context: hit.context,
-            contextAvailable: hit.contextAvailable,
+            context: contextOfDetail({ basicInfo: hit.basicInfo, formFields: hit.fields }),
+            contextAvailable: hit.fields.length > 0,
             metrics: hit.metrics,
             fields: hit.fields,
         });
@@ -94,7 +97,7 @@ export async function fetchDetailFacts(env, requestIds, args, stamps) {
             for (const [requestId, detail] of details) {
                 const fact = {
                     context: contextOfDetail(detail),
-                    contextAvailable: detail.summaryFields.length > 0,
+                    contextAvailable: detail.formFields.length > 0,
                     metrics: detail.metrics ?? {},
                     fields: materialFieldsOf(detail),
                 };
@@ -106,10 +109,11 @@ export async function fetchDetailFacts(env, requestIds, args, stamps) {
                     stats.contextEmpty += 1;
                 // 详情为空也写缓存：否则这类条目每次都要重拉
                 if (cache.set(requestId, stamps?.get(requestId), {
-                    context: fact.context,
-                    contextAvailable: fact.contextAvailable,
+                    v: DETAIL_CACHE_ENTRY_VERSION,
+                    basicInfo: detail.basicInfo,
                     metrics: fact.metrics,
                     fields: fact.fields,
+                    excludeTag: detail.excludeTag,
                 }))
                     written += 1;
             }

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

@@ -1,4 +1,5 @@
 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 级是「重要」。 */
@@ -115,29 +116,32 @@ export function isExpiringTodayRow(row, now = Date.now()) {
     return isExpiringTodayUserOverTime(row.userOverTime, now);
 }
 /**
- * 「建议优先处理的流程」筛选规则：
+ * 「建议优先处理的流程」筛选规则（2026-11-03 起可在 `generalRules.priorityGroup.rules` 配置启用子集）：
  *
- *  1. **超时** 必收（`userOverTime` / `overTime` 判定，与紧急程度无关）；
- *  2. **紧急程度**按 `requestLevel` 取：整批有 `=2`（紧急）就只要 2；没有 2 才退到 `=1`（重要）；
+ *  1. **超时**（`overdue`）必收（`userOverTime` / `overTime` 判定，与紧急程度无关）；
+ *  2. **紧急程度**（`levelFallback`）按 `requestLevel` 取：整批有 `=2`（紧急）就只要 2；没有 2 才退到 `=1`（重要）；
  *     `=0`（正常）**不因等级入选**——降级链到 1 就停，不倒到 0；
  *  3. 整批连 1 级都没有（全 0）时，等级条件不生效，只按超时筛；此时若一条都没超时，
  *     优先组为空（"实在没有紧急的就算了"），不硬凑。
  *
  * 注意这是**筛选**，不是视图叠加：入选条目的 `requestLevel` 只有 2（或 2 缺失时的 1）与超时两类。
+ * `enabledRules` 缺省 = 全部启用（与历史行为一致）；预留 `expiringToday`（今天到期）等后续扩展。
  */
-export function selectPriorityRows(rows) {
+export function selectPriorityRows(rows, enabledRules) {
+    const rules = enabledRules ?? new Set(['overdue', 'levelFallback']);
     let maxLevel = 0;
     for (const row of rows) {
         if (row.requestLevel > maxLevel)
             maxLevel = row.requestLevel;
     }
-    const targetLevel = maxLevel >= 2 ? 2 : maxLevel >= 1 ? 1 : undefined;
+    const targetLevel = rules.has('levelFallback') && maxLevel >= 2 ? 2
+        : rules.has('levelFallback') && maxLevel >= 1 ? 1 : undefined;
     const selected = [];
     let overdueCount = 0;
     let levelCount = 0;
     let bothCount = 0;
     for (const row of rows) {
-        const overdue = isOverdueRow(row);
+        const overdue = rules.has('overdue') && isOverdueRow(row);
         const byLevel = targetLevel !== undefined && row.requestLevel >= targetLevel;
         if (overdue)
             overdueCount += 1;
@@ -324,7 +328,11 @@ export function runGroup(args) {
     const groupBy = readGroupBy(args.groupBy);
     const topN = readTopN(args.topN);
     // 优先组是叠加视图：筛出的条目**不从**工作流分组剔除，两个视图各自完整。
-    const priority = selectPriorityRows(rows);
+    // 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;
     const buckets = new Map();
@@ -360,7 +368,7 @@ export function runGroup(args) {
         ? [{
                 id: PRIORITY_GROUP_ID,
                 topPriority: true,
-                title: PRIORITY_GROUP_TITLE,
+                title: pgTitle,
                 count: priorityRows.length,
                 requestDatas: priorityRows.map((row) => toRequestData(row)),
                 stats: statsOf(priorityRows),
@@ -392,7 +400,7 @@ export function runGroup(args) {
             : priority.targetLevel === 1
                 ? '重要（requestLevel=1；本次无 2 级数据，已按规则降级取 1，0 级不取）'
                 : '无等级（本次整批没有 ≥1 级的条目，只按超时筛）';
-        warnings.push(`「${PRIORITY_GROUP_TITLE}」筛出 ${priorityRows.length} 条：超时 ${priority.overdueCount} 条 / ` +
+        warnings.push(`「${pgTitle}」筛出 ${priorityRows.length} 条：超时 ${priority.overdueCount} 条 / ` +
             `等级命中 ${priority.levelCount} 条（两者都满足 ${priority.bothCount} 条），等级口径=${levelText}；` +
             `这 ${priorityRows.length} 条同时保留在各自工作流分组中（叠加视图：Σcount 会大于 totalCount，` +
             `totalCount 按去重条数计 = ${rows.length}）`);

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

@@ -13,6 +13,23 @@ const INTERNAL_MESSAGE_SUMMARY_HINT = '内部留言：只按原文直接概括
 const GROUP_SUMMARY_TAIL = GROUP_SUMMARY_TAIL_TEXT;
 /** 组级摘要建议长度上限。 */
 const DEFAULT_GROUP_SUMMARY_MAX = 100;
+/**
+ * 组摘要目标字数解析器：**入参 > aigroup 规则（`groupSummaryMaxChars`）> 兜底 100**。
+ *
+ * 规则是主要来源（2026-10-30 用户要求「摘要规则必须从 JSON 取」），入参只在用户当轮明确给了
+ * 口径时覆盖它。按工作流名缓存，避免逐组重复解析规则。
+ */
+function makeGroupMaxCharsResolver(args) {
+    const cache = new Map();
+    return (workflowName) => {
+        const hit = cache.get(workflowName);
+        if (hit !== undefined)
+            return hit;
+        const value = readBoundedInt(args.groupSummaryMaxChars ?? activeRuleFor(workflowName)?.groupSummaryMaxChars, 'groupSummaryMaxChars', DEFAULT_GROUP_SUMMARY_MAX, 20, 1000);
+        cache.set(workflowName, value);
+        return value;
+    };
+}
 /** `¥123` / `￥1,280.50` / `123元` 三种写法；每条只取第一个命中，避免把「14 小时」当金额。 */
 const GROUP_AMOUNT_PATTERNS = [
     /[¥￥]\s*(\d[\d,]*(?:\.\d{1,2})?)/u,
@@ -45,7 +62,7 @@ export function createrPhraseOf(creators) {
  * `smartGroup` 已为确定性路径的二次分组汇总项写入固定 `summary`；AI 路径和内部留言仍可进入
  * `groupSummaryBatches`，由后续阶段补写组摘要。
  */
-export function collectGroupSummaryBatches(groups, isCtxEmpty, maxChars = DEFAULT_GROUP_SUMMARY_MAX) {
+export function collectGroupSummaryBatches(groups, isCtxEmpty, maxCharsFor = () => DEFAULT_GROUP_SUMMARY_MAX) {
     const batches = [];
     for (const group of groups) {
         if (group.topPriority)
@@ -82,6 +99,8 @@ export function collectGroupSummaryBatches(groups, isCtxEmpty, maxChars = DEFAUL
                     amounts.push(amount);
             }
             const amountReliable = items.length >= 2 && amounts.length === items.length;
+            /** 组摘要口径（规则 `groupSummary.prompt`）：`needAI:true` 的组必有，没配则不下发 */
+            const groupPrompt = (activeRuleFor(group.title)?.aiGroup?.groupSummary?.prompt ?? '').trim();
             batches.push({
                 groupId: sub.id,
                 parentGroupId: group.id,
@@ -91,7 +110,8 @@ export function collectGroupSummaryBatches(groups, isCtxEmpty, maxChars = DEFAUL
                 totalCount: allRows.length,
                 kind,
                 ...(kind === 'internal-message' ? { hint: INTERNAL_MESSAGE_SUMMARY_HINT } : {}),
-                suggestedMaxChars: maxChars,
+                ...(groupPrompt ? { prompt: groupPrompt } : {}),
+                suggestedMaxChars: maxCharsFor(group.title),
                 ...(emptySkipped > 0 ? { emptySkipped } : {}),
                 items,
                 stats: {
@@ -174,8 +194,9 @@ export async function runGroupSummaryContext(args, env) {
     const groups = await readFinalGroups(args, env);
     const { isCtxEmpty, warnings: emptyWarnings } = await loadCtxEmptyPredicate(env, groups, args);
     // 组摘要目标字数：用户给了就用用户的，没给才用默认 100。
-    const groupSummaryMaxChars = readBoundedInt(args.groupSummaryMaxChars, 'groupSummaryMaxChars', DEFAULT_GROUP_SUMMARY_MAX, 20, 1000);
-    const batches = collectGroupSummaryBatches(groups, isCtxEmpty, groupSummaryMaxChars);
+    const groupMaxCharsFor = makeGroupMaxCharsResolver(args);
+    const batches = collectGroupSummaryBatches(groups, isCtxEmpty, groupMaxCharsFor);
+    const distinctChars = [...new Set(batches.map((batch) => batch.suggestedMaxChars))].sort((left, right) => left - right);
     const totalCount = totalTodoCount(groups);
     const warnings = [...emptyWarnings];
     const skippedEmpty = batches.reduce((sum, batch) => sum + (batch.emptySkipped ?? 0), 0);
@@ -208,7 +229,7 @@ export async function runGroupSummaryContext(args, env) {
                 /** CLI 固定文案的汇总项个数（不进批次，`smartGroup` 阶段已写好） */
                 deterministicGroups,
                 tail: GROUP_SUMMARY_TAIL,
-                suggestedMaxChars: groupSummaryMaxChars,
+                ...(distinctChars.length === 1 ? { suggestedMaxChars: distinctChars[0] } : { suggestedMaxCharsList: distinctChars }),
             },
         },
         warnings,
@@ -259,8 +280,9 @@ export async function runGroupSummary(args, env) {
     const summaries = readAiGroupSummaries(args.aiGroupSummaries);
     const { isCtxEmpty, warnings: emptyWarnings } = await loadCtxEmptyPredicate(env, groups, args);
     // 组摘要目标字数：与 `runGroupSummaryContext` 保持同一口径（用户给了就用用户的）。
-    const groupSummaryMaxChars = readBoundedInt(args.groupSummaryMaxChars, 'groupSummaryMaxChars', DEFAULT_GROUP_SUMMARY_MAX, 20, 1000);
-    const batches = collectGroupSummaryBatches(groups, isCtxEmpty, groupSummaryMaxChars);
+    const groupMaxCharsFor = makeGroupMaxCharsResolver(args);
+    const batches = collectGroupSummaryBatches(groups, isCtxEmpty, groupMaxCharsFor);
+    const distinctChars = [...new Set(batches.map((batch) => batch.suggestedMaxChars))].sort((left, right) => left - right);
     const knownGroupIds = new Set(batches.map((batch) => batch.groupId));
     for (const groupId of summaries.keys()) {
         if (!knownGroupIds.has(groupId)) {
@@ -282,6 +304,8 @@ export async function runGroupSummary(args, env) {
         if (group.topPriority)
             continue;
         const kind = detectBusinessKind(group.title);
+        /** 本组的组摘要字数口径（入参 > 规则 > 兜底） */
+        const groupMaxChars = groupMaxCharsFor(group.title);
         for (const sub of groupItemsOf(group)) {
             if (isDeterministicGroupKind(kind)) {
                 // ★ 固定文案：`smartGroup` 阶段已写好，这里**不覆盖**。
@@ -294,7 +318,7 @@ export async function runGroupSummary(args, env) {
                     }
                     filled += 1;
                     summarizedGroupCount += 1;
-                    if (summary.length > groupSummaryMaxChars)
+                    if (summary.length > groupMaxChars)
                         tooLong += 1;
                     const batch = batches.find((item) => item.groupId === sub.id);
                     if (batch && batch.stats.createrPhrase && !summary.includes(batch.stats.createrPhrase)) {
@@ -314,7 +338,7 @@ export async function runGroupSummary(args, env) {
             }
             filled += 1;
             summarizedGroupCount += 1;
-            if (summary.length > groupSummaryMaxChars)
+            if (summary.length > groupMaxChars)
                 tooLong += 1;
             const batch = batches.find((item) => item.groupId === sub.id);
             if (batch && batch.stats.createrPhrase && !summary.includes(batch.stats.createrPhrase)) {
@@ -325,7 +349,7 @@ export async function runGroupSummary(args, env) {
     if (empty > 0)
         warnings.push(`有 ${empty} 个汇总项没有拿到组摘要，summary 保持空串（未编造）`);
     if (tooLong > 0) {
-        warnings.push(`有 ${tooLong} 个组摘要超过建议的 ${groupSummaryMaxChars} 字，已原样保留（CLI 不改写文案）`);
+        warnings.push(`有 ${tooLong} 个组摘要超过建议的 ${distinctChars.length > 0 ? distinctChars.join('/') : DEFAULT_GROUP_SUMMARY_MAX} 字，已原样保留（CLI 不改写文案）`);
     }
     if (missingCreater > 0) {
         warnings.push(`有 ${missingCreater} 个组摘要没有包含算好的「由 … 发起」短语（发起人由 CLI 统计，模型不该自己数），`

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

@@ -80,6 +80,7 @@ const inputSchema = schemaOf({
     tabid: { type: 'string' },
     tabName: { type: 'string' },
     subCategory: { type: 'string' },
+    isremarks: { type: 'string', description: '备注筛选（getTodoListData params.isremarks），多个数字用英文逗号拼接，仅作用于本汇总取数' },
     workflow: { type: 'array', items: { type: 'string' } },
     creator: { type: 'string' },
     requestName: { type: 'string' },
@@ -88,8 +89,10 @@ const inputSchema = schemaOf({
     groupFocus: { type: 'string' },
     maxCharsPerBatch: { type: 'integer', minimum: 500, maximum: 200000, default: 24000 },
     maxItemsPerBatch: { type: 'integer', minimum: 1, maximum: 500, default: 100 },
-    summaryMaxChars: { type: 'integer', minimum: 10, maximum: 500, default: 50 },
-    groupSummaryMaxChars: { type: 'integer', minimum: 20, maximum: 1000, default: 100 },
+    // 字数口径不设 schema 默认：默认值来自 aigroup 规则（default.json 的 defaults），
+    // 入参只在用户当轮明确给口径时覆盖规则（2026-10-30 用户要求「摘要规则必须从 JSON 取」）。
+    summaryMaxChars: { type: 'integer', minimum: 10, maximum: 500 },
+    groupSummaryMaxChars: { type: 'integer', minimum: 20, maximum: 1000 },
     detailConcurrency: { type: 'integer', minimum: 1, maximum: 32, default: 10 },
     detailTimeoutMs: { type: 'integer', minimum: 1000, maximum: 60000, default: 10000 },
     skillTiming: { type: 'object' },

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

@@ -4,7 +4,8 @@ import { asRecord, readBoundedInt, } from './todoSmartConvert.core.js';
 import { PRIORITY_GROUP_ID, PRIORITY_GROUP_TITLE, runGroup, GROUP_MIN_ITEMS_FOR_SUBGROUP, } from './todoSmartConvert.group.js';
 import { fetchDetailFacts, stampsOfRows } from './todoSmartConvert.detail.js';
 import { activeRuleFor, evaluateFocusKeywords, primeRules } from './aigroupRules.js';
-import { openSummaryCache } from './summaryCache.js';
+import { openSummaryCache, promptTagOf } from './summaryCache.js';
+import { openDetailCache, detailMaterialTagOf } from './todoDetailCache.js';
 const DEFAULT_REQUEST_SUMMARY_MAX = 50;
 /** 把一批条目包成「单独展示」项（优先组、以及普通组里没同类可合并的条目都用它）。 */
 export function requestItemsOf(rows) {
@@ -176,12 +177,18 @@ export async function runSmartGroup(args, env, options = {}) {
     // withDetailContext=false 时只生成结构、不获取详情（此时没有指标，阈值规则自然不生效）。
     const skipDetail = args.withDetailContext === false;
     const summaryCache = await openSummaryCache(env.ctx);
+    // 摘要条目的素材特征值：详情素材变了 ⇒ 旧摘要视为不存在（该条重新写摘要）
+    const detailCacheForTag = skipDetail ? null : await openDetailCache(env.ctx);
+    const materialTagOfRow = (requestId, stamp) => {
+        const entry = detailCacheForTag?.get(requestId, stamp);
+        return entry ? detailMaterialTagOf(entry) : undefined;
+    };
     const cachedIds = new Set();
     const allRows = [];
     for (const group of groups) {
         for (const row of group.requestDatas ?? []) {
             allRows.push(row);
-            if (summaryCache.get(row.requestId, row.lastFeedBackDateTime, summaryMaxChars))
+            if (summaryCache.get(row.requestId, row.lastFeedBackDateTime, summaryMaxChars, promptTagOf(activeRuleFor(group.title)?.requestSummaryPrompt ?? ''), materialTagOfRow(row.requestId, row.lastFeedBackDateTime)))
                 cachedIds.add(row.requestId);
         }
     }