weaver-work-cli 0.1.36 → 0.1.39

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

@@ -1,8 +1,6 @@
-import { existsSync, readdirSync, statSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
-import { stateRoot } from '../../../../core/state.js';
 /**
  * `todoSmartConvert` 的**单条摘要缓存**（放在 Agent 真实 skill 目录下）。
  *
@@ -18,21 +16,13 @@ import { stateRoot } from '../../../../core/state.js';
  * 流程有了新反馈（lastFeedBackDateTime 变化）key 就变了，摘要自然失效、重新生成——
  * 用业务时间做版本号，比记录「摘要生成时间」更准。
  *
- * 目录定位顺序：`WEAVER_WORK_CLI_CACHE_DIR`（直接指定缓存目录，测试用）→
- * `WEAVER_WORK_CLI_SKILL_DIR`（直接指定 skill 目录）→ 已知 Agent 的全局 skill 根目录
- * （`~/.workbuddy/skills`、`~/.claude/skills` …）→ 全部不存在时退回 CLI 状态目录（并在 warnings 里说明）。
+ * 目录定位（2026-11-01 用户定稿：**缓存的生成与提取都取自当前 skill 自己的 `cache/`**）：
+ * `WEAVER_WORK_CLI_SKILL_DIR`（tools 脚本把自身所在 skill 目录显式指进来）⇒ 直接用 `<该目录>/cache`；
+ * 未设置（裸 CLI，无当前 skill 上下文）⇒ **拒绝读写缓存**（refused），调用方按「没有缓存」处理。
+ * 用户已不要求多安装发现与排名——各自 agent 独立安装一份 skill，脚本锚定自身目录即可。
  */
-/** 与 `skills/` 下发布的目录名一致。 */
-const SKILL_DIR_NAME = 'weaver-e10-workflow';
 /** skill 内的缓存子目录。 */
 const CACHE_DIR_NAME = 'cache';
-/**
- * 已知 Agent 产物的用户级根目录（按优先级）。
- *
- * 只看 `~/<agent>/skills/<skill>/SKILL.md` 是否存在——存在即认为「这个 Agent 装了这个 skill」。
- * **不看工作区里的 `.workbuddy/skills`**：项目内目录属于「本地项目」，用户明确不让缓存放那儿。
- */
-const AGENT_HOME_DIRS = ['.workbuddy', '.claude', '.codebuddy', '.codex', '.cursor', '.gemini'];
 /** 单条摘要缓存（跨任务，7 天）。 */
 export const SUMMARY_CACHE_FILE_NAME = 'todo-summary-cache.json';
 /**
@@ -42,105 +32,31 @@ export const SUMMARY_CACHE_FILE_NAME = 'todo-summary-cache.json';
  */
 export const SUMMARY_CACHE_VERSION = 2;
 function uniqueDirs(dirs) {
-    return [...new Set(dirs.filter(Boolean))];
-}
-function stateCacheDir(ctx) {
-    return resolve(stateRoot(ctx), CACHE_DIR_NAME);
+    return [...new Set(dirs.filter((dir) => Boolean(dir)))];
 }
 /**
- * 扫已知 Agent 的 skills 根，找「本 skill 的目录」——判据是 `references/todo-smart-convert.md` 存在。
- * 用于 skill 目录被改名（例如本地测试副本）后仍能定位到已攒的摘要缓存。
+ * 解析「当前 skill 目录」：只认 `WEAVER_WORK_CLI_SKILL_DIR`（tools 脚本锚定自身目录）；
+ * 未设置 = 裸 CLI，无当前 skill 上下文。
  */
-function discoverThisSkillDirs(home) {
-    const marker = join('references', 'todo-smart-convert.md');
-    const found = [];
-    for (const agent of AGENT_HOME_DIRS) {
-        const root = join(home, agent, 'skills');
-        const entries = (() => {
-            try {
-                return readdirSync(root, { withFileTypes: true });
-            }
-            catch {
-                return [];
-            }
-        })();
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            const dir = join(root, entry.name);
-            if (existsSync(join(dir, marker)))
-                found.push(dir);
-        }
-    }
-    return found;
-}
-/** 读文件 mtime（毫秒）；读不到（不存在/无权限）返回 0。 */
-function mtimeOf(file) {
-    try {
-        return statSync(file).mtimeMs;
-    }
-    catch {
-        return 0;
-    }
-}
-/**
- * 多个候选 skill 目录同时存在时，优先选择已有缓存且安装完整的目录。
- *
- * 排序键（依次比较，越小越优先）：
- *  1. 目录里**已有摘要缓存** ⇒ 优先（连续性：别把攒好的摘要换到另一份安装上）
- *  2. 有 `references/todo-smart-convert.md` ⇒ 优先（完整安装优于半解压的残目录）
- *  3. `SKILL.md` 的 mtime 更新 ⇒ 优先（刚复制/刚升级的那份大概率就是正在用的）
- *  4. 原始顺序（`WEAVER_WORK_CLI_SKILL_DIR` 指定的永远排最前）
- */
-function rankSkillDirs(dirs) {
-    const scored = dirs.map((dir, index) => ({
-        dir,
-        index,
-        hasCache: existsSync(join(dir, CACHE_DIR_NAME, SUMMARY_CACHE_FILE_NAME)) ? 1 : 0,
-        cacheMtime: mtimeOf(join(dir, CACHE_DIR_NAME, SUMMARY_CACHE_FILE_NAME)),
-        hasMarker: existsSync(join(dir, 'references', 'todo-smart-convert.md')) ? 1 : 0,
-        skillMtime: mtimeOf(join(dir, 'SKILL.md')),
-    }));
-    scored.sort((a, b) => b.hasCache - a.hasCache
-        || b.cacheMtime - a.cacheMtime
-        || b.hasMarker - a.hasMarker
-        || b.skillMtime - a.skillMtime
-        || a.index - b.index);
-    return scored.map((item) => item.dir);
+export function resolveSkillDir() {
+    const explicit = process.env.WEAVER_WORK_CLI_SKILL_DIR?.trim();
+    return explicit ? resolve(explicit) : null;
 }
 /** 定位缓存目录（不创建目录，纯路径计算）。 */
 export function cacheRoots(ctx) {
-    const fallback = stateCacheDir(ctx);
-    const explicitCache = process.env.WEAVER_WORK_CLI_CACHE_DIR?.trim();
-    if (explicitCache) {
-        const dir = resolve(explicitCache);
-        return { preferred: dir, fallback: dir, inSkillDir: false, skillDir: null };
-    }
-    const home = homedir();
-    const explicitSkill = process.env.WEAVER_WORK_CLI_SKILL_DIR?.trim();
-    const candidates = [];
-    if (explicitSkill)
-        candidates.push(resolve(explicitSkill));
-    for (const agent of AGENT_HOME_DIRS) {
-        candidates.push(join(home, agent, 'skills', SKILL_DIR_NAME));
+    void ctx;
+    const skillDir = resolveSkillDir();
+    if (!skillDir) {
+        // 裸 CLI：无当前 skill 上下文 ⇒ 缓存拒绝读写（用户 2026-11-01 定稿：拒绝执行）
+        return { preferred: null, fallback: null, inSkillDir: false, skillDir: null, refused: true };
     }
-    // 目录名可能被改（如本地测试副本 `todoSmartGroupTest`）：再按「本 skill 的特征文件」扫一遍，
-    // 避免改名后缓存落到 CLI 状态目录、把已攒的摘要全丢掉。
-    candidates.push(...discoverThisSkillDirs(home));
-    // 只认「装了本 skill」的目录，再在多份安装之间择优（见 rankSkillDirs）。
-    const installed = uniqueDirs(candidates).filter((dir) => existsSync(join(dir, 'SKILL.md')));
-    const [skillDir] = rankSkillDirs(installed);
-    if (skillDir) {
-        return {
-            preferred: join(skillDir, CACHE_DIR_NAME),
-            fallback,
-            inSkillDir: true,
-            skillDir,
-        };
-    }
-    return { preferred: fallback, fallback, inSkillDir: false, skillDir: null };
+    const cacheDir = join(skillDir, CACHE_DIR_NAME);
+    return { preferred: cacheDir, fallback: cacheDir, inSkillDir: true, skillDir, refused: false };
 }
 export async function readCacheFile(roots, fileName) {
+    // 裸 CLI（无当前 skill 上下文）：拒绝读缓存（用户 2026-11-01 定稿）
+    if (roots.refused || !roots.preferred)
+        return null;
     for (const dir of uniqueDirs([roots.preferred, roots.fallback])) {
         const file = join(dir, fileName);
         if (!existsSync(file))
@@ -161,6 +77,9 @@ export async function readCacheFile(roots, fileName) {
  * 缓存是加速设施，写不进去也绝不能让主流程失败。
  */
 export async function writeCacheFile(roots, fileName, payload) {
+    // 裸 CLI（无当前 skill 上下文）：拒绝写缓存（用户 2026-11-01 定稿）；目录不可写时静默放弃（不另设兜底）
+    if (roots.refused || !roots.preferred)
+        return null;
     for (const dir of uniqueDirs([roots.preferred, roots.fallback])) {
         const file = join(dir, fileName);
         try {
@@ -199,15 +118,28 @@ export function summaryCacheKey(requestId, lastFeedBackDateTime) {
     const stamp = String(lastFeedBackDateTime ?? '').trim();
     return `${requestId}__${stamp}`;
 }
+/** 口径提示的入库形式：trim 后原样存储；空口径返回空串（条目不落 pk 字段）。 */
+export function promptTagOf(prompt) {
+    return String(prompt ?? '').trim();
+}
 /**
- * 缓存条目是否与当前目标字数口径匹配。
+ * 缓存条目是否与当前目标字数 / 口径 / 详情素材匹配。
  *
- * 不传 `maxChars` 时不按字数过滤；传入后必须与写入口径一致。
+ *  - 不传 `maxChars` 时不按字数过滤；传入后必须与写入口径一致；
+ *  - `pk`（口径特征值）同理：规则改了 `requestSummaryPrompt` ⇒ pk 变化 ⇒ 旧摘要自动失效；
+ *  - `dv`（详情素材特征值，2026-11-01 根治）：
+ *      条目没有 dv = 旧条目，兼容命中；
+ *      条目有 dv 时必须与当前素材特征值一致——当前**没有**详情素材（无法核验）也视为失效
+ *      （与「缓存没了就当从未生成过、直接走实时逻辑」的口径一致）。
  */
-function entryMatchesMaxChars(entry, maxChars) {
-    if (maxChars === undefined)
-        return true;
-    return (entry.maxChars ?? 50) === maxChars;
+function entryMatches(entry, maxChars, pk, dv) {
+    if (maxChars !== undefined && (entry.maxChars ?? 50) !== maxChars)
+        return false;
+    if (pk !== undefined && (entry.pk ?? '') !== pk)
+        return false;
+    if (entry.dv !== undefined && entry.dv !== dv)
+        return false;
+    return true;
 }
 function normalizeSummaryEntry(raw) {
     if (!raw || typeof raw !== 'object')
@@ -218,7 +150,15 @@ 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;
-    return { summary: entry.summary, cachedAt: entry.cachedAt, ...(maxChars === undefined ? {} : { maxChars }) };
+    const pk = typeof entry.pk === 'string' && entry.pk !== '' ? entry.pk : undefined;
+    const dv = typeof entry.dv === 'string' && entry.dv !== '' ? entry.dv : undefined;
+    return {
+        summary: entry.summary,
+        cachedAt: entry.cachedAt,
+        ...(maxChars === undefined ? {} : { maxChars }),
+        ...(pk === undefined ? {} : { pk }),
+        ...(dv === undefined ? {} : { dv }),
+    };
 }
 /**
  * 打开摘要缓存（读 + 按需清理）。
@@ -273,21 +213,21 @@ export async function openSummaryCache(ctx) {
         misses: 0,
         pruned,
         dirty: false,
-        get(requestId, lastFeedBackDateTime, maxChars) {
+        get(requestId, lastFeedBackDateTime, maxChars, pk, dv) {
             const key = summaryCacheKey(requestId, lastFeedBackDateTime);
             const entry = entries.get(key);
-            if (entry && now - entry.cachedAt <= SUMMARY_CACHE_TTL_MS && entryMatchesMaxChars(entry, maxChars)) {
+            if (entry && now - entry.cachedAt <= SUMMARY_CACHE_TTL_MS && entryMatches(entry, maxChars, pk, dv)) {
                 cache.hits += 1;
                 return entry.summary;
             }
             cache.misses += 1;
             return null;
         },
-        has(requestId, lastFeedBackDateTime, maxChars) {
+        has(requestId, lastFeedBackDateTime, maxChars, pk, dv) {
             const entry = entries.get(summaryCacheKey(requestId, lastFeedBackDateTime));
-            return entry !== undefined && entryMatchesMaxChars(entry, maxChars);
+            return entry !== undefined && entryMatches(entry, maxChars, pk, dv);
         },
-        set(requestId, lastFeedBackDateTime, summary, maxChars) {
+        set(requestId, lastFeedBackDateTime, summary, maxChars, pk, dv) {
             const text = String(summary ?? '').trim();
             if (!requestId || !text)
                 return false;
@@ -295,6 +235,8 @@ export async function openSummaryCache(ctx) {
                 summary: text,
                 cachedAt: Date.now(),
                 ...(maxChars === undefined ? {} : { maxChars }),
+                ...(pk === undefined || pk === '' ? {} : { pk }),
+                ...(dv === undefined || dv === '' ? {} : { dv }),
             });
             dirty = true;
             cache.dirty = true;

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

@@ -2,11 +2,12 @@ import { cacheRoots, readCacheFile, writeCacheFile, SUMMARY_CACHE_PRUNE_INTERVAL
 /**
  * **流程详情数据缓存**（与摘要缓存并存，互不替代）。
  *
- * 规则（用户 2026-10-26 定稿）：
+ * 规则（用户 2026-10-26 定稿；条目格式 2026-10-30 升 v2）：
  *  - 键：`requestId__lastFeedBackDateTime`（与该条待办的业务时间绑定——流程一动就换键）；
  *  - 有效期：7 天，与摘要缓存一致；读的时候逻辑过期，超过清理间隔（3 天）时物理剔除；
- *  - **不设版本号**：过期条目逐条剔除、新条目直接加入，不做整份失效；
- *  - 详情为空的条目**也写**（`contextAvailable:false`），否则这类条目每次都要重拉；
+ *  - **条目带格式版本 `v`**：v2 起素材 = 排除清单过滤后的 formData + 全量 basicInfo；
+ *    旧格式条目（无 `v`）读取时视为无效，被新条目逐步覆盖；排除清单变化靠 `excludeTag` 失效；
+ *  - 详情为空的条目**也写**（`fields: []`），否则这类条目每次都要重拉；
  *  - 缓存文件缺失 ⇒ 视为从未缓存过，正常走接口。
  *
  * 位置：与摘要缓存同一个 `cache/` 目录（skill 目录优先，不可写时退回 CLI 状态目录）。
@@ -16,18 +17,53 @@ export const DETAIL_CACHE_FILE_NAME = 'todo-detail-cache.json';
 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` 键）读取时直接视为无效并逐步被覆盖。
+ */
+export const DETAIL_CACHE_ENTRY_VERSION = 3;
 export function detailCacheKey(requestId, lastFeedBackDateTime) {
     const stamp = String(lastFeedBackDateTime ?? '').trim();
     return `${requestId}__${stamp}`;
 }
+/**
+ * 详情素材特征值（2026-11-01 根治「素材升级后旧摘要继续命中」）：对 `basicInfo + fields`
+ * 的稳定序列化做 djb2 哈希。任何素材变化——详情管线升级、`excludeOriginFormDataFields`
+ * 调整、字段增减——都会让它改变；摘要缓存条目的 `dv` 与之比对即可自动失效重写。
+ */
+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]),
+    ]);
+    let hash = 5381;
+    for (let i = 0; i < material.length; i += 1)
+        hash = ((hash << 5) + hash + material.charCodeAt(i)) >>> 0;
+    return hash.toString(16);
+}
 function normalizeEntry(raw) {
     if (!raw || typeof raw !== 'object')
         return null;
     const value = raw;
+    // 旧格式（v1：context + 8 字段/80 字截断）与新口径不兼容，直接视为无效
+    if (value.v !== DETAIL_CACHE_ENTRY_VERSION)
+        return null;
     if (typeof value.cachedAt !== 'number' || !Number.isFinite(value.cachedAt))
         return null;
-    if (typeof value.context !== 'string')
+    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 fields = Array.isArray(value.fields)
         ? value.fields
             .filter((item) => Boolean(item) && typeof item.fieldName === 'string'
@@ -36,10 +72,11 @@ function normalizeEntry(raw) {
         : [];
     const metrics = value.metrics && typeof value.metrics === 'object' ? value.metrics : {};
     return {
-        context: value.context,
-        contextAvailable: value.contextAvailable === true,
-        metrics,
+        v: DETAIL_CACHE_ENTRY_VERSION,
+        basicInfo,
         fields,
+        metrics,
+        excludeTag: value.excludeTag,
         cachedAt: value.cachedAt,
     };
 }

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

@@ -4,7 +4,8 @@ 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';
@@ -144,11 +145,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 +251,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.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;
             }