weaver-work-cli 0.1.40 → 0.1.44

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

@@ -15,6 +15,7 @@
  * createApply 合并而来）：模型只需「取表单 → 填字段 → createRequest」，不必自己判断必填是否缺失
  * ——必填判定完全在 CLI 内部按实际所填数据（含联动带出值）实时计算。
  */
+import { CONTINUATION_TTL_MS } from '../../../core/continuation-ttl.js';
 import { randomUUID } from 'node:crypto';
 import { workflowSuccess, schemaOf, SCHEMA_REQUEST_ID, SCHEMA_CONTINUATION, SCHEMA_CONFIRM, } from './types.js';
 import { asBool, responseData, toArray, withLeadingMeta, stdoutBytesOf, stdoutCharsOf, STDOUT_SAFE_BYTES, parseNameWithId, resolveMemoryAppId, } from './shared.js';
@@ -72,7 +73,6 @@ const SYSTEM_FIELD_KEYS = {
 };
 /** 附件大小档位 0-5 对应 1/5/10/20/50/100MB；6/9 取同层 customAttmentSize（已修复 bug）。 */
 const ATTACH_SIZE_LIMIT_STEPS_MB = [1, 5, 10, 20, 50, 100];
-const CONTINUATION_TTL_MS = 10 * 60 * 1000;
 /**
  * 大表单输出保护（通用，不针对任何具体工作流/表单）。
  *
@@ -4720,6 +4720,7 @@ function linkageResultNotice(linkageDetails, fields, hiddenSubforms, rowHidden,
  * - `title` 取**工作流名称**；`src` 与两处 `routerProps_*` 的 `initialEntries` 用**工作流 id**；
  *   `src` 末尾另按 `&<字段id>=<值>` 拼上本次要填的字段（2026-10-30 用户裁定，与下面
  *   `params.customParams` 同一份数据）；
+ *   `src` 里的 `#` **一律写成 `%23`**（2026-11-05 用户裁定，见 `xiaoEEncodeSrcHash`）；
  *   `params.customParams` 取 `createRequest` **入参**经解析后的字段值（不含表单默认值、不含联动带出的值），
  *   同段 `fieldAssignKeys` 列出这次要填的**全部字段 id**（`,` 连接）。
  */
@@ -4761,6 +4762,11 @@ const XIAOE_INITIAL_VALUES_ROW_SEPARATOR = ';';
  * 明细多行同口径：`##<id>;<名称>`。
  */
 const XIAOE_BROWSER_ID_PREFIX = '##';
+/**
+ * 交给浏览器页面时带的自定义标识（`src` 与 `params.customParams` 各带一份，值都是 `1`）：
+ * 页面据此按「带初始值打开新建页」处理。
+ */
+const XIAOE_INITIAL_COVERT_NAME = 1;
 /** 单个标量 → URL 传参里的那一段文本。对象按「id 优先」取标识（附件取到的就是 fileid）。 */
 function xiaoEUrlParamScalar(value, prefixBrowserId = false) {
     if (value === null || value === undefined)
@@ -4904,9 +4910,10 @@ function xiaoECustomParams(preview, fields) {
  * `src` 末尾的字段参数（2026-10-30 用户裁定）：`&<字段id>=<值>`，与 `params.customParams` 里那份
  * 字段值**同一份数据、同一顺序**（`fieldAssignKeys` 是元信息，不进 URL）。
  *
- * 值**原样拼、不做任何百分号编码**：客户端自己解析这段 query（按 `&` 切键值对、再按 `=` 切第一个
- * 等号），中文、空格、`,` / `;` / `#` 等都不需要转义，拼出来的字面值必须与 `params.customParams`
- * 里逐字相同。唯一代价是值本身含 `&` 时会截断——按用户口径以此为准，不在此处兜底改写。
+ * 值在这里**原样拼**（不逐个做百分号编码）：中文、空格、`,` / `;` 等都保持字面值，与
+ * `params.customParams` 里那份一致。**只有 `#` 例外**——整段 `src` 拼完之后统一换成 `%23`
+ * （见下面的 `xiaoEEncodeSrcHash`，2026-11-05 用户裁定）。唯一剩余代价是值本身含 `&` 时会截断
+ * ——按用户口径以此为准，不在此处兜底改写。
  */
 function xiaoESrcFieldQuery(params) {
     let query = '';
@@ -4918,13 +4925,28 @@ function xiaoESrcFieldQuery(params) {
     }
     return query;
 }
+/**
+ * `src` 里的 `#` 一律写成 `%23`（2026-11-05 用户裁定）。
+ *
+ * 原因：`#` 在 URL 里是**片段起始符**，一旦出现在 query 段，浏览器与路由会把 `#` 之后的全部内容
+ * 当成 hash 丢掉 —— 浏览按钮字段的 `##<id>` 前缀（见 `XIAOE_BROWSER_ID_PREFIX`）与用户自己填的
+ * `#` 都会踩这个坑。
+ *
+ * 只作用于 `src` 这一个属性；`params.customParams` 里仍是原样的 `##<id>`（两处不再逐字相同，
+ * 页面解析 `src` 时按 URL 语义还原即可）。
+ */
+function xiaoEEncodeSrcHash(src) {
+    return src.replace(/#/gu, '%23');
+}
 /**
  * 渲染 `<browsertool>` 块（该块**整体**就是小e 环境下 `createRequest` 的 `finalMarkdown`）。
  *
  * 除 `title` / `src` / 两处 `routerProps_*` 的 `initialEntries` / `params.customParams` 外全部写死。
  *
- * `src` 形如 `…/flowpage/create/<workflowId>?workflowId=<workflowId>&isCreate=1&<字段id>=<值>&…`
- * —— 末尾的字段参数与 `params.customParams` 同源（2026-10-30 用户裁定）。
+ * `src` 形如 `…/flowpage/create/<workflowId>?workflowId=<workflowId>&isCreate=1&initialCovertName=1&<字段id>=<值>&…`
+ * —— 末尾的字段参数与 `params.customParams` 同源（2026-10-30 用户裁定）；其中 `#` 全部写成 `%23`
+ * （2026-11-05 用户裁定）。
+ * `initialCovertName=1` 是自定义标识，`params.customParams.initialCovertName: 1` 与之同步（两处都要有）。
  */
 function renderXiaoEFillFormMarkdown(params) {
     const base = String(params.baseUrl ?? '').replace(/\/+$/u, '');
@@ -4937,7 +4959,8 @@ function renderXiaoEFillFormMarkdown(params) {
         arguments: {
             type: 'e10',
             title: String(params.title ?? ''),
-            src: `${base}/sp/workflow${createPath}?workflowId=${workflowId}&isCreate=1${xiaoESrcFieldQuery(params.customParams)}`,
+            // `#` 一律转义成 `%23`（2026-11-05 用户裁定）：`##<id>` 前缀与用户填的 `#` 都会被当成片段起始符。
+            src: xiaoEEncodeSrcHash(`${base}/sp/workflow${createPath}?workflowId=${workflowId}&isCreate=1&initialCovertName=${XIAOE_INITIAL_COVERT_NAME}${xiaoESrcFieldQuery(params.customParams)}`),
             sdkOptions: {
                 compName: XIAOE_FILL_FORM_SDK_OPTIONS.compName,
                 routerType: XIAOE_FILL_FORM_SDK_OPTIONS.routerType,
@@ -4947,9 +4970,10 @@ function renderXiaoEFillFormMarkdown(params) {
                 params_mobile: { ...XIAOE_FILL_FORM_SDK_OPTIONS.params_mobile },
                 params: {
                     customParams: {
-                        // 字段 id → 值（要填写的字段及值），随后是这次要填的**全部字段 id**。
+                        // 字段 id → 值（要填写的字段及值），随后是这次要填的**全部字段 id** 与自定义标识。
                         ...params.customParams.values,
                         fieldAssignKeys: params.customParams.keys.join(','),
+                        initialCovertName: XIAOE_INITIAL_COVERT_NAME,
                     },
                 },
             },

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

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

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

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

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

@@ -5,7 +5,7 @@ import { cacheRoots, readCacheFile, writeCacheFile, SUMMARY_CACHE_PRUNE_INTERVAL
  * 规则（用户 2026-10-26 定稿；条目格式 2026-10-30 升 v2）：
  *  - 键：`requestId__lastFeedBackDateTime`（与该条待办的业务时间绑定——流程一动就换键）；
  *  - 有效期：7 天，与摘要缓存一致；读的时候逻辑过期，超过清理间隔（3 天）时物理剔除；
- *  - **条目带格式版本 `v`**：v2 起素材 = 排除清单过滤后的 formData + 全量 basicInfo；
+ *  - **条目带格式版本 `v`**：v4（2026-11-03）起素材 = 排除清单过滤后的 formData **+ 仅 workflowName**；
  *    旧格式条目（无 `v`）读取时视为无效，被新条目逐步覆盖；排除清单变化靠 `excludeTag` 失效；
  *  - 详情为空的条目**也写**（`fields: []`），否则这类条目每次都要重拉；
  *  - 缓存文件缺失 ⇒ 视为从未缓存过，正常走接口。
@@ -18,29 +18,28 @@ export const DETAIL_CACHE_TTL_MS = SUMMARY_CACHE_TTL_MS;
 /** 与摘要缓存一致：清理间隔 3 天。 */
 export const DETAIL_CACHE_PRUNE_INTERVAL_MS = SUMMARY_CACHE_PRUNE_INTERVAL_MS;
 /**
- * 缓存条目格式版本。v2（2026-10-30）：
- *  - 素材改为「排除清单过滤后的 formData `fieldName:value` + 全量 basicInfo」，
- *    取代旧版「selectSummaryFields 投影 + 8 字段/80 字截断」；
- *  - 新增 `excludeTag`（排除清单原文拼接）——清单一变旧条目整体失效；
- *  - v1 条目（无 `v` 键）读取时直接视为无效并逐步被覆盖。
+ * 缓存条目格式版本。
+ *  - v2（2026-10-30）：素材 = 排除清单过滤后的 formData + 全量 basicInfo，新增 `excludeTag`；
+ *  - v3（2026-11-01）：basicInfo 剔除 `requestTitle` / `flowName`；
+ *  - **v4（2026-11-03，用户定）**：基础信息**只留 `workflowName`**，其余 basic 字段（creatorName /
+ *    createdAt / currentNode / flowStatus / requestLevel …）既不入缓存也不入素材；
+ *    `dv` 相应改为**只对 fields 哈希**。v3 及更早条目读取时视为无效、自动重拉。
  */
-export const DETAIL_CACHE_ENTRY_VERSION = 3;
+export const DETAIL_CACHE_ENTRY_VERSION = 4;
 export function detailCacheKey(requestId, lastFeedBackDateTime) {
     const stamp = String(lastFeedBackDateTime ?? '').trim();
     return `${requestId}__${stamp}`;
 }
 /**
- * 详情素材特征值（2026-11-01 根治「素材升级后旧摘要继续命中」）：对 `basicInfo + fields`
- * 的稳定序列化做 djb2 哈希。任何素材变化——详情管线升级、`excludeOriginFormDataFields`
- * 调整、字段增减——都会让它改变；摘要缓存条目的 `dv` 与之比对即可自动失效重写。
+ * 详情素材特征值 `dv`（2026-11-01 根治「素材升级后旧摘要继续命中」）：对**清洗后的 fields**
+ * 做稳定序列化 + djb2 哈希。任何素材变化——详情管线升级、`excludeOriginFormDataFields` 调整、
+ * 字段增减——都会让它改变；摘要缓存条目的 `dv` 与之比对即可自动失效重写。
+ * （v4 起 basic 只剩 workflowName 且不进素材，故不再参与哈希。）
  */
 export function detailMaterialTagOf(entry) {
-    const basic = entry.basicInfo ?? {};
-    const basicKeys = Object.keys(basic).sort();
-    const material = JSON.stringify([
-        basicKeys.map((key) => [key, basic[key]]),
-        (entry.fields ?? []).map((field) => [field.fieldName, field.value]),
-    ]);
+    // v4 起 basic 只剩 workflowName 且不进素材 ⇒ dv 只对**清洗后的 fields** 哈希；
+    // workflowName 的变化不影响摘要内容，故不参与（改由 pk 侧的口径与分组处理）。
+    const material = JSON.stringify((entry.fields ?? []).map((field) => [field.fieldName, field.value]));
     let hash = 5381;
     for (let i = 0; i < material.length; i += 1)
         hash = ((hash << 5) + hash + material.charCodeAt(i)) >>> 0;
@@ -57,13 +56,7 @@ function normalizeEntry(raw) {
         return null;
     if (typeof value.excludeTag !== 'string')
         return null;
-    const basicInfo = {};
-    if (value.basicInfo && typeof value.basicInfo === 'object') {
-        for (const [key, item] of Object.entries(value.basicInfo)) {
-            if (typeof item === 'string')
-                basicInfo[key] = item;
-        }
-    }
+    const workflowName = typeof value.workflowName === 'string' ? value.workflowName : '';
     const fields = Array.isArray(value.fields)
         ? value.fields
             .filter((item) => Boolean(item) && typeof item.fieldName === 'string'
@@ -73,7 +66,7 @@ function normalizeEntry(raw) {
     const metrics = value.metrics && typeof value.metrics === 'object' ? value.metrics : {};
     return {
         v: DETAIL_CACHE_ENTRY_VERSION,
-        basicInfo,
+        workflowName,
         fields,
         metrics,
         excludeTag: value.excludeTag,

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

@@ -110,6 +110,12 @@ function isRetryable(error) {
         return true;
     return structured?.retryable === true && structured?.type !== 'authentication';
 }
+/** 列表行上的发起人（**只用于内部留言的「发起人」行**，basic 已丢弃后由它兜底）。 */
+function userIdToCreatorName(options, requestId) {
+    const name = options.rowMeta?.get(requestId)?.createrName;
+    const text = String(name ?? '').trim();
+    return text === '' ? undefined : text;
+}
 /**
  * 单条详情取数。后续切换批量接口时，保持本文件对外的批量结果契约即可。
  */
@@ -134,15 +140,14 @@ async function fetchOneDetail(env, requestId, userId, options) {
     const normalized = normalizeDetailResponse(response);
     const base = (normalized?.basicInfo ?? {});
     const rawFields = Array.isArray(normalized?.formData?.fields) ? normalized.formData.fields : [];
-    // ⓪ basicInfo 里**无条件剔除** requestTitle / flowName（2026-11-01 用户定稿：给 AI 的素材与
-    //    本地缓存都不允许出现这两个字段）——标题在素材里出现会诱导模型"按标题写摘要"、
-    //    甚至产出"标题未体现"这类降级话术；标题本身已由列表行（requestNameTitle）承载，素材里不需要。
-    const basicInfo = Object.fromEntries(Object.entries(base).filter(([key]) => key !== 'requestTitle' && key !== 'flowName'));
+    // ⓪ 基础信息**只留 workflowName**（2026-11-03 用户定）：其余 basic 字段丢弃，不进缓存也不进素材。
+    //    `requestTitle` / `flowName` 这类标题字段自然也在丢弃之列。
+    const workflowName = String(base.workflowName ?? '').trim();
     // ① 分发类字段（`主送` …）**无条件丢弃**：值是几十个部门的收件人清单，对摘要零信息量，
     //    还会撑大喂给模型的上下文。必须在排除清单之前丢（技术卫生，用户不可在 JSON 里恢复）。
     const usableFields = dropDistributionDetailFields(rawFields);
     // ② 内部留言类：只保留 留言内容 / 发起人 / 发起时间（其余是分发元数据，见 `detailFieldRules.ts`）。
-    const internalMessage = isInternalMessageDetail(base.workflowName, usableFields.map((field) => field?.fieldName));
+    const internalMessage = isInternalMessageDetail(workflowName, usableFields.map((field) => field?.fieldName));
     // ③ 字段值只清洗（实体解码 / 富文本残留 / 压缩空白），不在这一步截断。
     const cleanedFields = usableFields.map((field) => ({
         ...field,
@@ -150,10 +155,10 @@ async function fetchOneDetail(env, requestId, userId, options) {
     }));
     // ④ 规则排除清单（aigroup JSON `excludeOriginFormDataFields`）：按 fieldName 精确匹配剔除，
     //    两侧都过 `normalizeDetailFieldName`，防【】包裹 / 空白等排版差异绕过精确匹配。
-    const excludeFields = excludeFieldsFor(base.workflowName);
+    const excludeFields = excludeFieldsFor(workflowName);
     const excludeSet = new Set(excludeFields.map((name) => normalizeDetailFieldName(name)));
     const picked = (internalMessage
-        ? pickInternalMessageFieldPairs(cleanedFields, base)
+        ? pickInternalMessageFieldPairs(cleanedFields, {}, userIdToCreatorName(options, requestId))
         : cleanedFields.filter((field) => !excludeSet.has(normalizeDetailFieldName(field?.fieldName))))
         .slice(0, DETAIL_MATERIAL_FIELD_LIMIT)
         .map((field) => ({
@@ -167,7 +172,7 @@ async function fetchOneDetail(env, requestId, userId, options) {
     const metrics = extractRowMetrics(usableFields);
     return {
         requestId,
-        basicInfo,
+        workflowName,
         formFields: picked,
         contextAvailable: picked.length > 0,
         excludeTag: excludeTagOf(excludeFields),
@@ -240,7 +245,7 @@ export async function fetchRequestDetailsBatch(env, requestIds, options = {}) {
                 failures.push({ requestId, error: reason });
                 details.set(requestId, {
                     requestId,
-                    basicInfo: {},
+                    workflowName: '',
                     formFields: [],
                     contextAvailable: false,
                     excludeTag: '',

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

@@ -124,6 +124,46 @@ export async function collectRawTodos(args, env) {
         if (pageRows.length < pageSize)
             break;
     }
+    // ① 详情回填（2026-11-03 用户定：取完列表**紧接着**拉流程详情）
+    //    目的：`getTodoListData.displayData` 可能没有 `workflowName`，缺了分组会整片落到 UNKNOWN_GROUP；
+    //    这里全量拉一遍详情（缓存优先，热缓存 0 请求），列表缺名时用详情 basic 的 workflowName 回填。
+    //    清洗口径照旧（分发字段 / excludeOriginFormDataFields / 200 字段 / 500 字），
+    //    但 basic 只保留 workflowName，其余字段丢弃（见 todoDetailFetcher + todoDetailCache v4）。
+    const workflowNames = new Map();
+    const createrNames = new Map();
+    for (const row of items) {
+        if (!row.requestId)
+            continue;
+        const name = String(row.workflowName ?? '').trim();
+        if (name)
+            workflowNames.set(row.requestId, name);
+        if (row.createrName)
+            createrNames.set(row.requestId, { createrName: row.createrName });
+    }
+    const detailBackfill = { requested: 0, cacheHit: 0, fetched: 0, failed: 0, nameFilled: 0 };
+    let allFacts = new Map();
+    if (items.length > 0) {
+        const detailIds = [...new Set(items.map((row) => row.requestId).filter(Boolean))];
+        const { facts, stats } = await fetchDetailFacts(env, detailIds, args, stampsOfRows(items), workflowNames, createrNames);
+        allFacts = facts;
+        detailBackfill.requested = stats.requested;
+        detailBackfill.cacheHit = stats.cacheHit;
+        detailBackfill.fetched = stats.fetched;
+        detailBackfill.failed = stats.failed;
+        for (const row of items) {
+            const fact = facts.get(row.requestId);
+            if (!fact)
+                continue;
+            if (!String(row.workflowName ?? '').trim() && fact.workflowName) {
+                row.workflowName = fact.workflowName;
+                workflowNames.set(row.requestId, fact.workflowName);
+                detailBackfill.nameFilled += 1;
+            }
+        }
+        if (detailBackfill.nameFilled > 0) {
+            warnings.push(`有 ${detailBackfill.nameFilled} 条列表数据缺少工作流名称，已用流程详情数据（basic.workflowName）回填`);
+        }
+    }
     // 刷新本地查询快照（本地写文件，不联网）：批量写门禁以「最近一次查询结果」为准，
     // 不写会让 todoSmartConvert 取到的 ID 在 workflow.batch* 那里被判成「不在快照里」。
     await saveSearchIndex({
@@ -197,8 +237,9 @@ export async function collectRawTodos(args, env) {
         // 详情是流水线中间数据，smartGroup / summaryContext 需要时现场拉取（带缓存）。
         // 例外：**有意图时**，ai二次分组要先看到表单字段，这里就把素材准备好（见下）。
         detailStats = {
-            deferred: true,
-            note: '详情不预取：smartGroup / summaryContext 会在需要时现场拉取（详情缓存优先）',
+            deferred: false,
+            note: '详情已在 collect 阶段全量回填（缓存优先）：仅 basic.workflowName 保留，其余 basic 字段与素材无关',
+            detailBackfill,
             summaryCached: cachedSummaryIds.size,
             summaryCacheFile: summaryCache.file,
             summaryCachePruned: summaryCache.pruned,
@@ -214,16 +255,17 @@ export async function collectRawTodos(args, env) {
                 .flatMap((group) => group.requestDatas ?? []);
             const targetIds = [...new Set(targetRows.map((row) => row.requestId).filter(Boolean))];
             if (targetIds.length > 0) {
-                const { facts, stats } = await fetchDetailFacts(env, targetIds, args, stampsOfRows(targetRows));
-                for (const [requestId, fact] of facts) {
-                    if (fact.fields.length > 0)
+                // 复用 ① 已回填的 facts（不再二次取数）
+                for (const requestId of targetIds) {
+                    const fact = allFacts.get(requestId);
+                    if (fact && fact.fields.length > 0)
                         fieldsById.set(requestId, fact.fields);
                 }
                 detailStats.groupingMaterial = {
                     requested: targetIds.length,
-                    cacheHit: stats.cacheHit,
-                    fetched: stats.fetched,
-                    failed: stats.failed,
+                    cacheHit: detailBackfill.cacheHit,
+                    fetched: detailBackfill.fetched,
+                    failed: detailBackfill.failed,
                     withFields: fieldsById.size,
                 };
             }

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

@@ -7,7 +7,7 @@ export const UNKNOWN_DATE = '未知日期';
 export const DEFAULT_TOP_N = 10;
 export const STAGE_VALUES = [
     'auto', 'collect', 'group', 'smartGroup',
-    'summaryContext', 'summary', 'groupSummaryContext', 'groupSummary',
+    'summaryContext', 'summary', 'subGroup', 'groupSummaryContext', 'groupSummary',
     'aggregate',
 ];
 export function asRecord(value) {
@@ -137,6 +137,7 @@ export const ALLOWED_INPUT_KEYS = [
     'aiGroupSummaries',
     'withDetailContext',
     'withGroupSummaryContext',
+    'withSubGroup',
     'detailPrefetch',
     'maxCharsPerBatch',
     'maxItemsPerBatch',

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

@@ -3,17 +3,16 @@ import { readBoundedInt } from './todoSmartConvert.core.js';
 import { openDetailCache, DETAIL_CACHE_ENTRY_VERSION } from './todoDetailCache.js';
 import { excludeTagFor } from './aigroupRules.js';
 /**
- * 把「全量 basicInfo + 排除清单过滤后的 formData 字段」拼成喂模型的文本（2026-10-30 用户定稿）。
+ * 把「排除清单过滤后的 formData 字段」拼成喂模型的文本。
  *
- * 每行一条 `fieldName:value`——字段归属一目了然；basicInfo 的键值同样按 `key:value` 逐行放在最前。
+ * 每行一条 `fieldName:value`；2026-11-03 起基础信息（basic）整体丢弃、只有 `workflowName` 保留在
+ * `DetailFact` 上用于分组回填，**不进素材**。
  * 字段来源与截断口径见 `todoDetailFetcher`（排除清单 → ≤200 个字段 → 单值 ≤500 字）。
  */
 export function contextOfDetail(detail) {
-    const basicLines = Object.entries(detail.basicInfo ?? {})
-        .filter(([, value]) => String(value ?? '').trim() !== '')
-        .map(([key, value]) => `${key}:${String(value).trim()}`);
-    const fieldLines = (detail.formFields ?? []).map((field) => `${field.fieldName}:${field.value}`);
-    return [...basicLines, ...fieldLines].join('\n');
+    // 2026-11-03 用户定：流程详情接口返回的 basic 基础信息直接丢弃（只留 workflowName 用于分组回填，
+    // 且不进素材）。因此素材就是清洗后的表单字段，逐行 `fieldName:value`。
+    return (detail.formFields ?? []).map((field) => `${field.fieldName}:${field.value}`).join('\n');
 }
 const EMPTY_DETAIL_STATS = {
     requested: 0,
@@ -57,7 +56,11 @@ function materialFieldsOf(detail) {
  *
  * 失败不致命：返回已拿到的部分 + warning，调用方按「无详情」降级。
  */
-export async function fetchDetailFacts(env, requestIds, args, stamps) {
+export async function fetchDetailFacts(env, requestIds, args, stamps, 
+/** 列表行的 `requestId → workflowName`（详情回填与 excludeTag 校验用） */
+names, 
+/** 列表行的 `requestId → createrName`（内部留言「发起人」行兜底） */
+createrNames) {
     const unique = [...new Set(requestIds.filter(Boolean))];
     const facts = new Map();
     const warnings = [];
@@ -72,15 +75,16 @@ export async function fetchDetailFacts(env, requestIds, args, stamps) {
     const missing = [];
     for (const requestId of unique) {
         const hit = cache.get(requestId, stamps?.get(requestId));
-        if (!hit || hit.excludeTag !== excludeTagFor(hit.basicInfo.workflowName ?? '')) {
+        if (!hit || hit.excludeTag !== excludeTagFor(hit.workflowName ?? names?.get(requestId) ?? '')) {
             missing.push(requestId);
             continue;
         }
         facts.set(requestId, {
-            context: contextOfDetail({ basicInfo: hit.basicInfo, formFields: hit.fields }),
+            context: contextOfDetail({ formFields: hit.fields }),
             contextAvailable: hit.fields.length > 0,
             metrics: hit.metrics,
             fields: hit.fields,
+            workflowName: hit.workflowName || (names?.get(requestId) ?? ''),
         });
         stats.cacheHit += 1;
     }
@@ -91,6 +95,7 @@ export async function fetchDetailFacts(env, requestIds, args, stamps) {
             const { details, stats: fetchStats } = await fetchRequestDetailsBatch(env, missing, {
                 concurrency: readBoundedInt(args.detailConcurrency, 'detailConcurrency', 10, 1, 32),
                 timeoutMs: readBoundedInt(args.detailTimeoutMs, 'detailTimeoutMs', 10_000, 1_000, 60_000),
+                ...(createrNames ? { rowMeta: createrNames } : {}),
             });
             stats.failed = fetchStats.failed;
             stats.concurrency = fetchStats.concurrency;
@@ -100,6 +105,7 @@ export async function fetchDetailFacts(env, requestIds, args, stamps) {
                     contextAvailable: detail.formFields.length > 0,
                     metrics: detail.metrics ?? {},
                     fields: materialFieldsOf(detail),
+                    workflowName: detail.workflowName || (names?.get(requestId) ?? ''),
                 };
                 facts.set(requestId, fact);
                 stats.fetched += 1;
@@ -110,7 +116,7 @@ export async function fetchDetailFacts(env, requestIds, args, stamps) {
                 // 详情为空也写缓存：否则这类条目每次都要重拉
                 if (cache.set(requestId, stamps?.get(requestId), {
                     v: DETAIL_CACHE_ENTRY_VERSION,
-                    basicInfo: detail.basicInfo,
+                    workflowName: fact.workflowName,
                     metrics: fact.metrics,
                     fields: fact.fields,
                     excludeTag: detail.excludeTag,

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

@@ -1,5 +1,4 @@
 import { workflowValidationError } from '../../errors.js';
-import { generalRules } from './aigroupRules.js';
 import { UNKNOWN_GROUP, groupKeyOf, readGroupBy, readItems, readTopN, assertKnownKeys, } from './todoSmartConvert.core.js';
 import { intentAppliesToKind, } from './businessRules.js';
 /** 紧急程度以 requestLevel=2 或显示文本「紧急」为准；1 级是「重要」。 */
@@ -327,16 +326,11 @@ export function runGroup(args) {
     const { rawCount, rows, duplicateCount, unreadableCount } = readItems(args.items);
     const groupBy = readGroupBy(args.groupBy);
     const topN = readTopN(args.topN);
-    // 优先组是叠加视图：筛出的条目**不从**工作流分组剔除，两个视图各自完整。
-    // 2026-11-03：标题与入选规则可在 default.json 的 generalRules.priorityGroup 配置；缺省 = 内置全量规则。
-    const pgConfig = generalRules()?.priorityGroup ?? null;
-    const pgTitle = pgConfig?.title?.trim() || PRIORITY_GROUP_TITLE;
-    const pgRules = new Set(pgConfig?.rules ?? ['overdue', 'levelFallback']);
-    const priority = selectPriorityRows(rows, pgRules);
-    const priorityRows = sortPriorityRows(priority.rows);
-    const restRows = rows;
+    // 2026-11-03 用户定：分组阶段**不再**产出「建议优先处理的流程」——它是最终结构上的一个置顶
+    // 视图，等摘要全部回填后用 `assemblePriorityGroup()` 按同一条规则从成品数据里筛出来。
+    // 这样前期（摘要单位、闸门、统计）都只需处理一份数据，不必到处特判 topPriority。
     const buckets = new Map();
-    for (const row of restRows) {
+    for (const row of rows) {
         const key = groupKeyOf(row, groupBy);
         let bucket = buckets.get(key);
         if (!bucket) {
@@ -364,20 +358,8 @@ export function runGroup(args) {
         stats: statsOf(bucket.rows),
         ...(bucket.ids.length > 1 ? { workflowIds: bucket.ids } : {}),
     }));
-    const groups = priorityRows.length > 0 && groupBy === 'workflow'
-        ? [{
-                id: PRIORITY_GROUP_ID,
-                topPriority: true,
-                title: pgTitle,
-                count: priorityRows.length,
-                requestDatas: priorityRows.map((row) => toRequestData(row)),
-                stats: statsOf(priorityRows),
-            }, ...workflowGroups]
-        : workflowGroups;
-    const displayedWorkflow = workflowGroups.slice(0, topN);
-    const displayed = priorityRows.length > 0 && groupBy === 'workflow'
-        ? [groups[0], ...displayedWorkflow]
-        : displayedWorkflow;
+    const groups = workflowGroups;
+    const displayed = workflowGroups.slice(0, topN);
     const rest = workflowGroups.slice(topN);
     const restCount = rest.reduce((sum, group) => sum + group.count, 0);
     const overall = statsOf(rows);
@@ -394,20 +376,6 @@ export function runGroup(args) {
             ? `有 ${unknownGroupCount} 条缺少工作流名称，已归入「${UNKNOWN_GROUP}」`
             : `有 ${unknownGroupCount} 条缺少分组字段，已归入「${UNKNOWN_GROUP}」`);
     }
-    if (priorityRows.length > 0 && groupBy === 'workflow') {
-        const levelText = priority.targetLevel === 2
-            ? '紧急（requestLevel=2）'
-            : priority.targetLevel === 1
-                ? '重要（requestLevel=1；本次无 2 级数据，已按规则降级取 1，0 级不取）'
-                : '无等级（本次整批没有 ≥1 级的条目，只按超时筛）';
-        warnings.push(`「${pgTitle}」筛出 ${priorityRows.length} 条：超时 ${priority.overdueCount} 条 / ` +
-            `等级命中 ${priority.levelCount} 条（两者都满足 ${priority.bothCount} 条），等级口径=${levelText}；` +
-            `这 ${priorityRows.length} 条同时保留在各自工作流分组中（叠加视图：Σcount 会大于 totalCount，` +
-            `totalCount 按去重条数计 = ${rows.length}）`);
-    }
-    else if (priorityRows.length === 0 && groupBy === 'workflow') {
-        warnings.push(`本次没有超时条目，也没有 requestLevel≥1 的条目，故不输出「${PRIORITY_GROUP_TITLE}」分组`);
-    }
     if (rest.length > 0) {
         warnings.push(`markdown 只展示前 ${topN} 个工作流分组，其余 ${rest.length} 组共 ${restCount} 条仍在 wfIdGroup 中（未截断）`);
     }
@@ -442,7 +410,7 @@ export function runGroup(args) {
         },
         wfIdGroup: groups,
         /** 第二部分（非优先组）的总条数与组数，前端折叠/分页直接用它，不用自己减 */
-        restTotal: restRows.length,
+        restTotal: rows.length,
         restGroupCount: workflowGroups.length,
         restGroups: rest.length > 0 ? { groupCount: rest.length, count: restCount } : null,
         warnings,

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

@@ -69,8 +69,9 @@ export function collectGroupSummaryBatches(groups, isCtxEmpty, maxCharsFor = ()
             continue;
         const kind = detectBusinessKind(group.title);
         for (const sub of groupItemsOf(group)) {
-            // CLI 已经写好固定文案 ⇒ 不需要模型再写一遍
-            if (isDeterministicGroupKind(kind) && (sub.summary ?? '').trim() !== '')
+            // 已有摘要就不产批次：①CLI 固定文案（needAI:false）；②模型随 aiGroups 一起给的
+            // 子组摘要（2026-11-03 合并交互）——两者都不需要再问一次模型。
+            if ((sub.summary ?? '').trim() !== '')
                 continue;
             const allRows = Array.isArray(sub.requestDatas) ? sub.requestDatas : [];
             const rows = isCtxEmpty ? allRows.filter((row) => !isCtxEmpty(row.requestId)) : allRows;