weaver-work-cli 0.1.38 → 0.1.40

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

@@ -3,13 +3,43 @@ 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);
+}
+/**
+ * 缓存**命中比对**用的字数口径：只在用户显式传了 `summaryMaxChars`（`--summary-chars`）时返回，
+ * 否则返回 undefined（= 不按字数过滤）。
+ * 2026-11-02 用户定稿：缓存失效只由 requestSummaryPrompt 调整触发；
+ * 规则/默认字数变化（如 50→150）不作废历史摘要，只有用户显式要求不同字数时才重写。
+ */
+function explicitMaxCharsFor(args, workflowName) {
+    const explicit = args.summaryMaxChars;
+    if (explicit === undefined || explicit === null || String(explicit).trim() === '')
+        return undefined;
+    return requestMaxCharsFor(args, workflowName);
+}
+/** 该组的单条摘要口径提示（规则 `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 +224,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) {
-            const cached = summaryCache.get(row.requestId, row.lastFeedBackDateTime, summaryMaxChars);
+            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 name = ruleNameForRow(unit, row);
+            const cached = summaryCache.get(row.requestId, row.lastFeedBackDateTime, explicitMaxCharsFor(args, name), promptTagOf(requestPromptFor(name)), materialTagOfRow(row.requestId, row.lastFeedBackDateTime));
             if (cached) {
                 row.summary = cached;
                 prefilled += 1;
@@ -232,7 +286,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 +297,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 +310,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 +390,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 +451,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 +501,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, explicitMaxCharsFor(args, name), promptTagOf(requestPromptFor(name)), materialTagOfRow(row.requestId, row.lastFeedBackDateTime));
             if (cached) {
                 row.summary = cached;
             }
@@ -440,7 +530,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 +551,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 +568,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 +599,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 +629,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

@@ -59,6 +59,19 @@ Chrome/Edge 原生确认框。宿主需要返回特定会话时，可以传
 结束后页面会自动退回浏览器自定义协议打开方式，不直接显示网络请求错误。
 智能小 E 统一登录不会经过浏览器，也不会显示“返回智能小 E”弹层；该弹层只属于用户另行显式发起的 `auth login` 浏览器 OAuth。
 
+HTTPS E10 授权页跳转到 HTTP loopback 是桌面 OAuth 的标准回调方式：它属于浏览器
+顶层导航，不按 Mixed Content 子资源请求处理。但部分 E10 环境或浏览器安全策略会把
+回调改成 `https://127.0.0.1:<port>`；由于 CLI 本地监听器是 HTTP，此时浏览器会显示
+`ERR_SSL_PROTOCOL_ERROR`，而旧版本 CLI 会继续等待直到超时。CLI 现在会识别发到 HTTP
+端口的 TLS ClientHello，在 WorkBuddy/终端立即给出协议错配提示，并保留 30 秒恢复窗口：
+只把浏览器当前地址开头明确改成 `http://`，保留完整路径和查询参数后回车，即可让同一次
+登录继续完成；未处理则返回 `authentication/oauth_callback_protocol_mismatch`，不再挂起
+5 分钟。长期应在 E10 认证服务侧保留传入的 HTTP loopback 回调，不要改写为 HTTPS。
+若仍收不到回调，再检查 CLI 与浏览器是否在同一台机器，以及 E10 侧的回调白名单。
+该排查只适用于显式浏览器登录，
+`auth xiaoe` 和业务命令的 XiaoE 自动取登录信息使用独立处理函数，不创建本地 HTTP
+服务，也不校验或使用 callback 端口。
+
 XiaoE 宿主身份有两种判定入口：桌面客户端由 Agent 根据“智能小 e 客户端”“小 E”、`XiaoE`、`xiaoe-client` 等明确上下文判断，并传入 `--runtime-agent xiaoe`；网页端沿用原有环境变量规则，成对的 `XIAOE_USER_TOKEN` + `XIAOE_DOMAIN` 会被识别为 XiaoE。工作目录、客户端文件、内置 Node.js、历史登录、路径变量或单个凭据变量都不能单独用于判定。判定为 XiaoE 后，Agent 显式执行 `weaver-work-cli auth xiaoe`。
 
 CLI 依次尝试成对的平台凭据、npm 包自带的 `scripts/xiaoe_env.py` 兼容路径、宿主 `xiaoeUserData/tokens.py`、桌面 XiaoE 客户端本地会话和 `WEAVER_XIAOE_*` ETEAMSID 映射。客户端会话优先读取 `XIAOE_USER_SETTINGS_PATH`，再从 `XIAOE_ROBOT_DATA_ROOT` / `XIAOE_ROBOT_ROOT` 查找，最后回退 macOS `~/Library/Application Support/XiaoE/Robots/<id>/user_settings.json` 或 Windows `%LOCALAPPDATA%/XiaoE/Robots/<id>/user_settings.json`。这些变量和文件只用于定位凭据，不能用于识别宿主。`XIAOE_DOMAIN` 是 XiaoE/erpa 换票服务地址，不是 E10 登录地址。
@@ -69,7 +82,9 @@ 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 换票结果中的 `expiryTimes` 按 Unix 毫秒时间戳持久化。宿主脚本未返回该字段时，CLI 与 XiaoE `tokens.py` 保持一致，按换票成功时间加 2 小时生成。业务命令加载会话后或长进程每次请求前发现当前时间达到 `expiryTimes` 时，会先静默重新换票；换票失败则停止本次业务请求，不会继续发送已知过期的 ETEAMSID。
+
+业务命令缺少可读取的本地会话时，若当前运行时已通过 `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.38",
+  "version": "0.1.40",
   "description": "面向泛微工作工具链的可扩展 TypeScript CLI 基础框架（E10 业票通等能力）",
   "type": "module",
   "main": "./dist/index.js",

package/scripts/mcp-meeting.mjs

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+/**
+ * weaver-work-cli 会议 MCP 服务器（stdio 传输，零依赖）。
+ *
+ * 把 CLI 的会议 operation 封装成 MCP tools，供小E / WorkBuddy 等宿主以 MCP 方式调用：
+ *   {"mcpServers": {"weaver-meeting": {"command": "node", "args": ["<本文件路径>"]}}}
+ *
+ * 设计原则（2026-11-03 与用户对齐）：
+ * - **不重新实现业务**：tools/call 内部直接 spawn 现有 CLI（`meeting run <op> --input-json`），
+ *   防呆闸门（timeConfirmed/roomConfirmed/confirm）、登录态、占用缓存、流程记忆全部原样继承；
+ * - **工具少而清晰**：MCP 工具发现靠模型读 tool schema，工具越多越乱 —— 只暴露 3 个高频动作；
+ * - **零依赖**：MCP stdio 就是 JSON-RPC 2.0（每行一个 JSON），手写握手即可，不引 SDK
+ *   （私服有坏包前科，bundle 链路也不动）。
+ *
+ * 手工自测：
+ *   printf '%s\n%s\n%s\n' \
+ *     '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"t","version":"0"}}}' \
+ *     '{"jsonrpc":"2.0","method":"notifications/initialized"}' \
+ *     '{"jsonrpc":"2.0","id":2,"method":"tools/list"}' | node scripts/mcp-meeting.mjs
+ */
+
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+
+const SERVER_INFO = { name: 'weaver-meeting', version: '1.0.0' };
+const PROTOCOL_VERSION = '2024-11-05';
+
+// CLI 入口：优先同目录的 dist（打包后 scripts/ 与 dist/ 同级），找不到再试仓库根
+const here = path.dirname(fileURLToPath(import.meta.url));
+const candidates = [
+  path.resolve(here, '..', 'dist', 'index.js'),
+  path.resolve(here, '..', '..', 'dist', 'index.js'),
+];
+const CLI_ENTRY = candidates.find((p) => existsSync(p));
+if (!CLI_ENTRY) {
+  console.error(JSON.stringify({ error: `找不到 CLI 入口，试过：${candidates.join(', ')}` }));
+  process.exit(1);
+}
+
+/** 调用现有 CLI：一行 JSON 进，一行 JSON 出。 */
+async function callCli(operation, input) {
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [
+      CLI_ENTRY, '--json', 'meeting', 'run', operation, '--input-json', JSON.stringify(input ?? {}),
+    ], { windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (chunk) => { stdout += String(chunk); });
+    child.stderr.on('data', (chunk) => { stderr += String(chunk); });
+    child.on('close', () => {
+      try {
+        resolve(JSON.parse(stdout));
+      } catch {
+        resolve({
+          ok: false,
+          error: { type: 'mcp', message: `CLI 输出不是 JSON（stderr: ${stderr.slice(0, 200)}；stdout: ${stdout.slice(0, 200)}）` },
+        });
+      }
+    });
+    child.on('error', (error) => {
+      resolve({ ok: false, error: { type: 'mcp', message: `CLI 启动失败：${error.message}` } });
+    });
+  });
+}
+
+/** 把 CLI 的返回压成 MCP text content（大 JSON 直接塞给模型会撑上下文，这里挑关键域）。 */
+function summarize(result) {
+  const data = result?.data ?? {};
+  const brief = {
+    ok: result?.ok === true,
+    ...(result?.ok ? {} : { error: result?.error }),
+    status: data.status,
+    meetingId: data.meetingId ?? undefined,
+    requestId: data.requestId ?? undefined,
+    workflowPending: data.workflowPending,
+    message: typeof data.message === 'string' ? data.message.slice(0, 400) : undefined,
+    // 选项类返回（时段/流程/会议室挑选）必须原样带给模型 —— 用户要在选项里点选
+    options: Array.isArray(data.options) ? data.options.slice(0, 6) : undefined,
+    timings: data.timings,
+  };
+  return { content: [{ type: 'text', text: JSON.stringify(brief, null, 1) }] };
+}
+
+// ---------------------------------------------------------------------------
+// 工具清单：3 个高频动作，schema 直接搬 CLI 入参的精简版（描述要自足，模型只看得到这里）
+// ---------------------------------------------------------------------------
+const TOOLS = [
+  {
+    name: 'meeting_book_room',
+    description: '预订会议室（泛微 E10 EB 版）：发起建会流程并**服务端直提**，不弹流程表单。'
+      + '时间/会议室必须来自用户原话或在候选里点选的结果——'
+      + '时间要传 timeConfirmed: true、会议室要传 roomConfirmed: true 才会真正提交，否则返回候选让用户挑。'
+      + 'submit=false 时只做预检与推荐（不提交、不弹表单）；submit=true 直接提交流程（同样不弹表单）。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        mt_subject: { type: 'string', description: '会议名称/主题（必填）' },
+        begin_datetime: { type: 'string', description: '开始时间 yyyy-MM-dd HH:mm（必填，须来自用户确认）' },
+        end_datetime: { type: 'string', description: '结束时间 yyyy-MM-dd HH:mm' },
+        timeConfirmed: { type: 'boolean', description: '用户原话明确了时间、或在候选中点选后才传 true' },
+        address: { type: 'string', description: '会议室 id 或名称' },
+        roomConfirmed: { type: 'boolean', description: '用户明确指定该会议室、或点选后才传 true' },
+        mt_type: { type: 'string', description: '会议类型名称（流程表单必填项）' },
+        extraFields: { type: 'object', description: '流程表单的其他必填字段（按字段标签传，如 {"会议内容":"..."}）' },
+        submit: { type: 'boolean', description: 'false=只出方案不提交（默认）；true=直接提交流程（不弹表单）' },
+      },
+      required: ['mt_subject', 'begin_datetime'],
+    },
+  },
+  {
+    name: 'meeting_room_list',
+    description: '查询会议室列表（EB 版，含状态）。可按人数/关键词过滤。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        keyword: { type: 'string', description: '会议室名称关键词' },
+        pageSize: { type: 'number', description: '每页条数，默认 20' },
+      },
+    },
+  },
+  {
+    name: 'meeting_room_usage',
+    description: '查询某天某会议室（或不指定则全部会议室）的占用明细，用于回答"这个会议室明天有没有空"。',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        day: { type: 'string', description: '日期 yyyy-MM-dd（必填）' },
+        address: { type: 'string', description: '会议室 id；不传 = 返回当天全部会议室占用' },
+      },
+      required: ['day'],
+    },
+  },
+];
+
+async function handleToolCall(name, args) {
+  if (name === 'meeting_book_room') {
+    const input = {
+      // ⛔ CLI 的语义键是 mt_name（FIELD_ALIASES 里「会议名称/会议主题/主题」都挂在它下面），
+      // mt_subject 不是合法入参 —— MCP 层做一次转换，别把模型给的名称弄丢。
+      mt_name: args.mt_subject ?? args.mt_name,
+      begin_datetime: args.begin_datetime,
+      ...(args.end_datetime ? { end_datetime: args.end_datetime } : {}),
+      ...(args.timeConfirmed ? { timeConfirmed: true } : {}),
+      ...(args.address ? { address: args.address } : {}),
+      ...(args.roomConfirmed ? { roomConfirmed: true } : {}),
+      ...(args.mt_type ? { mt_type: args.mt_type } : {}),
+      ...(args.extraFields && typeof args.extraFields === 'object' ? { extraFields: args.extraFields } : {}),
+      // MCP 口径（2026-11-03 用户确认）：预约会议 = 直提流程，**永不弹流程表单**；
+      // 提交必须 confirm + submit_mode:direct，预检则不带 confirm（CLI 返回方案，同样不弹表单）。
+      ...(args.submit === true ? { confirm: true, submit_mode: 'direct' } : {}),
+    };
+    return summarize(await callCli('meeting.eb.meeting.create.flow.quick', input));
+  }
+  if (name === 'meeting_room_list') {
+    return summarize(await callCli('meeting.eb.room.list', {
+      ...(args.keyword ? { keyword: args.keyword } : {}),
+      ...(args.pageSize ? { pageSize: args.pageSize } : {}),
+    }));
+  }
+  if (name === 'meeting_room_usage') {
+    const day = String(args.day ?? '').slice(0, 10);
+    const input = args.address
+      ? { beginDatetime: `${day} 00:00`, endDatetime: `${day} 23:59`, address: args.address }
+      : { begindatetime: `${day} 00:00`, enddatetime: `${day} 23:59`, pageSize: 200 };
+    const op = args.address ? 'meeting.eb.conflict.room' : 'meeting.eb.roomUsage.list';
+    return summarize(await callCli(op, input));
+  }
+  return { content: [{ type: 'text', text: `未知工具：${name}` }], isError: true };
+}
+
+// ---------------------------------------------------------------------------
+// JSON-RPC over stdio（每行一个消息）
+// ---------------------------------------------------------------------------
+const rl = createInterface({ input: process.stdin });
+const send = (message) => process.stdout.write(`${JSON.stringify(message)}\n`);
+// stdin 关闭（宿主不再发消息）时要等在途的 tools/call 跑完再退——CLI 调用要十几秒，不能被杀
+let pendingCalls = 0;
+let stdinClosed = false;
+
+rl.on('line', (line) => {
+  const text = line.trim();
+  if (text === '') return;
+  let message;
+  try {
+    message = JSON.parse(text);
+  } catch {
+    return; // 非 JSON 行（人话日志）直接忽略
+  }
+  const { id, method, params } = message ?? {};
+  if (method === 'initialize') {
+    send({
+      jsonrpc: '2.0', id,
+      result: {
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: { tools: { listChanged: false } },
+        serverInfo: SERVER_INFO,
+      },
+    });
+    return;
+  }
+  if (method === 'notifications/initialized' || (method ?? '').startsWith('notifications/')) return;
+  if (method === 'tools/list') {
+    send({ jsonrpc: '2.0', id, result: { tools: TOOLS } });
+    return;
+  }
+  if (method === 'tools/call') {
+    pendingCalls += 1;
+    handleToolCall(String(params?.name ?? ''), params?.arguments ?? {})
+      .then((result) => send({ jsonrpc: '2.0', id, result }))
+      .catch((error) => send({
+        jsonrpc: '2.0', id,
+        result: { content: [{ type: 'text', text: `工具执行异常：${error.message}` }], isError: true },
+      }))
+      .finally(() => {
+        pendingCalls -= 1;
+        if (stdinClosed && pendingCalls === 0) process.exit(0);
+      });
+    return;
+  }
+  if (method === 'ping') {
+    send({ jsonrpc: '2.0', id, result: {} });
+    return;
+  }
+  if (id !== undefined) {
+    send({ jsonrpc: '2.0', id, error: { code: -32601, message: `method not found: ${method}` } });
+  }
+});
+rl.on('close', () => {
+  if (pendingCalls === 0) process.exit(0);
+  stdinClosed = true; // 在途调用完成后自行退出（见 tools/call 的 finally）
+});

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": [
+    "闲置资产",
+    "资产闲置",
+    "闲置判定",
+    "闲置统计",
+    "待调拨",
+    "待调剂",
+    "待评估",
+    "闲置时长",
+    "置信度",
+    "处置建议",
+    "资管家闲置"
   ]
-}
+}