weaver-work-cli 0.1.32 → 0.1.33

package/dist/shortcuts/meeting/operations/standard-guard.js

@@ -0,0 +1,71 @@
+import { MeetingCliError } from '../errors.js';
+import { readCache } from './env.js';
+/**
+ * 标准版会议 operation → 对应的 EB operation。
+ *
+ * ⛔ 存在的理由（2026-10-29 真机事故）：e-cology 这类租户**同时装了标准会议应用和 EB 会议应用**，
+ * 两套数据完全不通（标准版 `meeting.room.list` 返回 74 间「317/342/442会议室」，
+ * EB 的 `uf_mt_room_base` 只有 1 间「测试会议室1」）。agent 在 EB 环境误调标准版接口时，
+ * 接口**不会报错、照常返回数据**，于是把根本不存在的会议室/会议摆到用户面前，用户还以为数据错了。
+ *
+ * 所以这里做一道闸：**环境已确认是 EB 时，标准版会议接口直接拒绝**，并给出对应的 EB operation。
+ * 只拦"会议域且语义对得上"的 operation —— 其余的（登录、附件、二维码等）不涉及双套数据，放行。
+ */
+const STANDARD_TO_EB = {
+    'meeting.list': 'meeting.eb.meeting.list',
+    'meeting.detail.field': 'meeting.eb.meeting.detail',
+    'meeting.room.list': 'meeting.eb.room.list',
+    'meeting.room.usage': 'meeting.eb.roomUsage.list',
+    'meeting.type.list': 'meeting.eb.type.list',
+    'meeting.receipt.list': 'meeting.eb.receipt.list',
+    'meeting.sign.list': 'meeting.eb.sign.list',
+    'meeting.conflict.room': 'meeting.eb.conflict.room',
+    'meeting.conflict.member': 'meeting.eb.conflict.member',
+    'meeting.roomAttribute.list': 'meeting.eb.room.list',
+};
+/** 逃生开关：确认要看标准版数据时设 `WEAVER_MEETING_ALLOW_STANDARD_IN_EB=1`。 */
+function escapeEnabled() {
+    const flag = String(process.env.WEAVER_MEETING_ALLOW_STANDARD_IN_EB ?? '').trim().toLowerCase();
+    return flag === '1' || flag === 'true';
+}
+/**
+ * 标准版会议 operation 的环境守卫。
+ *
+ * 判据只用**已确认的**环境结论（env-mode 缓存）：
+ * - 缓存说 `eb` → 拒绝（本次事故场景）；
+ * - 缓存说 `standard` → 放行（这正是降级后的正常状态）；
+ * - **没有缓存 → 放行**。未探测不等于 EB：标准版租户首次使用不该被拦，
+ *   拦住反而会让"第一次就能用"的体验断掉。要纠偏就跑 `meeting.env.detect --refresh`。
+ */
+export async function assertStandardOperationAllowed(operation, context) {
+    const peer = STANDARD_TO_EB[operation];
+    if (!peer)
+        return;
+    if (escapeEnabled())
+        return;
+    let mode;
+    try {
+        const session = await context.host.getSession();
+        const cache = await readCache(context.ctx);
+        mode = cache.environments[session.baseUrl]?.mode;
+    }
+    catch {
+        // 缓存读不到（权限/损坏）不应阻断业务：按"未确认"处理，放行。
+        return;
+    }
+    if (mode !== 'eb')
+        return;
+    throw new MeetingCliError('api', 'env_mismatch', `当前环境已确认为 **EB 版**，\`${operation}\` 是**标准版**接口，返回的是另一套数据（两套会议数据互不相通，`
+        + '标准版会议室/会议在这里是不存在的东西）。请改用 EB operation **`' + peer + '`**。'
+        + '如果确实要读标准版数据（极少见），设环境变量 `WEAVER_MEETING_ALLOW_STANDARD_IN_EB=1` 后再跑。', {
+        code: 'env_mismatch',
+        details: {
+            requestedOperation: operation,
+            standardOperation: operation,
+            ebOperation: peer,
+            envMode: 'eb',
+        },
+        retryable: false,
+        exitCode: 1,
+    });
+}

package/dist/shortcuts/meeting/operations.js

@@ -3,6 +3,8 @@ import { dirname, join } from 'node:path';
 import { getMeetingOperation } from './operations/registry.js';
 import { assertNoForbiddenKeys, asObject } from './operations/shared.js';
 import { meetingStateDir } from './operations/env.js';
+import { tryDegradeEbFailure } from './operations/eb-fallback.js';
+import { assertStandardOperationAllowed } from './operations/standard-guard.js';
 /**
  * 调用流水（best-effort）：每次 operation 追加一行 JSON 到 `<state>/meeting/logs/calls.jsonl`。
  *
@@ -49,12 +51,26 @@ export async function executeMeetingOperation(operation, rawInput, context) {
     };
     const startedAt = Date.now();
     try {
+        // 环境守卫（2026-10-29）：环境已确认是 EB 时，标准版会议接口直接拒绝 ——
+        // 两套数据不通，标准版照常返回 74 间"不存在的会议室"，agent 会原样转述给用户。
+        await assertStandardOperationAllowed(operation, { ...context, host });
         const envelope = await definition.handler(input, { ...context, host });
         recordCall(context, operation, startedAt, true);
         return envelope;
     }
     catch (error) {
         recordCall(context, operation, startedAt, false, String(error?.type ?? 'unknown'));
+        // EB 优先 + 惰性降级：EB operation 在这个环境走不通时，实探标准版并把 standard 固化进
+        // env 缓存，然后抛 `env_fallback` 指引调用方改用标准版 operation。标准版也不通则保持原错误。
+        try {
+            const degraded = await tryDegradeEbFailure(operation, error, context.host, context.ctx);
+            if (degraded)
+                throw degraded;
+        }
+        catch (rethrow) {
+            if (rethrow !== error)
+                throw rethrow;
+        }
         throw error;
     }
 }

package/dist/shortcuts/workflow/index.js

@@ -6,6 +6,9 @@ import { workflowManifest } from './manifest.js';
 import { executeWorkflowOperation } from './operations.js';
 import { workflowValidationError } from './errors.js';
 import { compactStdoutPaths } from './stdout-compact.js';
+import { join } from 'node:path';
+import { loadRules, resetActiveRules } from './operations/todoSmartConvert/aigroupRules.js';
+import { clearUserIntents, readRawUserIntents, readUserIntents, saveUserIntents, } from './operations/todoSmartConvert/aigroupStore.js';
 function asOptions(value) {
     return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
@@ -114,6 +117,53 @@ async function executeAndPrint(ctx, operation, input) {
         process.exitCode = isCliError(error) ? error.exitCode : ExitCode.GeneralError;
     }
 }
+/**
+ * 目录里的 `fields` 只取 `inputSchema.properties` 的键名，供 agent 判断「这个字段存不存在」。
+ *
+ * ★ 2026-10-28：整份 manifest 实测 65,748 B，超过 stdout 预算（`DEFAULT_RESULT_THRESHOLD_BYTES`
+ * = 24 KB）后，公共输出层按 `COMPACT_TIERS` 第一档把 `operations` 截到 10 条 —— 26 个 operation 里
+ * 排在后面的（`createRequest` 之后，含 `workflow.todoSmartConvert`）在 stdout 上完全不可见，
+ * 且没有任何「还有 16 条」的提示。此处改为默认编目形态（约 15 KB，26 条全可见），
+ * 完整 inputSchema 用 `--operation` 单取，整份完整 manifest 用 `--full`。
+ */
+function fieldNamesOf(inputSchema) {
+    const properties = inputSchema.properties;
+    if (!properties || typeof properties !== 'object' || Array.isArray(properties))
+        return [];
+    return Object.keys(properties);
+}
+function manifestIndex() {
+    return {
+        schemaVersion: workflowManifest.schemaVersion,
+        name: workflowManifest.name,
+        title: workflowManifest.title,
+        version: workflowManifest.version,
+        host: workflowManifest.host,
+        status: workflowManifest.status,
+        sourceSkill: workflowManifest.sourceSkill,
+        capabilities: workflowManifest.capabilities,
+        operationCount: workflowManifest.operations.length,
+        operations: workflowManifest.operations.map((definition) => ({
+            name: definition.name,
+            resource: definition.resource,
+            summary: definition.summary,
+            ...(definition.capability ? { capability: definition.capability } : {}),
+            risk: definition.risk,
+            ...(definition.requiresConfirmation ? { requiresConfirmation: true } : {}),
+            fields: fieldNamesOf(definition.inputSchema),
+        })),
+        withheldOperations: workflowManifest.withheldOperations,
+        operationsHint: '默认只列 operation 与字段名；字段类型、枚举和填写口径用 `workflow schema --operation <name>` 单取，整份完整 manifest 用 `workflow schema --full`。',
+    };
+}
+function findOperationContract(name) {
+    const full = name.startsWith('workflow.') ? name : `workflow.${name}`;
+    const matched = workflowManifest.operations.find((definition) => definition.name === full);
+    if (!matched) {
+        throw workflowValidationError('operation_unknown', `流程模块不支持操作：${name}`);
+    }
+    return matched;
+}
 function withJsonInputOptions(command) {
     command
         .option('--input <path>', 'JSON input file, or - for stdin')
@@ -130,8 +180,67 @@ export const workflowShortcut = {
             .description('泛微E10流程智能助手（待办/已办/我发起/全部、详情、操作、批量、发起、修改）');
         workflow.command('schema')
             .description('Print workflow operation manifest for agents')
+            .option('--operation <name>', 'print one operation with its full inputSchema')
+            .option('--full', 'print the whole manifest (about 65 KB; stdout may be trimmed)')
+            .action(action((ctx, options) => {
+            const opts = asOptions(options);
+            const requested = String(opts.operation ?? '').trim();
+            if (requested && opts.full === true) {
+                throw workflowValidationError('option_conflict', '不能同时传 --operation 和 --full');
+            }
+            if (opts.full === true) {
+                ctx.output.write(workflowManifest, { json: true });
+                return;
+            }
+            if (requested) {
+                ctx.output.write(findOperationContract(requested), { json: true });
+                return;
+            }
+            ctx.output.write(manifestIndex(), { json: true });
+        }));
+        /**
+         * ai二次分组规则库：`<skill>/aigroup/default.json`（系统只读）+ CLI 状态目录下的
+         * `aigroup/user-intents.json`（用户意图，不随 skill 分发）。
+         * 意图由模型理解、但**落盘必须结构化**：这里统一做校验 + 按 workflowName 整条覆盖。
+         */
+        const aigroup = workflow
+            .command('aigroup')
+            .description('ai二次分组规则库（默认规则 + 用户意图）');
+        aigroup.command('show')
+            .description('Print effective ai-group rules (default merged with user intents)')
+            .option('--raw', 'also print user-intents.json as stored on disk')
+            .action(action((ctx, options) => {
+            const opts = asOptions(options);
+            const loaded = loadRules({ ctx: ctx });
+            const user = readUserIntents({ ctx: ctx });
+            ctx.output.write({
+                dir: loaded.dir,
+                defaultFile: join(loaded.dir, 'default.json'),
+                userIntentFile: user.file,
+                userIntentExists: user.exists,
+                userIntentError: user.error,
+                defaults: loaded.file.defaults,
+                rules: loaded.file.rules,
+                userRules: user.rules,
+                warnings: loaded.warnings,
+                ...(opts.raw === true && user.exists ? { rawUserIntents: readRawUserIntents(user.file) } : {}),
+            }, { json: true });
+        }));
+        withJsonInputOptions(aigroup.command('set')
+            .description('Save user-intent rules: validated, whole-entry replace by workflowName')
+            .action(action(async (ctx, options) => {
+            const payload = await inputFrom(options);
+            const result = saveUserIntents(payload, { ctx: ctx });
+            // 同一进程内后续命令要看到新规则，避免读到旧的进程内缓存
+            resetActiveRules();
+            ctx.output.write(result, { json: true });
+        })));
+        aigroup.command('clear')
+            .description('Empty user-intent rules (default.json is never touched)')
             .action(action((ctx) => {
-            ctx.output.write(workflowManifest, { json: true });
+            const file = clearUserIntents({ ctx: ctx });
+            resetActiveRules();
+            ctx.output.write({ cleared: true, file }, { json: true });
         }));
         withJsonInputOptions(workflow.command('run')
             .description('Run a workflow operation with JSON input')

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

@@ -24,7 +24,7 @@ import { resolveSignRemark } from './sign-input.js';
 import { compactStdoutPaths } from '../stdout-compact.js';
 import { continuationReplayError } from '../continuation.js';
 import { writeStateFileBestEffort } from '../state.js';
-import { buildHistoryRequestData, fetchHistoryListSnapshot, filterHistoryRequestData, pickUniqueMineWorkflow } from './read.js';
+import { buildHistoryRequestData, fetchHistoryListSnapshot, filterHistoryRequestData, pickUniqueMineWorkflow, prefetchHistoryDetails } from './read.js';
 import { hasXiaoEEnv } from '../../../internal/e10/auth/xiaoe.js';
 import { buildChatSceneInput, formatLocalNow, requestFormFill } from './chatscene.js';
 // ---------------------------------------------------------------------------
@@ -448,6 +448,12 @@ function parseTenantSetting(data) {
  *   只读字段 35→0）；不带时拿到的才是表单设计级的真实属性。
  */
 function buildLayoutRequest(workflowId, runtime, frame) {
+    // 建模表单（relateType=WEA_EBUILDER）的 `module` 与桥接服务名都不是 workflow：服务端按请求体里的
+    // `module` 解析 `@Service("<module>_FormCoreService")`，传 `workflow` 会直接 500「未找到名为
+    // FormCoreService 的实例对象」（2026-10-29 e-cology 建模流程 1179913136549412865 实测：只把该值
+    // 改成 ebuildercard 即 200，其余 params 逐字不变）。页面同场景传 `module:"ebuildercard"` +
+    // `customParam.bridgeService:"ebuilder"`（`loadBaseParam` 顶层也返回 `bridgeService:"ebuilder"`）。
+    const isEbForm = String(frame.relate_type ?? '').trim() === 'WEA_EBUILDER';
     const custom = {
         permissionType: frame.permission_type,
         requestId: runtime.request_id,
@@ -463,6 +469,7 @@ function buildLayoutRequest(workflowId, runtime, frame) {
         mobile: false,
         formId: frame.form_id,
         source: 'view',
+        ...(isEbForm ? { bridgeService: 'ebuilder' } : {}),
         isAgent: false,
         beAgentId: '0',
         hideSysFieldArea: true,
@@ -478,7 +485,7 @@ function buildLayoutRequest(workflowId, runtime, frame) {
         terminalType: 'PC',
         formId: frame.form_id,
         ...(nodePermissionEnabled && permissionId ? { permissionId } : {}),
-        module: 'workflow',
+        module: isEbForm ? 'ebuildercard' : 'workflow',
         customParam: custom,
         cacheUid: randomUUID(),
         newLayout: frame.new_layout,
@@ -1959,6 +1966,18 @@ async function buildCreateFormData(workflowId, env) {
      * 兜住之后就不会留下未处理的拒绝；真要暴露的认证/网络错误由同批的载入请求抛出，不会被吞掉。
      */
     const historyListSnapshot = fetchHistoryListSnapshot(env, { workflowId }).catch(() => null);
+    /**
+     * 明细请求紧跟着**列表**走（2026-10-29 用户口径）：它的入参只有 `requestId`（列表给的）与会话
+     * `userId`，与 `getFormLayout` **没有任何参数依赖**；原先排在 layout 之后纯属写法问题，白等约
+     * 100 ms。现在列表一返回就发出去，与 layout 并行；**取值后怎么组装一个字没改**（仍在 layout 之后
+     * 用本表单字段清单做，见下方 `buildHistoryRequestData`）。
+     *
+     * `.catch(() => {})`：表单后续可能先抛错（layout 失败等），这条链就没人 `await` 了 —— 先挂一个
+     * 空处理免得留下未处理的拒绝。真正的认证/网络错误仍由 `buildHistoryRequestData` 里那次 `await`
+     * 决定去留（口径不变）。
+     */
+    const historyDetails = historyListSnapshot.then(async (snapshot) => (snapshot && snapshot.requestIds.length ? prefetchHistoryDetails(env, snapshot) : null));
+    historyDetails.catch(() => { });
     // 2026-09-22：这四个接口**彼此没有数据依赖**（入参只需要 workflowId，见各自的 query/body），
     // 真机实测各 171–429 ms、串行合计约 1.1 s；并行后只受最慢的一个约束。
     // `loadMinorInfo` / `tenant/setting` 仍是 best-effort（失败只降级、不阻断），所以各自 catch 成
@@ -2319,7 +2338,9 @@ async function buildCreateFormData(workflowId, env) {
     const historyCache = fields.length
         ? await buildHistoryRequestData(env, fields, historyRequiredFieldIds.map((id) => ({ id, name: String((fieldsById.get(id) || {}).name ?? id) })), { allFormFields: true, workflowId }, 
         // 本命令开头就已并发发起的列表请求：这里只补「详情」那几步（P2）。
-        historyListSnapshot)
+        historyListSnapshot, 
+        // 明细也已在列表返回时就发出去（与 layout 并行），这里只等它回来、按本表单字段组装。
+        historyDetails)
         : null;
     const session = await getSessionContext(env);
     const context = {

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

@@ -1717,9 +1717,9 @@ const workflowSearch = {
 // workflow.search 执行模式路由与最终 Markdown（来源：Python resolve_workflow_search_mode /
 // build_workflow_search_final_markdown / todo_probe_notice）
 // ---------------------------------------------------------------------------
-/** 智能分组基线版本（来源：Python _SMART_GROUPING_MIN_OA_VERSION） */
-const SMART_GROUPING_MIN_OA_VERSION = [10, 0, 9909, 1];
-/** 把版本元组格式化为 OA 习惯的四段式（尾两段补零：10.0.9909.01）。错误提示一律由常量派生，避免文案与判定漂移。 */
+/** 智能分组基线版本（来源：Python _SMART_GROUPING_MIN_OA_VERSION；2026-10-29 用户口径下调到 10.0.9807.01） */
+const SMART_GROUPING_MIN_OA_VERSION = [10, 0, 9807, 1];
+/** 把版本元组格式化为 OA 习惯的四段式（尾两段补零：10.0.9807.01）。错误提示一律由常量派生，避免文案与判定漂移。 */
 function formatOaVersion(tuple) {
     const [a, b, c, d] = tuple;
     return `${a}.${b}.${c}.${String(d).padStart(2, '0')}`;
@@ -1833,7 +1833,7 @@ function requireProbeSuccess(probe, label, title) {
 //
 // 来源：Python `execute_grouped_todo_search` / `normalize_todo_group_list` /
 // `combine_todo_group_results` / `build_grouped_todo_summary_markdown`
-// （V11.2 查询逻辑，V11.3 由 legacy 分支沿用）。恢复版本门槛后（阈值 10.0.9909.01），
+// （V11.2 查询逻辑，V11.3 由 legacy 分支沿用）。恢复版本门槛后（阈值 10.0.9807.01），
 // 低版本 OA 环境将长期走这条分支，故必须与 V11.3 对齐。
 //
 // 未移植项（有意为之）：V11.3 的 `frequentPreference` / `batchSuggestions` 两路依赖
@@ -5153,6 +5153,33 @@ function formatHistoryFieldValue(raw, field) {
     }
     return stringifyDetailValue(raw);
 }
+/**
+ * SaaS 公有云正式环境域名（2026-10-29 用户口径）。
+ *
+ * 只有这个环境下，历史取数要在 `getMineListData` 的 `params` 里**写死**带上
+ * `disableCheckUserPermission: '1'`（放开用户权限校验）；其余环境不带该键，行为与之前完全一致。
+ */
+const SAAS_COLOGY_BASE_URL = 'https://www.e-cology.com.cn';
+/** 比 baseUrl 时容忍末尾斜杠与大小写差异（`E10AuthSession.getBaseUrl()` 已去掉末尾斜杠）。 */
+function isSaasCologyBaseUrl(baseUrl) {
+    const normalize = (value) => String(value ?? '').trim().replace(/\/+$/u, '').toLowerCase();
+    return normalize(baseUrl) === SAAS_COLOGY_BASE_URL;
+}
+/**
+ * 当前环境是否 SaaS 公有云（`https://www.e-cology.com.cn`）。
+ *
+ * 取不到会话时按"非 SaaS"处理并返回 `false`：这里只是决定要不要多加一个参数，真正的认证错误
+ * 由紧随其后的列表请求自己抛出，不在这一步抢先报错。
+ */
+async function isSaasCologyEnv(env) {
+    try {
+        const session = await env.host.getSession();
+        return isSaasCologyBaseUrl(session?.baseUrl);
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * 历史取数的**前半段**：只发那一次列表请求。
  *
@@ -5169,6 +5196,7 @@ export async function fetchHistoryListSnapshot(env, options = {}) {
         const now = new Date();
         const start = new Date(now.getTime() - HISTORY_LOOKBACK_DAYS * 24 * 60 * 60 * 1000);
         const historyWorkflowId = String(options.workflowId ?? '').trim();
+        const addDisableCheckUserPermission = await isSaasCologyEnv(env);
         const listResponse = await env.host.workflowRequest({
             method: 'POST',
             path: WORKFLOW_ENDPOINTS.MINE_LIST,
@@ -5181,6 +5209,8 @@ export async function fetchHistoryListSnapshot(env, options = {}) {
                     flowSpareType: 1,
                     outType: 0,
                     needIutData: false,
+                    // SaaS 公有云环境写死带上（见 `SAAS_COLOGY_BASE_URL`）；其余环境不带此键。
+                    ...(addDisableCheckUserPermission ? { disableCheckUserPermission: '1' } : {}),
                 },
                 // `needParseData: true`：让服务端把日期等字段直接解析成可读文本（`displayData`），
                 // 客户端不再自己转。
@@ -5301,12 +5331,55 @@ export async function pickUniqueMineWorkflow(candidates, env) {
         return null;
     }
 }
+/**
+ * 历史取数的**中间段**：只把「明细」那几次请求发出去（2026-10-29 用户口径）。
+ *
+ * 明细请求（`getWorkflowRequest`）的入参只有 `requestId`（来自列表）+ 会话 `userId` + 四个写死的
+ * 布尔值，路径里也没有 `formId`/`layoutId` —— 与 `getFormLayout` **没有任何参数依赖**。原先它要等
+ * layout 才发，纯粹是因为「发请求」和「按 layout 字段清单组装」写在同一段里。拆出本函数后，调用方
+ * 可以在**列表一返回**就把它挂上去、与 `getFormLayout` 并行，组装逻辑仍按原样在 layout 之后做。
+ *
+ * 不在这里吞异常：认证/网络错误照旧由 `buildHistoryRequestData` 的 catch
+ * （`rethrowAuthOrNetworkError`）决定去留。调用方只做"预取"时，须另行 `.catch(() => {})` 兜住，
+ * 以免表单后续先抛错时留下无人 `await` 的未处理拒绝。
+ */
+export function prefetchHistoryDetails(env, listed) {
+    const requestIds = listed?.requestIds ?? [];
+    if (!requestIds.length)
+        return Promise.resolve([]);
+    return (async () => {
+        const session = await env.host.getSession();
+        return Promise.all(requestIds.map(async (requestId) => {
+            const payload = {
+                requestId,
+                isGetRequestBaseInfo: false,
+                isGetRequestLog: false,
+                isGetFormData: true,
+                isReadRequest: false,
+            };
+            if (session.userId)
+                payload.userId = session.userId;
+            const response = await env.host.workflowRequest({
+                method: 'POST',
+                path: WORKFLOW_ENDPOINTS.REQUEST_DETAIL,
+                operation: 'workflow.createRequest.history.detail',
+                body: payload,
+            });
+            return detailDataOf(response);
+        }));
+    })();
+}
 export async function buildHistoryRequestData(env, fields, targets, options = {}, 
 /**
  * 已提前发起的列表请求（见 `fetchHistoryListSnapshot`）。传入即直接复用，不再重复发请求；
  * 传 `null` / 不传时退回"本函数内自己发列表"的老口径。
  */
-prefetchedList) {
+prefetchedList, 
+/**
+ * 已提前发起的**明细**请求（见 `prefetchHistoryDetails`）。传入即直接复用，不再在这里重发；
+ * 传 `null` / 不传时退回"本函数内自己发"的老口径。组装逻辑与返回值口径与老口径完全一致。
+ */
+prefetchedDetails) {
     const targetList = toArray(targets)
         .filter((item) => !item?.systemField && String(item?.id ?? '').trim())
         .map((item) => ({ id: String(item.id).trim(), name: String(item.name ?? item.id) }));
@@ -5331,24 +5404,32 @@ prefetchedList) {
         const items = listed.items;
         const requestIds = listed.requestIds;
         const session = await env.host.getSession();
-        const details = await Promise.all(requestIds.map(async (requestId) => {
-            const payload = {
-                requestId,
-                isGetRequestBaseInfo: false,
-                isGetRequestLog: false,
-                isGetFormData: true,
-                isReadRequest: false,
-            };
-            if (session.userId)
-                payload.userId = session.userId;
-            const response = await env.host.workflowRequest({
-                method: 'POST',
-                path: WORKFLOW_ENDPOINTS.REQUEST_DETAIL,
-                operation: 'workflow.createRequest.history.detail',
-                body: payload,
-            });
-            return detailDataOf(response);
-        }));
+        // 明细请求可以由调用方提前发（`prefetchHistoryDetails`）—— 那时它的结果已经在飞了，
+        // 这里只等它回来；后续「按本表单字段组装」的口径与老路径逐行相同。
+        const details = prefetchedDetails
+            ? await prefetchedDetails
+            : await Promise.all(requestIds.map(async (requestId) => {
+                const payload = {
+                    requestId,
+                    isGetRequestBaseInfo: false,
+                    isGetRequestLog: false,
+                    isGetFormData: true,
+                    isReadRequest: false,
+                };
+                if (session.userId)
+                    payload.userId = session.userId;
+                const response = await env.host.workflowRequest({
+                    method: 'POST',
+                    path: WORKFLOW_ENDPOINTS.REQUEST_DETAIL,
+                    operation: 'workflow.createRequest.history.detail',
+                    body: payload,
+                });
+                return detailDataOf(response);
+            }));
+        // 预取链在「没有列表结果」时会回 `null`（正常路径走不到这里，因为上面已经 `!listed` 早退）；
+        // 按老口径降级成"没有可参考的历史数据"。
+        if (!details)
+            return null;
         const result = [];
         for (let index = 0; index < details.length; index += 1) {
             const data = details[index] || {};