weaver-work-cli 0.1.38 → 0.1.39

package/dist/shortcuts/asset-idle/operations.js

@@ -0,0 +1,15 @@
+import { assetIdleManifest } from './manifest.js';
+import { getAssetIdleOperation } from './operations/registry.js';
+import { assertKnownKeys, assertNoForbiddenKeys, asObject } from './operations/shared.js';
+/** 顶层输入白名单直接取自 manifest：schema 即运行时约束，避免两处规则漂移。 */
+const ALLOWED_KEYS = Object.fromEntries(assetIdleManifest.operations.map((operation) => [
+    operation.name,
+    Object.keys(operation.inputSchema.properties ?? {}),
+]));
+export async function executeAssetIdleOperation(operation, rawInput, context) {
+    const definition = getAssetIdleOperation(operation);
+    const input = asObject(rawInput);
+    assertNoForbiddenKeys(input);
+    assertKnownKeys(input, ALLOWED_KEYS[operation] ?? [], operation);
+    return definition.handler(input, context);
+}

package/dist/shortcuts/index.js

@@ -105,6 +105,11 @@ export const builtinShortcuts = [
         description: 'E10 资产管理（资管家）CLI',
         load: async () => (await import('./asset/index.js')).assetShortcut,
     }),
+    lazyShortcut({
+        name: 'asset-idle',
+        description: 'E10 闲置资产判定结果查询 CLI（分页获取/聚合统计）',
+        load: async () => (await import('./asset-idle/index.js')).assetIdleShortcut,
+    }),
     lazyShortcut({
         name: 'im',
         description: '泛微E10易秒办（即时通讯）CLI',

package/dist/shortcuts/workflow/host.js

@@ -2,6 +2,7 @@ import { E10_SESSION_EXPIRED_MESSAGE } from '../../internal/e10/auth/messages.js
 import { requireE10Session } from '../../internal/e10/context.js';
 import { getActiveProfile } from '../../internal/e10/auth/session.js';
 import { createE10RequestRuntime } from '../../internal/e10/request-runtime.js';
+import { isE10AuthenticationRequired } from '../../internal/e10/auth-recovery.js';
 import { workflowApiError, workflowAuthError, workflowNetworkError } from './errors.js';
 const DEFAULT_TIMEOUT_MS = 30_000;
 /**
@@ -81,6 +82,8 @@ export function isAtustRedirect(status, value) {
 export function isLoginExpired(value, httpStatus) {
     if (httpStatus === 401 || httpStatus === 403)
         return true;
+    if (isE10AuthenticationRequired({ status: httpStatus ?? 200, value }))
+        return true;
     if (isAtustRedirect(httpStatus, value))
         return true;
     const joined = payloadTexts(value).join('\n').toLowerCase();

package/dist/shortcuts/workflow/index.js

@@ -215,7 +215,7 @@ export const workflowShortcut = {
             const user = readUserIntents({ ctx: ctx });
             ctx.output.write({
                 dir: loaded.dir,
-                defaultFile: join(loaded.dir, 'default.json'),
+                defaultFile: loaded.dir ? join(loaded.dir, 'default.json') : null,
                 userIntentFile: user.file,
                 userIntentExists: user.exists,
                 userIntentError: user.error,

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

@@ -34,8 +34,16 @@ import { buildChatSceneInput, formatLocalNow, requestFormFill } from './chatscen
 const TEXTAREA_COMPONENTS = new Set(['textarea', 'richtext', 'editor', 'html', 'htmltext']);
 const SELECT_COMPONENTS = new Set(['select', 'selectmultiple', 'radiobox', 'checkbox', 'radio', 'multiselect']);
 const BROWSER_COMPONENTS = new Set([
-    'employee', 'department', 'subcompany', 'jobtitle', 'job', 'relatebrowser',
-    'browser', 'workflow', 'ebuilder', 'customer', 'project',
+    // 人员 / 组织类
+    'employee', 'department', 'subcompany', 'jobtitle', 'job',
+    'employeeorganization', 'employeeshare', 'employeeauthshare', 'odocreceivecomponent',
+    // 关联类型（设计器「表单组件 / 关联类型」面板）
+    'ebuilder', 'mainline', 'project', 'task', 'document', 'workflow', 'formcomponent',
+    'customer', 'customercomponent', 'cluecomponent', 'ordercomponent', 'contactcomponent',
+    'productioncomponent', 'contractcomponent', 'activitycomponent', 'competitorcomponent',
+    'kpiflowcomponent', 'workreportcomponent', 'attendcomponent', 'agendacomponent', 'chancecomponent',
+    'relatebrowser', 'relateodoc', 'relatetag', 'relateintegrate', 'modulecomponent', 'paas',
+    'quotecomponent', 'drivingrecord', 'browser',
 ]);
 const NON_INPUT_COMPONENTS = new Set([
     'paragraph', 'label', 'divider', 'option', 'detailtable', 'group', 'layout', 'internaltitle', 'multilingualtag',
@@ -593,14 +601,7 @@ function extractFields(layoutData, requiredMap, disableEditMap, displayMap) {
         // （Python 的 `bool({})` 为 False）——直接照抄 Python 的 `bool(browser_type)` 会让**每个字段**
         // 都被判成浏览按钮字段，文本/富文本字段随之走 name→ID 解析并报 BROWSER NOT_FOUND，
         // 内容永远写不进去（2026-09-16「内部留言」留言内容字段实证）。必须判"非空对象"。
-        // 组件名有两种写法：eBuilder 表单里常带 `Component` 后缀（`CustomerComponent` /
-        // `EmployeeComponent`），标准流程表单里是不带的（`customer` / `employee`）。
-        // ⛔ 只认前者会漏判：2026-10-31 会议申请流程的「参会客户」是 `CustomerComponent`，
-        // 被当成普通文本字段 ⇒ 提交 `[{id,name}]` 报「文本字段只接受字符串、数字或布尔值」。
-        const componentBase = normalized.replace(/component$/, '');
-        const isBrowser = Object.keys(browserType).length > 0
-            || BROWSER_COMPONENTS.has(normalized)
-            || BROWSER_COMPONENTS.has(componentBase);
+        const isBrowser = Object.keys(browserType).length > 0 || BROWSER_COMPONENTS.has(normalized);
         const isSelect = SELECT_COMPONENTS.has(normalized) || options.length > 0;
         result.push({
             id: fieldId,
@@ -2147,31 +2148,6 @@ async function buildCreateFormData(workflowId, env, options = {}) {
             continue;
         visibleFields.push(f);
     }
-    /**
-     * 明细表**整表被判不可见**时的显式告警（2026-10-31）。
-     *
-     * 场景：明细表被摆在了页面网格的**隐藏行 / 隐藏列**上（`pageLayouts[0].config.workbook.Sheet1.rows[n].visible=false`），
-     * 于是它的列字段全部被 `hiddenCellIds` 过滤掉。此前是**静默丢弃** —— 模型只看到"表单里没有这张明细表"，
-     * 分不清「表单确实没配」和「配了但摆在隐藏行上」，只能回一句"没有这张表"，用户无从下手。
-     * 这里按 subFormId 汇总，整表字段全灭的才告警（部分列隐藏属正常设计）。
-     */
-    const hiddenBySubform = new Map();
-    for (const f of fields) {
-        const fid = String(f.id ?? '');
-        const sid = String(f.subFormId ?? '').trim();
-        if (!sid || !hiddenCellIds.has(fid))
-            continue;
-        hiddenBySubform.set(sid, (hiddenBySubform.get(sid) || 0) + 1);
-    }
-    const survivingSubforms = new Set(visibleFields.map((f) => String(f.subFormId ?? '').trim()).filter(Boolean));
-    const invisibleSubformWarnings = [];
-    for (const [sid, count] of hiddenBySubform) {
-        if (survivingSubforms.has(sid))
-            continue;
-        invisibleSubformWarnings.push(`明细表 ${sid} 的 ${count} 个字段全部被判为「不可见」（该明细表所在的行/列在表单布局里是隐藏的），`
-            + '因此没有出现在字段清单里。要么在表单设计器里把明细表挪到可见行，要么取消隐藏它所在的行/列，然后重新载入表单。');
-    }
-    let layoutWarning = invisibleSubformWarnings.length ? invisibleSubformWarnings.join('；') : null;
     const defaults = normalizeDefaults(layoutData.defaultDetails);
     // 计算必填/可编辑/明细必填（按默认值 + onLoadForm 联动）
     const systemFieldValues = _normalizeSystemFieldValues(layoutData.businessOperatorObj);
@@ -2236,52 +2212,6 @@ async function buildCreateFormData(workflowId, env, options = {}) {
         }
     }
     const folderOptionValues = _mainValueMap(defaults);
-    /**
-     * 「条件显示」的明细表（2026-10-31，会议申请流程「参会客户明细」实证）
-     *
-     * 表单可以给明细表配**显示联动**：触发字段有值时 `show`、为空时 `hideLine`。
-     * 会议申请流程的「参会客户明细」（subFormId `1332370499762806784`）就是这样 ——
-     * 触发字段是「参会客户」(`crm_members`)，空着时整表隐藏。
-     *
-     * 旧行为把它与「明细表被摆在隐藏行」一视同仁 ⇒ 整表字段从 `fields` 里消失，
-     * 建会链路既解析不到明细表也写不进明细，模型只能回「表单里没有这张表」。
-     * 现在：布局上确实存在、且有成对 `show` 规则的表，按**条件可见**处理 ——
-     * 字段照常下发（标 `conditional: true`），并在 `layoutWarning` 里说明触发字段。
-     */
-    const conditionalHiddenSubforms = new Set();
-    const conditionalMainFields = new Set();
-    const conditionalHints = collectDetailShowLinkages(layoutData.viewLinkages, fields);
-    /**
-     * 主表字段同理：「参会客户」(`crm_members`) 自己也有成对的 `show` / `hideLine` 规则
-     * （空值时连自己都隐藏）。若不这样处理，建会链路的 `crm_members` 永远映射不到字段。
-     */
-    const fieldShowIds = collectFieldShowLinkageIds(layoutData.viewLinkages);
-    for (const fid of Array.from(mainHidden)) {
-        if (!fieldShowIds.has(fid))
-            continue;
-        if (hiddenCellIds.has(fid))
-            continue;
-        const target = visibleFields.find((f) => String(f.id ?? '') === fid);
-        if (!target)
-            continue;
-        conditionalMainFields.add(fid);
-        mainHidden.delete(fid);
-        invisibleSubformWarnings.push(`字段「${target.name}」(${fid}) 因显示联动隐藏（该字段本身是触发字段），已照常下发并标 conditional: true`);
-    }
-    for (const sid of Array.from(hiddenSubforms)) {
-        const hint = conditionalHints.get(sid);
-        if (!hint)
-            continue;
-        const usable = visibleFields.some((f) => String(f.subFormId ?? '') === sid && !hiddenCellIds.has(String(f.id ?? '')));
-        if (!usable)
-            continue;
-        conditionalHiddenSubforms.add(sid);
-        hiddenSubforms.delete(sid);
-        invisibleSubformWarnings.push(`明细表 ${sid}${hint.tableName ? `（${hint.tableName}）` : ''} 因显示联动隐藏，触发字段：`
-            + `${hint.triggerNames.join('、') || hint.triggerIds.join('、')}。`
-            + '该表字段已照常下发（标 conditional: true），把触发字段填上后表单里就会显示；不要回「表单里没有这张明细表」。');
-    }
-    layoutWarning = invisibleSubformWarnings.length ? invisibleSubformWarnings.join('；') : null;
     for (const field of visibleFields) {
         const fieldId = String(field.id ?? '');
         const subFormId = String(field.subFormId ?? '');
@@ -2381,11 +2311,6 @@ async function buildCreateFormData(workflowId, env, options = {}) {
         else if (slimSubFormId) {
             item.subFormId = slimSubFormId;
         }
-        // 条件可见的明细表（见 conditionalHiddenSubforms 注释）：字段可用，但当前触发字段没值时表单里不显示。
-        if (slimSubFormId && conditionalHiddenSubforms.has(slimSubFormId))
-            item.conditional = true;
-        if (!slimSubFormId && conditionalMainFields.has(String(field.id ?? '')))
-            item.conditional = true;
         item.componentKey = field.componentKey;
         // 表单初始化时就有的值（OA 预填 + onLoadForm 联动带出）——有才出现该键；**没有默认值的字段不带**。
         // CLI 拼 `data` 时会自动并入，模型**不必显式传**；用户本次明确改写了它才按用户说的覆盖（见
@@ -2544,8 +2469,6 @@ async function buildCreateFormData(workflowId, env, options = {}) {
             },
             systemFieldWarning: minorWarning,
             requiredInfoWarning: requiredInfoWarningText(context),
-            // 明细表整表不可见时的告警（见 layoutWarning 注释）：有值时**不要**回"表单里没有这张明细表"。
-            layoutWarning,
             // 原 Python 把完整 context 落盘；此处通过 continuation 承载，返回结构保持文档契约。
             continuation: token,
         },
@@ -4047,74 +3970,6 @@ function mergeLinkageDetails(merged, linkageDetails) {
 function emptyLinkageVisibility() {
     return [new Set(), {}, {}, {}];
 }
-/**
- * 收集主表字段的 `show` 联动字段 id（`linkageObj=field` 且 `linkageProp=show`）。
- * 这类字段的隐藏是**条件性**的，按条件可见处理，见 `buildCreateFormData` 的 `conditionalMainFields`。
- */
-export function collectFieldShowLinkageIds(linkages) {
-    const out = new Set();
-    if (!Array.isArray(linkages))
-        return out;
-    for (const rule of linkages) {
-        const details = Array.isArray(rule?.linkageDetails) ? rule.linkageDetails : [];
-        for (const detail of details) {
-            if (!detail || typeof detail !== 'object')
-                continue;
-            if (String(detail.linkageObj ?? '') !== 'field')
-                continue;
-            if (String(detail.linkageProp ?? '') !== 'show')
-                continue;
-            const fid = String(detail.linkageValue ?? '').trim();
-            if (fid)
-                out.add(fid);
-        }
-    }
-    return out;
-}
-/**
- * 收集「明细表的显示联动」——`linkageObj=detail` 且 `linkageProp=show` 的规则。
- *
- * 用途见 `buildCreateFormData` 里 `conditionalHiddenSubforms` 的注释：配了 `show` 规则的明细表
- * 是**条件可见**（另有配套的 `hideLine` 规则），不能因为当期条件不成立就把整表字段丢掉。
- * 返回 `subFormId → { triggerIds, triggerNames, tableName }`，triggerNames 供告警文本直接引用。
- */
-export function collectDetailShowLinkages(linkages, fields) {
-    const out = new Map();
-    if (!Array.isArray(linkages))
-        return out;
-    const list = Array.isArray(fields) ? fields : [];
-    const nameOf = (id) => {
-        for (const f of list) {
-            if (String(f?.id ?? '') === id)
-                return String(f?.name ?? id);
-        }
-        return id;
-    };
-    for (const rule of linkages) {
-        const details = Array.isArray(rule?.linkageDetails) ? rule.linkageDetails : [];
-        for (const detail of details) {
-            if (!detail || typeof detail !== 'object')
-                continue;
-            if (String(detail.linkageObj ?? '') !== 'detail')
-                continue;
-            if (String(detail.linkageProp ?? '') !== 'show')
-                continue;
-            const sid = String(detail.linkageValue ?? '').trim();
-            if (!sid)
-                continue;
-            const conds = Array.isArray(rule?.condition?.conditionDetails) ? rule.condition.conditionDetails : [];
-            const triggerIds = conds
-                .map((c) => String(c?.targetId ?? '').trim())
-                .filter(Boolean);
-            out.set(sid, {
-                triggerIds,
-                triggerNames: triggerIds.map(nameOf),
-                tableName: nameOf(sid) === sid ? '' : nameOf(sid),
-            });
-        }
-    }
-    return out;
-}
 function computeLinkageVisibility(linkages, entries, defaults, linkageDetails, systemFieldValues, fields) {
     const hiddenSubforms = new Set();
     const rowHidden = {};
@@ -4879,8 +4734,19 @@ const XIAOE_FILL_FORM_SDK_OPTIONS = {
  */
 const XIAOE_INITIAL_VALUES_MULTI_SEPARATOR = ',';
 const XIAOE_INITIAL_VALUES_ROW_SEPARATOR = ';';
+/**
+ * 浏览按钮字段的值是**对象 id** 时加的前缀（2026-11-02 用户裁定）。
+ *
+ * 口径：`isBrowser === true` 的字段值来自 `[{id, name}]` 里的 `id`，落进 `customParams` / `src`
+ * 时写成 `##<id>`，让页面能区分「这是记录 id」与「这是用户手打的名称」；而**名称不拼前缀**
+ * （非浏览字段的值本来就是字符串，原样透传）。
+ *
+ * 多值逐个判定，所以 `##<id>,<名称>` 是合法形态（同一字段里既有解析出的 id、又有原样名称）。
+ * 明细多行同口径：`##<id>;<名称>`。
+ */
+const XIAOE_BROWSER_ID_PREFIX = '##';
 /** 单个标量 → URL 传参里的那一段文本。对象按「id 优先」取标识（附件取到的就是 fileid）。 */
-function xiaoEUrlParamScalar(value) {
+function xiaoEUrlParamScalar(value, prefixBrowserId = false) {
     if (value === null || value === undefined)
         return '';
     if (typeof value === 'object') {
@@ -4893,24 +4759,26 @@ function xiaoEUrlParamScalar(value) {
             if (picked === null || picked === undefined)
                 continue;
             const text = String(picked).trim();
-            if (text)
-                return text;
+            if (!text)
+                continue;
+            // 浏览按钮字段：这一段的来源是对象 id（不是用户给的名称），按 2026-11-02 口径加 `##`。
+            return prefixBrowserId ? `${XIAOE_BROWSER_ID_PREFIX}${text}` : text;
         }
         return '';
     }
     return String(value).trim();
 }
 /** 单个字段的值 → URL 传参里的那一段文本（数组按「同字段多值」用 `,` 连接）。 */
-function xiaoEUrlParamValue(value) {
+function xiaoEUrlParamValue(value, prefixBrowserId = false) {
     if (value === null || value === undefined)
         return '';
     if (Array.isArray(value)) {
         return value
-            .map((item) => xiaoEUrlParamScalar(item))
+            .map((item) => xiaoEUrlParamScalar(item, prefixBrowserId))
             .filter(Boolean)
             .join(XIAOE_INITIAL_VALUES_MULTI_SEPARATOR);
     }
-    return xiaoEUrlParamScalar(value);
+    return xiaoEUrlParamScalar(value, prefixBrowserId);
 }
 /**
  * `params.customParams` 里**字段值**那一份 = `{字段id: 值}`（用户裁定用**字段 id**，不用数据 key）；
@@ -4921,6 +4789,10 @@ function xiaoEUrlParamValue(value) {
  *
  * 明细字段（`preview` 里带 `dataIndex`）按**行号升序**取值、用 `;` 连接；主表字段就是它自己的值。
  * 值为空（没解析出内容）的字段整个省略，不生成空参数。
+ *
+ * **浏览按钮字段的值加 `##` 前缀**（2026-11-02 用户裁定，见 `XIAOE_BROWSER_ID_PREFIX`）：这类字段解析
+ * 出来的每一段都是对象 id，写成 `##<id>`；名称（非浏览字段的字符串）原样不加。多值/多行逐个判定，
+ * 因此 `##<id>,<名称>`、`##<id>;<名称>` 都是合法形态。`src` 末尾的字段参数与这里同源，一起带上。
  */
 /**
  * 小e 档交给浏览器页面的字段值：只留**可见且可编辑**的那些（2026-10-21 用户裁定）。
@@ -4963,15 +4835,23 @@ function editablePreviewForXiaoE(preview, fields, visibility) {
     }
     return kept;
 }
-function xiaoECustomParams(preview) {
+function xiaoECustomParams(preview, fields) {
     const ordered = [];
     const mainValues = new Map();
     const detailValues = new Map();
+    // 「这个字段是不是浏览按钮」决定要不要给对象 id 拼 `##`（2026-11-02 用户裁定）——
+    // 判据取 `extractFields` 算好的 `isBrowser`，与值解析走的是同一份结论，不在这里二次推断。
+    const browserFieldIds = new Set();
+    for (const field of toArray(fields)) {
+        const id = String(field?.id ?? '').trim();
+        if (id && field?.isBrowser)
+            browserFieldIds.add(id);
+    }
     for (const item of toArray(preview)) {
         const fieldId = String(item?.fieldId ?? '').trim();
         if (!fieldId)
             continue;
-        const text = xiaoEUrlParamValue(item?.value);
+        const text = xiaoEUrlParamValue(item?.value, browserFieldIds.has(fieldId));
         if (!text)
             continue;
         const isDetail = item?.dataIndex !== undefined && item?.dataIndex !== null;
@@ -5220,12 +5100,7 @@ async function runCreateRequest(args, env, options = {}) {
      * （`buildCreateFormData`，那边的联动结果要用来算字段的必填 / 可编辑清单）；这里两者都不跑 ——
      * 本档既不做必填判定、也不发写请求。非小e 环境行为不变。
      */
-    // ⛔ 2026-10-31 真机回归：调用方可以显式要求「小e 环境也走服务端提交」（meeting 建会直提用）。
-    // 起因：小e 的浏览器填单页只给**文本类**字段赋值，浏览按钮（参会人员 / 参会客户）传过去整段是空 ——
-    // 用户看到的就是"填了但表单里这两个字段没有值"。服务端提交这条路上这些字段走标准 JSON，
-    // 能完整落库，所以建会这类「字段必须完整」的场景应走直提，浏览器填单只留给需要人工核对/补填的场合。
-    const forceServerSubmit = args.forceServerSubmit === true;
-    const isXiaoE = forceServerSubmit ? false : hasXiaoEEnv(env.ctx.env, env.ctx.getGlobalOptions?.());
+    const isXiaoE = hasXiaoEEnv(env.ctx.env, env.ctx.getGlobalOptions?.());
     const linkageDetails = isXiaoE
         ? []
         : await runFieldLinkage(env, linkageContextFromPayload(context), entries, null, merged, false, context.defaults || []);
@@ -5392,7 +5267,7 @@ async function runCreateRequest(args, env, options = {}) {
                 baseUrl: xiaoEBaseUrl,
                 title: String(context.workflow?.name ?? ''),
                 workflowId: String(context.workflow?.id ?? context.runtime?.workflow_id ?? ''),
-                customParams: xiaoECustomParams(fillPreview),
+                customParams: xiaoECustomParams(fillPreview, fields),
             }),
         });
     }

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

@@ -12,7 +12,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { stateRoot } from '../../../../core/state.js';
-import { cacheRoots } from './summaryCache.js';
+import { resolveSkillDir } from './summaryCache.js';
 export const AIGROUP_DIR_NAME = 'aigroup';
 export const DEFAULT_RULE_FILE = 'default.json';
 export const USER_INTENT_RULE_FILE = 'user-intents.json';
@@ -30,6 +30,7 @@ export const FALLBACK_DEFAULTS = {
     summaryMaxChars: 150,
     groupSummaryMaxChars: 100,
     groupSummaryTail: '可展开逐条查看或直接汇总处理',
+    excludeOriginFormDataFields: [],
 };
 export function emptyRuleFile(error = null) {
     return {
@@ -66,16 +67,38 @@ function validateFocusKeyword(raw, index) {
         return `focusKeyword[${index}] 必须是 [指标, 算子, 值] 三元组`;
     return null;
 }
+/** 校验排除字段清单：缺省放行；给了就必须是字符串或字符串数组（允许空数组）。 */
+function validateExcludeFields(raw, where) {
+    if (raw === undefined)
+        return null;
+    if (typeof raw === 'string') {
+        return raw.trim() === '' ? `${where} 不能是空字符串（不排除就别给这个键）` : null;
+    }
+    if (!Array.isArray(raw))
+        return `${where} 必须是字符串数组`;
+    for (const item of raw) {
+        if (typeof item !== 'string' || item.trim() === '')
+            return `${where} 的每一项都必须是非空字符串`;
+    }
+    return null;
+}
 /** 校验整份规则文件；返回错误列表（空数组 = 合法）。 */
 export function validateRuleFile(raw) {
     const errors = [];
     const file = raw;
     if (!file || typeof file !== 'object')
         return ['规则文件必须是 JSON 对象'];
+    // schemaVersion：不能是废字段。给值时必须受支持（2 = aigroup set 写入的意图文件，3 = default.json）；缺省允许（规则级校验兼容）。
+    if (file.schemaVersion !== undefined && file.schemaVersion !== 2 && file.schemaVersion !== 3) {
+        errors.push(`schemaVersion 只支持 2 或 3，收到 ${JSON.stringify(file.schemaVersion ?? null)}`);
+    }
     if (!Array.isArray(file.rules)) {
         errors.push('rules 必须是数组');
         return errors;
     }
+    const defaultsExclude = validateExcludeFields(file.defaults?.excludeOriginFormDataFields, 'defaults.excludeOriginFormDataFields');
+    if (defaultsExclude)
+        errors.push(defaultsExclude);
     const seen = new Set();
     file.rules.forEach((rule, index) => {
         if (!rule || typeof rule !== 'object') {
@@ -98,6 +121,16 @@ export function validateRuleFile(raw) {
         if (rule.summaryMaxChars !== undefined && (typeof rule.summaryMaxChars !== 'number' || rule.summaryMaxChars <= 0)) {
             errors.push(`rules[${index}].summaryMaxChars 必须是正数`);
         }
+        const excludeReason = validateExcludeFields(rule.excludeOriginFormDataFields, `rules[${index}].excludeOriginFormDataFields`);
+        if (excludeReason)
+            errors.push(excludeReason);
+        if (rule.summaryRequiredFields !== undefined) {
+            if (!Array.isArray(rule.summaryRequiredFields) || rule.summaryRequiredFields.length === 0
+                || rule.summaryRequiredFields.some((f) => typeof f !== 'string' || !f.trim() || f.trim().length > 50)
+                || rule.summaryRequiredFields.length > 20) {
+                errors.push(`rules[${index}].summaryRequiredFields 必须是非空字符串数组（1~20 项、每项 1~50 字）`);
+            }
+        }
         const groupRule = rule.aiGroup?.groupRule;
         if (groupRule) {
             if (typeof groupRule.focus !== 'boolean')
@@ -162,47 +195,42 @@ export function loadRuleFile(file) {
         return emptyRuleFile(`规则文件校验失败：${errors.join('；')}`);
     return { file: parsed, error: null };
 }
-/** 默认规则目录（**随 skill 分发、只读**）：`WEAVER_WORK_CLI_AIGROUP_DIR` → skill 目录下的 `aigroup/` → CLI 状态目录。 */
-export function aigroupDir(ctx) {
-    const explicit = process.env.WEAVER_WORK_CLI_AIGROUP_DIR?.trim();
-    if (explicit)
-        return join(explicit);
-    const roots = cacheRoots(ctx);
-    return roots.skillDir ? join(roots.skillDir, AIGROUP_DIR_NAME) : join(stateRoot(ctx), AIGROUP_DIR_NAME);
-}
 /**
- * 用户意图目录（**运行时产物，绝不写进 skill 目录**）：`WEAVER_WORK_CLI_AIGROUP_DIR` → CLI 状态目录。
- *
- * 刻意与 `aigroupDir()` 分开：意图文件是本机产生的，一旦落在 skill 目录里，
- * 打包/安装时会跟着 skill 跑到别人机器上（既是泄漏，也会污染别人的分组口径）。
+ * 当前 skill 的 aigroup 目录（`default.json` 与 `user-intents.json` 同目录；
+ * 2026-11-01 用户定稿：规则与意图都锚定**当前 agent 的 skill 目录**）。
+ * 裸 CLI（无当前 skill 上下文）返回 null ⇒ 规则不加载、意图不可读写。
  */
+export function aigroupDir(ctx) {
+    const skillDir = resolveSkillDir();
+    return skillDir ? join(skillDir, AIGROUP_DIR_NAME) : null;
+}
+/** 用户意图目录：与 `default.json` 同目录（见 `aigroupDir`）。 */
 export function aigroupUserDir(ctx) {
-    const explicit = process.env.WEAVER_WORK_CLI_AIGROUP_DIR?.trim();
-    if (explicit)
-        return join(explicit);
-    return join(stateRoot(ctx), AIGROUP_DIR_NAME);
+    return aigroupDir(ctx);
 }
 /**
  * 加载并合并规则：默认文件 +（可选）用户意图文件（**同 workflowName 整条覆盖**，系统默认不被覆盖）。
  * 用户意图文件里的条目按 `workflowName` 粒度替换默认条目，缺字段由 defaults 补。
+ * 裸 CLI（无当前 skill 上下文）⇒ 按无规则处理 + warning（缓存与规则都拒绝，见 cacheRoots）。
  */
 export function loadRules(options = {}) {
-    const dir = options.dir ?? aigroupDir(options.ctx);
-    // 显式 `dir` 时（测试/现场）默认文件与意图文件放一起；否则意图文件只从状态目录读。
-    const userDir = options.dir ?? aigroupUserDir(options.ctx);
     const warnings = [];
+    const dir = options.dir ?? aigroupDir(options.ctx);
+    if (!dir) {
+        warnings.push('无当前 skill 上下文（WEAVER_WORK_CLI_SKILL_DIR 未设置）：aigroup 规则未加载，按无规则处理');
+        return { file: emptyRuleFile(null).file, warnings, dir: null };
+    }
     const base = loadRuleFile(join(dir, DEFAULT_RULE_FILE));
     if (base.error)
         warnings.push(base.error);
     const rules = [...base.file.rules];
-    // 兼容迁移：意图文件原先写在 skill 目录里，改到状态目录后老文件不会被自动搬走；
-    // 状态目录没有时就回读老位置，避免用户已有的意图「凭空消失」。
-    const userIntentFile = join(userDir, USER_INTENT_RULE_FILE);
-    const legacyIntentFile = join(dir, USER_INTENT_RULE_FILE);
+    // 意图文件与 default.json 同目录；兼容迁移：老位置（CLI 状态目录）若存在且新位置没有 ⇒ 回读 + 提示
+    const userIntentFile = join(dir, USER_INTENT_RULE_FILE);
+    const legacyIntentFile = join(stateRoot(options.ctx), AIGROUP_DIR_NAME, USER_INTENT_RULE_FILE);
     let intentFile = userIntentFile;
     if (!options.dir && !existsSync(userIntentFile) && existsSync(legacyIntentFile)) {
         intentFile = legacyIntentFile;
-        warnings.push(`用户意图仍读自 skill 目录（${legacyIntentFile}）：新位置是 ${userIntentFile}，重新执行 aigroup set 即可迁移`);
+        warnings.push(`用户意图仍读自 CLI 状态目录（${legacyIntentFile}）：新位置是 ${userIntentFile}，重新执行 aigroup set 即可迁移`);
     }
     const intent = loadRuleFile(intentFile);
     if (intent.error) {
@@ -274,13 +302,16 @@ export function resolveRule(file, workflowName) {
             summaryMaxChars: raw.summaryMaxChars ?? defaults.summaryMaxChars,
             groupSummaryMaxChars: defaults.groupSummaryMaxChars,
             groupSummaryTail: defaults.groupSummaryTail,
+            // 显式给 `[]` = 规则级覆盖（清空 defaults 的清单）；未给才落 defaults
+            excludeOriginFormDataFields: raw.excludeOriginFormDataFields === undefined
+                ? defaults.excludeOriginFormDataFields
+                : asStringArray(raw.excludeOriginFormDataFields) ?? [],
             aiGroup: raw.aiGroup
                 ? {
                     groupSummary: {
                         needAI: groupSummary?.needAI ?? false,
                         ...(groupSummary?.prompt === undefined ? {} : { prompt: groupSummary.prompt }),
                         ...(groupSummary?.template === undefined ? {} : { template: groupSummary.template }),
-                        maxChars: defaults.groupSummaryMaxChars,
                         tail: defaults.groupSummaryTail,
                     },
                     groupRule: groupRule ?? EMPTY_GROUP_RULE,
@@ -446,3 +477,23 @@ export function resetActiveRules() {
     activeFile = null;
     activeDir = null;
 }
+// ---------------------------------------------------------------------------
+// formData 排除字段（2026-10-30 用户定稿：excludeOriginFormDataFields）
+// ---------------------------------------------------------------------------
+/**
+ * 当前生效规则的 formData 排除字段清单（空数组 = 不排除）。
+ *
+ * 消费方：`todoDetailFetcher.fetchOneDetail` —— 拿到接口 formData 后按 fieldName 精确匹配剔除；
+ * 详情缓存用 `excludeTagFor()` 做**口径失效**：清单一变，旧缓存条目整体 miss。
+ */
+export function excludeFieldsFor(workflowName) {
+    return activeRuleFor(workflowName)?.excludeOriginFormDataFields ?? [];
+}
+/** 排除清单的特征串（原文拼接）。规则没配 = 空串，与「无口径」条目互相匹配。 */
+export function excludeTagOf(fields) {
+    return [...fields].join('\u0001');
+}
+/** 便捷组合：某流程当前生效的排除口径特征串。 */
+export function excludeTagFor(workflowName) {
+    return excludeTagOf(excludeFieldsFor(workflowName));
+}

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

@@ -44,6 +44,8 @@ function namesOf(rule) {
  */
 export function saveUserIntents(payload, options = {}) {
     const dir = options.dir ?? aigroupUserDir(options.ctx);
+    if (!dir)
+        throw workflowValidationError('aigroup_no_skill_context', '无当前 skill 上下文（WEAVER_WORK_CLI_SKILL_DIR 未设置）：用户意图不可读写');
     const warnings = [];
     const entries = normalizeIntentPayload(payload);
     if (entries.length === 0)
@@ -86,6 +88,8 @@ export function saveUserIntents(payload, options = {}) {
 /** 读用户意图文件（诊断/展示用）。 */
 export function readUserIntents(options = {}) {
     const dir = options.dir ?? aigroupUserDir(options.ctx);
+    if (!dir)
+        return { dir: null, file: '', exists: false, error: '无当前 skill 上下文（WEAVER_WORK_CLI_SKILL_DIR 未设置）', rules: [] };
     const file = join(dir, USER_INTENT_RULE_FILE);
     if (!existsSync(file))
         return { dir, file, exists: false, error: null, rules: [] };
@@ -95,6 +99,8 @@ export function readUserIntents(options = {}) {
 /** 清空用户意图（只删内容、不删文件，保持目录结构）。 */
 export function clearUserIntents(options = {}) {
     const dir = options.dir ?? aigroupUserDir(options.ctx);
+    if (!dir)
+        throw workflowValidationError('aigroup_no_skill_context', '无当前 skill 上下文（WEAVER_WORK_CLI_SKILL_DIR 未设置）：用户意图不可读写');
     const file = join(dir, USER_INTENT_RULE_FILE);
     mkdirSync(dir, { recursive: true, mode: 0o700 });
     writeFileSync(file, `${JSON.stringify({ schemaVersion: 2, rules: [] }, null, 2)}\n`, { mode: 0o600 });