weaver-work-cli 0.1.36 → 0.1.39

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

@@ -88,8 +88,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);
         }
     }

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

@@ -3,13 +3,31 @@ import { workflowValidationError } from '../../errors.js';
 import { asRecord, readBoundedInt } from './todoSmartConvert.core.js';
 import { orderGroupsByIntent, readGroupOrder } from './todoSmartConvert.group.js';
 import { detectBusinessKind, needsRequestSummary } from './businessRules.js';
-import { openSummaryCache } from './summaryCache.js';
+import { openSummaryCache, promptTagOf } from './summaryCache.js';
+import { openDetailCache, detailMaterialTagOf } from './todoDetailCache.js';
 import { loadDetailContextProvider, stampsOfRows } from './todoSmartConvert.detail.js';
 import { requestItemsOf, rowsOfGroup, runSmartGroup, totalTodoCount, } from './todoSmartConvert.smartGroup.js';
 /** 该组是否需要 AI 生成单条摘要（规则 needSummary 决定，默认需要）。 */
 function needAiSummary(workflowName) {
     return activeRuleFor(workflowName)?.needSummary ?? true;
 }
+/**
+ * 单条摘要的目标字数：**入参 > aigroup 规则（default.json / user-intents.json）> 内置兜底**。
+ *
+ * 规则是主要来源（2026-10-30 用户要求「摘要规则必须从 JSON 取」），入参只在用户当轮明确给了
+ * 口径（如「每条 30 字」）时覆盖它；两者都没有才用兜底 50。
+ */
+function requestMaxCharsFor(args, workflowName) {
+    return readBoundedInt(args.summaryMaxChars ?? activeRuleFor(workflowName)?.summaryMaxChars, 'summaryMaxChars', DEFAULT_REQUEST_SUMMARY_MAX, 10, 500);
+}
+/** 该组的单条摘要口径提示（规则 `requestSummaryPrompt`，空串表示没有）。 */
+function requestPromptFor(workflowName) {
+    return (activeRuleFor(workflowName)?.requestSummaryPrompt ?? '').trim();
+}
+/** 批次里出现过的目标字数（去重、升序）；用于在 meta 里表达「各组口径可能不同」。 */
+function distinctBatchMaxChars(batches) {
+    return [...new Set(batches.map((batch) => batch.suggestedMaxChars))].sort((left, right) => left - right);
+}
 const DEFAULT_MAX_CHARS_PER_BATCH = 24_000;
 const DEFAULT_MAX_ITEMS_PER_BATCH = 100;
 const DEFAULT_REQUEST_SUMMARY_MAX = 50;
@@ -194,18 +212,42 @@ export async function runSummaryContext(args, env, prefetched) {
         .reduce((sum, group) => sum + rowsOfGroup(group).length, 0);
     // 优先组是叠加视图 ⇒ 同一条待办会在两个位置各出现一次，统计口径必须去重。
     const requestIds = [...new Set(units.flatMap((unit) => unit.rows.map((row) => row.requestId)))].filter(Boolean);
-    // 单条摘要目标字数：用户给了口径（如「每条 30 字」）就用用户的，没给才用默认 50。
-    const summaryMaxChars = readBoundedInt(args.summaryMaxChars, 'summaryMaxChars', DEFAULT_REQUEST_SUMMARY_MAX, 10, 500);
     // 摘要缓存命中时直接回填，未命中的条目才进入 AI 批次。
     //   预填必须在「准备详情」之前做——已有摘要的条目根本不需要详情（详情只为写摘要服务）。
     const summaryCache = await openSummaryCache(env.ctx);
+    // 摘要条目的素材特征值（dv）：读详情缓存（本地文件，不发请求）算当前素材哈希，
+    // 与条目写入时的素材比对——素材变了 ⇒ 旧摘要失效重写（2026-11-01 根治）。
+    const detailCacheForTag = await openDetailCache(env.ctx);
+    const materialTagOfRow = (requestId, stamp) => {
+        const entry = detailCacheForTag.get(requestId, stamp);
+        return entry ? detailMaterialTagOf(entry) : undefined;
+    };
     /** 已有摘要（缓存命中 / collect 已回填）而跳过 AI 的条数 */
     let prefilled = 0;
     const prefilledIds = new Set();
     const needsDetail = [];
+    /**
+     * 优先组里的条目在**工作流组**里还有一份副本——它们的规则口径必须按**原工作流**解析，
+     * 而不是按「建议优先处理的流程」这个组名（它匹配不到规则 ⇒ pk/字数都取错）。
+     * 先建 requestId → 工作流组名 的映射，优先组的行查这张表。
+     */
+    const workflowTitleByRequest = new Map();
+    for (const unit of units) {
+        if (unit.groupId === 'priority')
+            continue;
+        for (const row of unit.rows) {
+            if (row.requestId && !workflowTitleByRequest.has(row.requestId)) {
+                workflowTitleByRequest.set(row.requestId, unit.groupTitle);
+            }
+        }
+    }
+    const ruleNameForRow = (unit, row) => unit.groupId === 'priority'
+        ? (workflowTitleByRequest.get(row.requestId ?? '') ?? unit.groupTitle)
+        : unit.groupTitle;
     for (const unit of units) {
         for (const row of unit.rows) {
-            const cached = summaryCache.get(row.requestId, row.lastFeedBackDateTime, summaryMaxChars);
+            const name = ruleNameForRow(unit, row);
+            const cached = summaryCache.get(row.requestId, row.lastFeedBackDateTime, requestMaxCharsFor(args, name), promptTagOf(requestPromptFor(name)), materialTagOfRow(row.requestId, row.lastFeedBackDateTime));
             if (cached) {
                 row.summary = cached;
                 prefilled += 1;
@@ -232,7 +274,10 @@ export async function runSummaryContext(args, env, prefetched) {
      * 所以这里跳过不会让任何一份摘要空缺，只是省掉一次重复的上下文。
      */
     const claimed = new Set();
-    for (const unit of units) {
+    // 优先组**最后**处理：它的条目在工作流批次里已经带着各自规则的口径（requestSummaryPrompt）
+    // 被写过一遍；若优先组先处理，口径会丢失（优先组标题匹配不到规则）。剩下的未认领条目才进优先批次。
+    const orderedUnits = [...units].sort((a, b) => Number(a.groupId === 'priority') - Number(b.groupId === 'priority'));
+    for (const unit of orderedUnits) {
         let bucket = [];
         let chars = 0;
         let seq = 0;
@@ -240,6 +285,9 @@ export async function runSummaryContext(args, env, prefetched) {
             if (bucket.length === 0)
                 return;
             seq += 1;
+            // 批次口径按本批**第一条**所属工作流的规则取（正常批次不跨工作流；
+            // 优先组批次兜底时可能混多条工作流，此时以首条为准，逐条口径随 items 上下文仍可辨）
+            const firstName = ruleNameForRow(unit, { requestId: bucket[0].requestId });
             batches.push({
                 batchId: `${unit.subGroupId}#${seq}`,
                 groupId: unit.groupId,
@@ -250,7 +298,8 @@ export async function runSummaryContext(args, env, prefetched) {
                 charCount: chars,
                 kind: unit.kind,
                 ...(unit.kind === 'internal-message' ? { hint: INTERNAL_MESSAGE_SUMMARY_HINT } : {}),
-                suggestedMaxChars: summaryMaxChars,
+                ...(requestPromptFor(firstName) ? { prompt: requestPromptFor(firstName) } : {}),
+                suggestedMaxChars: requestMaxCharsFor(args, firstName),
                 items: bucket,
             });
             bucket = [];
@@ -329,8 +378,10 @@ export async function runSummaryContext(args, env, prefetched) {
                 titleCopied,
                 /** 本地摘要命中、跳过 AI 的条数 */
                 prefilled,
-                /** 单条摘要的目标字数（默认 50，可由 summaryMaxChars 覆盖） */
-                suggestedMaxChars: summaryMaxChars,
+                /** 单条摘要的目标字数：口径一致时给数字，各组口径不同时给 distinct 列表 */
+                ...(distinctBatchMaxChars(batches).length === 1
+                    ? { suggestedMaxChars: distinctBatchMaxChars(batches)[0] }
+                    : { suggestedMaxCharsList: distinctBatchMaxChars(batches) }),
                 /** 内部留言类批次：摘要要按「最低推理强度」写 */
                 internalMessageBatches: batches.filter((batch) => batch.kind === 'internal-message').length,
                 skippedSatisfaction,
@@ -388,16 +439,42 @@ export function readAiSummaries(value) {
 export async function runSummary(args, env) {
     const groups = await readFinalGroups(args, env);
     const summaries = readAiSummaries(args.aiSummaries);
-    // 单条摘要目标字数：与 `runSummaryContext` 保持同一口径（用户给了就用用户的）。
-    const summaryMaxChars = readBoundedInt(args.summaryMaxChars, 'summaryMaxChars', DEFAULT_REQUEST_SUMMARY_MAX, 10, 500);
+    // 单条摘要目标字数：与 `runSummaryContext` 保持同一口径（入参 > 规则 > 兜底）。
+    /** 按工作流名缓存本组的字数口径，避免逐行解析规则。 */
+    const maxCharsByGroup = new Map();
+    const maxCharsFor = (workflowName) => {
+        const hit = maxCharsByGroup.get(workflowName);
+        if (hit !== undefined)
+            return hit;
+        const value = requestMaxCharsFor(args, workflowName);
+        maxCharsByGroup.set(workflowName, value);
+        return value;
+    };
     // ★ 本次 AI 写出来的摘要顺手进缓存（key=requestId__lastFeedBackDateTime），
     //   下次同一条流程的待办再来时可以复用摘要。
     const summaryCache = await openSummaryCache(env.ctx);
+    // 素材特征值（与 summaryContext 同口径）：写入时锚定当前详情素材，读取时比对失效
+    const detailCacheForTag = await openDetailCache(env.ctx);
+    const materialTagOfRow = (requestId, stamp) => {
+        const entry = detailCacheForTag.get(requestId, stamp);
+        return entry ? detailMaterialTagOf(entry) : undefined;
+    };
     let cacheWritten = 0;
     // 缓存预填（与 `summaryContext` 同口径）：只跑 `summary` 阶段时也能拿到已写好的摘要，
     // 否则重跑 finish（不带 aiSummaries）会把整份摘要清成空串。
     // 满意度类不走 AI、也不读缓存：直接用标题当摘要，保证 `summary` 不为空。
     let titleSummary = 0;
+    // 优先组的行按**原工作流**解析口径（组名「建议优先处理的流程」匹配不到规则）。
+    const wfTitleByRequest = new Map();
+    for (const group of groups) {
+        if (group.topPriority)
+            continue;
+        for (const row of rowsOfGroup(group)) {
+            if (row?.requestId && !wfTitleByRequest.has(row.requestId))
+                wfTitleByRequest.set(row.requestId, group.title);
+        }
+    }
+    const ruleNameForGroup = (group, row) => group.topPriority ? (wfTitleByRequest.get(row?.requestId ?? '') ?? group.title) : group.title;
     for (const group of groups) {
         if (!needAiSummary(group.title)) {
             for (const row of rowsOfGroup(group)) {
@@ -412,7 +489,8 @@ export async function runSummary(args, env) {
         for (const row of rowsOfGroup(group)) {
             if (!row?.requestId || (row.summary ?? '').trim())
                 continue;
-            const cached = summaryCache.get(row.requestId, row.lastFeedBackDateTime, summaryMaxChars);
+            const name = ruleNameForGroup(group, row);
+            const cached = summaryCache.get(row.requestId, row.lastFeedBackDateTime, maxCharsFor(name), promptTagOf(requestPromptFor(name)), materialTagOfRow(row.requestId, row.lastFeedBackDateTime));
             if (cached) {
                 row.summary = cached;
             }
@@ -440,7 +518,7 @@ export async function runSummary(args, env) {
     let prefilledKept = 0;
     /** 统计用：同一条待办在叠加视图里出现两次，计数只算一次 */
     const countedIds = new Set();
-    const applyAll = (rows) => {
+    const applyAll = (rows, meta) => {
         for (const row of rows) {
             const summary = summaries.get(row.requestId) ?? '';
             const firstTime = !row.requestId || !countedIds.has(row.requestId);
@@ -461,10 +539,10 @@ export async function runSummary(args, env) {
             if (summary) {
                 if (firstTime) {
                     filled += 1;
-                    if (summary.length > summaryMaxChars)
+                    if (summary.length > meta(row).maxChars)
                         tooLong += 1;
                 }
-                if (summaryCache.set(row.requestId, row.lastFeedBackDateTime, summary, summaryMaxChars))
+                if (summaryCache.set(row.requestId, row.lastFeedBackDateTime, summary, meta(row).maxChars, meta(row).pk, materialTagOfRow(row.requestId, row.lastFeedBackDateTime)))
                     cacheWritten += 1;
             }
             else if (firstTime) {
@@ -478,18 +556,30 @@ export async function runSummary(args, env) {
         if (!needAiSummary(group.title))
             continue;
         if (group.topPriority) {
-            applyAll(rowsOfGroup(group));
+            applyAll(rowsOfGroup(group), (row) => {
+                const name = ruleNameForGroup(group, row);
+                return { maxChars: maxCharsFor(name), pk: promptTagOf(requestPromptFor(name)) };
+            });
             continue;
         }
         for (const item of group.displayItems) {
             if (item.type === 'group') {
-                applyAll(item.requestDatas);
+                applyAll(item.requestDatas, (row) => {
+                    const name = ruleNameForGroup(group, row);
+                    return { maxChars: maxCharsFor(name), pk: promptTagOf(requestPromptFor(name)) };
+                });
                 continue;
             }
             // 单独展示的一条：只回填它自己
-            applyAll([item.requestData]);
+            applyAll([item.requestData], (row) => {
+                const name = ruleNameForGroup(group, row);
+                return { maxChars: maxCharsFor(name), pk: promptTagOf(requestPromptFor(name)) };
+            });
         }
     }
+    /** 告警与 meta 里展示的口径：各组一致就给数字，不一致就给 `a/b` 形式。 */
+    const usedMaxChars = [...new Set(maxCharsByGroup.values())].sort((left, right) => left - right);
+    const maxCharsHint = usedMaxChars.length > 0 ? usedMaxChars.join('/') : String(DEFAULT_REQUEST_SUMMARY_MAX);
     if (empty > 0) {
         warnings.push(`有 ${empty} 条没有拿到 AI 摘要，summary 保持空串（未用标题兜底、未编造）`);
     }
@@ -497,7 +587,7 @@ export async function runSummary(args, env) {
         warnings.push(`有 ${titleKept} 条详情为空的条目保留 CLI 填充的标题摘要（不参与 AI 回填）`);
     }
     if (tooLong > 0) {
-        warnings.push(`有 ${tooLong} 条摘要超过目标长度 ${summaryMaxChars} 字（可按用户口径调整），已原样保留；`
+        warnings.push(`有 ${tooLong} 条摘要超过目标长度 ${maxCharsHint} 字（可按用户口径调整），已原样保留；`
             + '如需控制长度请重跑模型侧（CLI 不改写文案）');
     }
     if (prefilledKept > 0) {
@@ -527,8 +617,8 @@ export async function runSummary(args, env) {
         meta: {
             summarized: filled,
             empty,
-            /** 单条摘要的目标字数（默认 50，可由 summaryMaxChars 覆盖） */
-            suggestedMaxChars: summaryMaxChars,
+            /** 单条摘要的目标字数：各组口径一致时给数字，不一致时给 distinct 列表 */
+            ...(usedMaxChars.length === 1 ? { suggestedMaxChars: usedMaxChars[0] } : { suggestedMaxCharsList: usedMaxChars }),
             titleCopied: titleKept,
             /** 本地摘要缓存命中、未重新生成的条数 */
             prefilled: prefilledKept,

package/docs/_catalog.md

@@ -50,3 +50,6 @@
 | Agent 调用采知连文档中心 CLI 的入口路由 | `skills/weaver-e10-caizhilian/SKILL.md` |
 | Agent 调用采知连文档中心 CLI 的具体 reference | `skills/weaver-e10-caizhilian/references/` |
 | 将新业务模块文档或代码同步转换为 weaver-work-cli 业务 CLI 与 Skill、检测源资料更新 | `skills/weaver-e10-skill-maker/SKILL.md` |
+| E10 闲置资产判定结果查询（分页获取/聚合统计/三张图口径）、asset-idle operation | `docs/asset-idle.md` |
+| Agent 调用闲置资产统计 CLI 的入口路由 | `skills/weaver-e10-asset-idle/SKILL.md` |
+| Agent 调用闲置资产统计 CLI 的具体 reference | `skills/weaver-e10-asset-idle/references/` |

package/docs/asset-idle.md

@@ -0,0 +1,45 @@
+# asset-idle — E10 闲置资产判定结果查询 CLI
+
+## 模块来源
+
+源资料为用户级技能 `weaver-e10-ziguanjia-idle`（SKILL.md + references/api.md + references/widget-style.md，2026-10-27 起实测固化的闲置资产统计口径）。按 `weaver-e10-skill-maker` 流程同步生成 CLI 模块与 Skill `weaver-e10-asset-idle`（CLI 命令后缀与 Skill 后缀均为 `asset-idle`，2026-11-02 用户确认）。
+
+- 源接口：`POST {baseurl}/api/esb/server/event/triggerActionFlow`（动作流「自用-skill获取闲置资产」）
+- 源口径：闲置判定由服务端动作流完成，CLI 只取数与聚合，不重算
+
+## 命令结构
+
+```text
+weaver-work-cli asset-idle schema
+weaver-work-cli asset-idle run <operation> --input-json '<json>'
+```
+
+## operation 表
+
+| operation | 风险 | 说明 |
+| --- | --- | --- |
+| `asset-idle.idle.list` | read | 触发动作流，按 `hasMore` 自动翻页（每页 1000 条，服务端固定），合并各页 `idleAssets` 为结果集 |
+| `asset-idle.idle.stats` | read | 在合并结果上聚合：`czjyCounts`（0=待调拨/1=待调剂/2=待评估/缺失=无法判断）、`typeCounts`（zclx 降序）、`agingBuckets`（≤30/31–90/91–180/181–365/>365 天，边界归前一档，0 档不返回） |
+
+## 何时用哪个 operation
+
+- 只要统计出图 → `idle.stats`（一次拿到全部分组，不要先 list 再自己数）
+- 要明细、逐条判定依据 → `idle.list`
+- 两个 operation 输入一致：`esbFlowId`（必填，1-32 位数字字符串）、`maxPages`（默认 20，1-100）
+
+## 输入与字段口径
+
+- `esbFlowId` 必须由调用方传入；按名称解析动作流 ID 需要的 ESB 应用列表查询接口在源资料中只有旧版 e10-cli 命令名，未实现（schema `withheldOperations: asset-idle.flow.resolve`）
+- 判定字段直接使用：`xzsz`（闲置时长/天）、`pdyj`（判定依据）、`zxd`（置信度）、`czjy`（处置建议编码）；缺失标「无法判断」并排除出统计
+- 恒为空展示字段（`czjy_obj`/`xzdj_obj`/`yjzczt_obj`/`czlc`/`czlc_obj`/`zcxzczrq`）不透出；禁止反推 `idle_date`/`stockindate`/`use_term`（`disabledCapabilities`）
+
+## 已知限制
+
+- 会话失效判据为接口返回 `{"error":"authentication required","code":-2}`（HTTP 200），与标准 401 并行识别
+- `truncated=true`（达到 maxPages 且 hasMore 仍 true）时结果不是全集，调用方应增大 `maxPages` 重查
+- 动作流数据规模随系统台账变化（2026-10-30 起为判定结果集，384 条；此前为原始台账 2885 条）
+
+## 安全边界
+
+- 只读模块，无写链；认证请求头由 `weaver-work-cli` 统一托管，模块代码不读取、不拼装任何凭据
+- 两个 operation 均为 `risk: read`，Agent 可直接执行；失败处置见 `skills/weaver-e10-asset-idle/references/`

package/docs/e10-auth.md

@@ -69,7 +69,7 @@ E10 目标地址按“显式 `--base-url` → 专用 `WEAVER_XIAOE_*` E10 配置
 
 `auth xiaoe` 会先打印不含凭证的 preflight 摘要，给出 `authMode=xiaoe`、`credentialSourceDetected`、`attempted`、各凭据源检测结果和目标 `baseUrl`。进入脚本分支时会打印 `Trying XiaoE token script credential...`；进入内置 Node 会话分支时会打印 `Trying built-in XiaoE client session credential...`。成功结果和后续 `auth status` 会显示 `credentialSourceStep`、`credentialSourceType`、`credentialSourceLabel`。
 
-业务命令不会在缺少本地会话时主动建立 XiaoE 登录态，首次使用仍需显式执行 `auth xiaoe`。已有 XiaoE 会话被 E10 接口明确拒绝为失效时，公共请求运行时会根据持久化会话的 `agentType` / `loginSource` 静默换票并重放原请求一次；这条路径不依赖 shared Skill、Agent、`XIAOE_*` 或 `--runtime-agent xiaoe`。它不会打印中间登录步骤，不会自动打开浏览器，也不会对流式请求、网络错误、`partial` / `write_uncertain` 做重放。`--runtime-agent xiaoe` 仅用于其他 XiaoE 专属业务行为，不携带也不选择凭据。WorkBuddy、Codex 及其他智能体首次认证使用 `auth login --base-url <url> --agent_type <agent_type>` 的浏览器 OAuth 流程。
+业务命令缺少可读取的本地会话时，若当前运行时已通过 `XIAOE_*`、`--runtime-agent xiaoe` 等标记识别为 XiaoE，公共会话加载层会先静默尝试统一登录，成功后继续业务操作。失败时返回 `authentication/xiaoe_credential_unavailable`，并明确提示已尝试自动获取。显式 `--auth` 不触发此恢复；未识别到 XiaoE 的首次认证仍需显式选择登录方式。`auth status --no-check` 等本地状态查询不会主动登录。已有 XiaoE 会话被 E10 接口明确拒绝为失效时，公共请求运行时会根据持久化会话的 `agentType` / `loginSource` 静默换票并重放原请求一次；这条路径不依赖 shared Skill、Agent、`XIAOE_*` 或 `--runtime-agent xiaoe`。它不会打印中间登录步骤，不会自动打开浏览器，也不会对流式请求、网络错误、`partial` / `write_uncertain` 做重放。`--runtime-agent xiaoe` 表示当前运行时身份，不携带凭据。WorkBuddy、Codex 及其他智能体首次认证使用 `auth login --base-url <url> --agent_type <agent_type>` 的浏览器 OAuth 流程。
 
 无法使用浏览器回调时，可以用 `auth set` 直接写入浏览器中复制到的
 `ETEAMSID`。命令会调用 `teamsCheck` 解析当前用户、租户和组织信息，并写入

package/docs/todo-smart-convert/subgroup-rules.md

@@ -6,7 +6,7 @@
 
 > **⚠️ 2026-10-28 起：分组规则已外置到 JSON，代码不再按业务类型分支。**
 > 唯一真源是 `skills/weaver-e10-workflow/aigroup/default.json`（`{defaults, rules[]}`，随 skill 分发、只读），用户意图另存 **CLI 状态目录**下的 `aigroup/user-intents.json`（`weaver-work-cli aigroup set` 写入，刻意不落 skill 目录，避免被打包带走）。
-> 现行规则要点：①没有 `aiGroup` ⇒ 全平铺；②`focus:true` ⇒ 按 `focusKeyword`（`[指标, 算子, 值]`，十种算子）确定性成一组，`groupTitle` 为组名，`sysArg` 指明指标取自列表属性还是流程详情；③`focus:false` ⇒ `aiContext`（流程标题/流程详情）交 AI 分组，**必须**给 `aiGroups`；④`focus:true` 收到多个计划子组时**只保留条数最多的一个**，其余平铺；⑤`aiGroups.seq` 已删除，只认 `requestIds`；⑥组摘要 `groupSummary.needAI:false` 时由 CLI 按 JSON `template` 渲染，`true` 时交 AI；⑦单条摘要由 `needSummary` 决定（false ⇒ 用标题）。
+> 现行规则要点：①没有 `aiGroup` ⇒ 全平铺；②`focus:true` ⇒ 按 `focusKeyword`（`[指标, 算子, 值]`，十种算子）确定性成一组，`groupTitle` 为组名，`sysArg` 指明指标取自列表属性还是流程详情；③`focus:false` ⇒ `aiContext`（流程标题/流程详情）交 AI 分组，**必须**给 `aiGroups`；④`focus:true` 收到多个计划子组时**只保留条数最多的一个**，其余平铺；⑤`aiGroups.seq` 已删除，只认 `requestIds`；⑥组摘要 `groupSummary.needAI:false` 时由 CLI 按 JSON `template` 渲染，`true` 时交 AI；⑦单条摘要由 `needSummary` 决定（false ⇒ 用标题）；⑧详情素材要排掉哪些 formData 字段由 **`excludeOriginFormDataFields`**（字段名清单，fieldName 精确匹配，2026-10-30 定稿）维护，过滤后 ≤200 个字段、单值 ≤500 字。
 > 下面各节是按类型描述的**历史口径**，仅作背景参考；与本节冲突时以本节与 `default.json` 为准。
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weaver-work-cli",
-  "version": "0.1.36",
+  "version": "0.1.39",
   "description": "面向泛微工作工具链的可扩展 TypeScript CLI 基础框架（E10 业票通等能力）",
   "type": "module",
   "main": "./dist/index.js",

package/scripts/package-skill.mjs

@@ -77,6 +77,8 @@ function shouldSkip(entry, relativePath) {
   if (entry.name === '.DS_Store' || entry.name.startsWith('.')) return true
   if (relativePath === 'product.json') return true
   if (relativePath === 'references/source-manifest.json') return true
+  // 用户意图是本机产物（2026-11-01 起与 default.json 同目录），不随包分发
+  if (relativePath.endsWith('user-intents.json')) return true
   if (entry.isDirectory() && ['cache', 'assets', 'node_modules', 'scripts'].includes(entry.name)) return true
   return false
 }

package/skill-template/business-info.json

@@ -512,5 +512,18 @@
     "合同借阅",
     "档案记录",
     "合同编号"
+  ],
+  "weaver-e10-asset-idle": [
+    "闲置资产",
+    "资产闲置",
+    "闲置判定",
+    "闲置统计",
+    "待调拨",
+    "待调剂",
+    "待评估",
+    "闲置时长",
+    "置信度",
+    "处置建议",
+    "资管家闲置"
   ]
-}
+}

package/skill-template/domains/asset-idle.md

@@ -0,0 +1,13 @@
+本业务域用于泛微 E10 资管家的**闲置资产判定结果查询与统计出图**。入口 `SKILL.md` 先路由到 `weaver-e10-shared/SKILL.md`，再给出判定口径语义（服务端判定不重算）、操作路由和出图流程。具体用法拆到 `references/`：
+
+- `idle-list.md`：`asset-idle.idle.list` 分页拉取服务端已判定的闲置资产结果集、字段口径与失败处置。
+- `idle-stats-and-charts.md`：`asset-idle.idle.stats` 聚合统计（czjy 处置建议 / zclx 类型 / xzsz 时长分档）与三张图输出流程、系统页面地址行规则。
+- `widget-style.md`：三张图的唯一样式来源（尺寸、字号、色值、文案结构）。
+- `source-manifest.json`：源资料清单与 sha256 指纹，用于源资料更新检测。
+
+调优重点：
+
+- `weaver-work-cli asset-idle schema` 是 operation 合约第一信息源；`withheldOperations` 声明按名称解析动作流 ID（`asset-idle.flow.resolve`）为禁用能力，`esbFlowId` 必须由调用方传入，不引导用户猜 ID。
+- **判定口径红线**：xzsz / pdyj / zxd / czjy 服务端已判定，CLI 与 Agent 都不重算、不补算；xzsz/czjy 缺失标「无法判断」并排除出对应统计（`disabledCapabilities.idle-date-recalculation`）。
+- 统计出图按固定流程：`idle.stats` → widget_guidelines → 三张图连续输出（图前图间无正文文字）→ 图③ widget 内部最后一行输出 `闲置资产详情：{url}`。
+- 与 `weaver-e10-ziguanjia`（`weaver-work-cli asset`，资产台账管理）的路由区分：闲置统计/出图走本域，入库/领用/归还/维保走资管家。

package/skill-template/domains/wenshuding.md

@@ -2,6 +2,7 @@
 
 - `archive-agent-entry.md`：schema、统一 `archive run` 入口、stdin/文件 JSON 调用方式和输出约定。
 - `archive-fonds.md`：全宗列表与预归档电子文件库节点识别（上传的 treeId 来源）。
+- `archive-prelib-list.md`：电子文件库列表查询（`treeId -> getTreeDetail -> getListDatas`）与智能识别的 `prepare -> apply`。
 - `archive-search.md`：全文检索可借档案，结果行的 `id`/`formId` 复用规则。
 - `archive-info.md`：档案基本信息查询（`{档案ID}_{表单ID}` 与 `dataId+formId` 两种输入）。
 - `archive-borrow-car.md`：借阅车列表（首选自定义接口、失败自动回退）与加入借阅车的 `prepare -> apply` 协议。
@@ -20,3 +21,5 @@ Agent 调优重点：
 - 下载为异步任务：`.apply` 会轮询打包进度并落盘，不要按超时立即重试。
 - 发起借阅/续借只返回 URL，不自动打开浏览器；必须把 URL 交给用户并说明需在浏览器完成填写与提交。
 - 结果为 `partial/write_uncertain` 时停止，不自动重放写请求。
+- 电子文件库列表（`archive.prelib.list`）属于预归档库数据，与全文检索的可借档案不是同一批，不要混用；行 `id` 是智能识别 `checkIds` 的来源，展示时保留。
+- 智能识别（`intelligentCate`）是异步任务：返回 `taskId` 只表示已提交，不得声称识别完成，也不要重复提交。

package/skills/weaver-e10-archive-oa/SKILL.md

@@ -81,6 +81,7 @@ Agent 不得自行拼接、改写或向用户索取上述凭证（禁止要求
 | 查契约锁（案例）合同 | `archive-oa run archive-oa.qys.contract.list` | [`qys-contract-search.md`](references/qys-contract-search.md) |
 | 加入借阅车 / 看借阅车 | `archive-oa run archive-oa.borrow-car.add.prepare` → `.apply` / `archive-oa.borrow-car.list` | [`borrow-car.md`](references/borrow-car.md) |
 | 发起借阅（**生成流程页 URL 并打开浏览器**） | `archive-oa run archive-oa.borrow.start.url` / 契约锁 `archive-oa.qys.borrow.start.url`（或 `archive-oa borrow start-url [--source qys]`） | [`borrow-flow.md`](references/borrow-flow.md) |
+| 查询我的借阅 / 我的借阅单 | 转到 `weaver-e10-workflow` 的 `workflow.search` | [`my-borrow.md`](references/my-borrow.md) |
 | 其余未收录能力 | 不在范围 | [`disabled-capabilities.md`](references/disabled-capabilities.md) |
 
 契约锁链路把 operation 前缀换成 `archive-oa.qys.*`（借阅车 `archive-oa.qys.borrow-car.*`、发起借阅 `archive-oa.qys.borrow.start.url`）。两套的流程页 URL 规则相同，`fb` 取借阅车记录自身的值（泛微 `0`、契约锁 `1`），禁止手工指定；契约锁客户名称字段是 `qymc`，泛微是 `htmc`。

package/skills/weaver-e10-archive-oa/references/my-borrow.md

@@ -0,0 +1,49 @@
+# 查询我的借阅 / 我的借阅单
+
+用户说「我的借阅」「我的借阅单」「查一下我借的合同」时，**本技能不自己查流程数据**——`archive-oa` 只有合同查询与借阅车能力，没有流程查询能力。改用 **`weaver-e10-workflow`** 技能的 `workflow.search`。
+
+执行前按共享规则确认 `weaver-e10-workflow` 已安装；未安装时如实告知，不要用 `archive-oa` 的 operation 冒充流程查询。
+
+## 固定限制（强制）
+
+| 参数 | 取值 | 说明 |
+| --- | --- | --- |
+| `workflow` | `["泛微合同电子档借阅申请流程"]` | **必须且只能是这一个工作流**；纯名称由 CLI 调 workflowPathBrowser 解析。多命中/0 命中时 CLI 返回澄清信封（`candidates`），此时用自然语言请用户确认完整名称，再按「名称(ID)」重发；**不要自己挑一个、不要向用户索取 ID** |
+| `filterFields` 前提 | 必须传 `workflow` 且**只能是单个** | 缺 workflow 报 `field_require_workflow`，多个报 `field_require_single_workflow` |
+| `category` | `mine`（默认） | 「我的借阅」= 我发起的 → `mine`。用户说「待我审批的借阅」才是 `todo`；说「我处理过的」→ `done`；都不确定且给了条件 → `all` |
+| mine 为 0 时 | 提示后改查 `done` | 实测当前账号 `mine`=0、`done`=14（借阅流程多为他人发起、本人作为档案/审批方处理）。**`mine` 查到 0 条不要直接下结论「没有借阅」**，要如实说明「我发起的没有，我处理过的有 N 条，要看吗？」，用户确认后再用 `done` 查 |
+
+## 默认：只查「授权结束日期」未到期
+
+**已实测可用的写法**（直接照用）：
+
+```json
+{"category":"...","workflow":["泛微合同电子档借阅申请流程"],
+ "filterFields":[{"fieldName":"授权结束日期","term":"like","value":["<今天 YYYY-MM-DD>","9999-12-31"]}]}
+```
+
+- 「授权结束日期」是**日期字段**，`term` **只支持 `like` / `null` / `notnull`**；传 `ge` / `gt` 会报 `field_term_unsupported`。
+- `like` 的 `value` 是**日期区间 `[开始, 结束]`**（YYYY-MM-DD）。**单边空串代表最小值**，所以：
+  - 未到期（≥ 今天）→ `["<今天>","9999-12-31"]`（**不要写 `["<今天>",""]`**，会被判「起点晚于终点」而报 `time_invalid`）；
+  - 已到期（< 今天）→ `["","<昨天>"]`。
+- 「今天」取当前真实日期，**禁止写死日期**。
+- 实测对照（同一工作流）：已办共 14 条，未到期区间返回 **0**、已到期区间返回 **14**，证明该区间过滤真实生效。
+- 字段名以 CLI 实际解析为准：`fieldName` 支持 `字段名(字段ID)` 或纯字段名；多命中/0 命中返回澄清信封（候选为 `字段名(字段ID)`），**按候选选择，不得臆造**；字段元数据读不到（`field_meta`）时如实告知并改为不带 `filterFields` 查询。
+- **不要逐条 `workflow.detail` 去取授权结束日期**：列表 `cards` 不带表单字段，且详情返回的表单值实测可能为空；用上面的 `filterFields` 区间即可，无需逐条调用。
+
+## 与用户交互：查全部
+
+- 默认只查未到期；**每次汇报都要说明**「当前只含未到期，要看全部请说『查全部』」。
+- 用户说「全部」「所有」「包括已到期的」「不限」「都列出来」时，**去掉授权结束日期条件**重新查一次（其余限制不变，仍限定该工作流）。
+- 未到期查到 0 条时，主动提示「要不要看全部（含已到期）」，不要直接下结论说没有借阅记录。
+
+## 展示
+
+- 按 `workflow.search` 的返回原样渲染流程列表（标题、编号、当前节点、状态、发起/结束时间等），**不新增衍生列**。
+- 需要看某条详情时用 `workflow.detail`；需要在 OA 打开时用 `workflow.open`。
+
+## 禁止事项
+
+- **禁止用 `archive-oa` 的 operation 查询借阅流程**（本技能无此能力），也不要把借阅车当成「我的借阅」——借阅车只是待发起的临时清单，不是已发起的流程。
+- 禁止伪造工作流名称、字段 ID 或流程数据。
+- 禁止把「授权结束日期」写成其它字段名（如「到期日期」「结束日期」），以 CLI 返回的候选为准。