weaver-work-cli 0.1.32 → 0.1.33

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

@@ -0,0 +1,448 @@
+/**
+ * `aigroup` 规则库：把「ai二次分组」的个性化规则从代码挪到 JSON（2026-10-28 用户定稿）。
+ *
+ * 目录与文件：
+ *  - `<skill>/aigroup/default.json`      —— 系统默认规则（随 skill 发布，**不允许被覆盖**）
+ *  - `<state>/aigroup/user-intents.json` —— 用户意图规则（会话里由模型生成、CLI 校验落盘，整条覆盖）
+ *    刻意放 CLI 状态目录而不是 skill 目录：本机产生的意图不能跟着 skill 被打包/安装到别人机器上。
+ *
+ * 本模块只负责**读、校验、匹配、条件求值**，不负责分组算法本身；
+ * 门槛 / 子组解散 / 漏分平铺 / 排序编号 / 错误码仍固定在代码里（全局规则，不进 JSON）。
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { stateRoot } from '../../../../core/state.js';
+import { cacheRoots } 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';
+/** 十种算子（2026-10-28 用户定稿；`介于` 左闭右闭）。 */
+export const FOCUS_OPERATORS = [
+    '等于', '不等于', '是', '不是', '大于', '小于', '小于等于', '大于等于', '介于', '包含',
+];
+/** `groupingPrompt` 会原样进模型上下文，限长避免把规则文件当提示词工程仓库。 */
+const MAX_GROUPING_PROMPT_CHARS = 500;
+const EMPTY_GROUP_RULE = { focus: false };
+export const FALLBACK_DEFAULTS = {
+    weight: 999,
+    needSummary: true,
+    requestSummaryPrompt: '',
+    summaryMaxChars: 150,
+    groupSummaryMaxChars: 100,
+    groupSummaryTail: '可展开逐条查看或直接汇总处理',
+};
+export function emptyRuleFile(error = null) {
+    return {
+        file: { schemaVersion: 2, defaults: FALLBACK_DEFAULTS, rules: [] },
+        error,
+    };
+}
+function asStringArray(value) {
+    if (typeof value === 'string')
+        return [value];
+    if (!Array.isArray(value))
+        return null;
+    const items = value.map((item) => String(item ?? '').trim()).filter((item) => item !== '');
+    return items.length > 0 ? items : null;
+}
+function isOperator(value) {
+    return typeof value === 'string' && FOCUS_OPERATORS.includes(value);
+}
+/** 校验一条 focusKeyword；不合法返回原因字符串。 */
+function validateFocusKeyword(raw, index) {
+    if (!Array.isArray(raw))
+        return `focusKeyword[${index}] 必须是数组`;
+    const [metric, op] = raw;
+    if (typeof metric !== 'string' || !metric.trim())
+        return `focusKeyword[${index}] 的指标名必须是非空字符串`;
+    if (!isOperator(op))
+        return `focusKeyword[${index}] 的算子「${String(op)}」不支持（可用：${FOCUS_OPERATORS.join('/')}）`;
+    if (op === '介于') {
+        if (raw.length !== 4)
+            return `focusKeyword[${index}] 用「介于」时必须给 [指标, 介于, 下界, 上界]`;
+        return null;
+    }
+    if (raw.length !== 3)
+        return `focusKeyword[${index}] 必须是 [指标, 算子, 值] 三元组`;
+    return null;
+}
+/** 校验整份规则文件；返回错误列表（空数组 = 合法）。 */
+export function validateRuleFile(raw) {
+    const errors = [];
+    const file = raw;
+    if (!file || typeof file !== 'object')
+        return ['规则文件必须是 JSON 对象'];
+    if (!Array.isArray(file.rules)) {
+        errors.push('rules 必须是数组');
+        return errors;
+    }
+    const seen = new Set();
+    file.rules.forEach((rule, index) => {
+        if (!rule || typeof rule !== 'object') {
+            errors.push(`rules[${index}] 必须是对象`);
+            return;
+        }
+        const names = asStringArray(rule.workflowName);
+        if (!names) {
+            errors.push(`rules[${index}].workflowName 必须是非空字符串或非空数组`);
+            return;
+        }
+        for (const name of names) {
+            if (seen.has(name))
+                errors.push(`workflowName「${name}」在 rules[${index}] 重复出现`);
+            seen.add(name);
+        }
+        if (rule.weight !== undefined && (typeof rule.weight !== 'number' || !Number.isFinite(rule.weight))) {
+            errors.push(`rules[${index}].weight 必须是数字`);
+        }
+        if (rule.summaryMaxChars !== undefined && (typeof rule.summaryMaxChars !== 'number' || rule.summaryMaxChars <= 0)) {
+            errors.push(`rules[${index}].summaryMaxChars 必须是正数`);
+        }
+        const groupRule = rule.aiGroup?.groupRule;
+        if (groupRule) {
+            if (typeof groupRule.focus !== 'boolean')
+                errors.push(`rules[${index}].aiGroup.groupRule.focus 必须是布尔`);
+            if (groupRule.focus) {
+                const keywords = groupRule.focusKeyword;
+                if (!Array.isArray(keywords) || keywords.length === 0) {
+                    errors.push(`rules[${index}] focus=true 时必须给 focusKeyword`);
+                }
+                else {
+                    keywords.forEach((keyword, k) => {
+                        const reason = validateFocusKeyword(keyword, k);
+                        if (reason)
+                            errors.push(`rules[${index}].${reason}`);
+                    });
+                }
+            }
+            else if (groupRule.focusKeyword !== undefined && groupRule.focusKeyword.length > 0) {
+                errors.push(`rules[${index}] focus=false 时不应给 focusKeyword`);
+            }
+            if (groupRule.focus === false && !groupRule.aiContext) {
+                errors.push(`rules[${index}] focus=false 时必须给 aiContext（流程标题 / 流程详情）`);
+            }
+            if (groupRule.groupingPrompt !== undefined) {
+                if (groupRule.focus === true) {
+                    errors.push(`rules[${index}] focus=true 时不应给 groupingPrompt（它只作用于 focus=false 的语义分组）`);
+                }
+                else if (typeof groupRule.groupingPrompt !== 'string' || groupRule.groupingPrompt.trim() === '') {
+                    errors.push(`rules[${index}].aiGroup.groupRule.groupingPrompt 必须是非空字符串`);
+                }
+                else if (groupRule.groupingPrompt.length > MAX_GROUPING_PROMPT_CHARS) {
+                    errors.push(`rules[${index}].aiGroup.groupRule.groupingPrompt 超过 ${MAX_GROUPING_PROMPT_CHARS} 字`
+                        + '（它会原样进模型上下文，请精简）');
+                }
+            }
+        }
+        const groupSummary = rule.aiGroup?.groupSummary;
+        if (groupSummary) {
+            if (typeof groupSummary.needAI !== 'boolean')
+                errors.push(`rules[${index}].aiGroup.groupSummary.needAI 必须是布尔`);
+            if (groupSummary.needAI && !groupSummary.prompt)
+                errors.push(`rules[${index}] groupSummary.needAI=true 时必须给 prompt`);
+            if (!groupSummary.needAI && !groupSummary.template)
+                errors.push(`rules[${index}] groupSummary.needAI=false 时必须给 template`);
+        }
+    });
+    return errors;
+}
+/** 读一份规则文件；文件不存在/坏 JSON/结构不合法都退回 `emptyRuleFile(原因)`。 */
+export function loadRuleFile(file) {
+    if (!existsSync(file))
+        return emptyRuleFile(`规则文件不存在：${file}`);
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch (error) {
+        return emptyRuleFile(`规则文件不是合法 JSON：${file}（${error.message}）`);
+    }
+    const errors = validateRuleFile(parsed);
+    if (errors.length > 0)
+        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 跑到别人机器上（既是泄漏，也会污染别人的分组口径）。
+ */
+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);
+}
+/**
+ * 加载并合并规则：默认文件 +（可选）用户意图文件（**同 workflowName 整条覆盖**，系统默认不被覆盖）。
+ * 用户意图文件里的条目按 `workflowName` 粒度替换默认条目，缺字段由 defaults 补。
+ */
+export function loadRules(options = {}) {
+    const dir = options.dir ?? aigroupDir(options.ctx);
+    // 显式 `dir` 时（测试/现场）默认文件与意图文件放一起；否则意图文件只从状态目录读。
+    const userDir = options.dir ?? aigroupUserDir(options.ctx);
+    const warnings = [];
+    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);
+    let intentFile = userIntentFile;
+    if (!options.dir && !existsSync(userIntentFile) && existsSync(legacyIntentFile)) {
+        intentFile = legacyIntentFile;
+        warnings.push(`用户意图仍读自 skill 目录（${legacyIntentFile}）：新位置是 ${userIntentFile}，重新执行 aigroup set 即可迁移`);
+    }
+    const intent = loadRuleFile(intentFile);
+    if (intent.error) {
+        // 用户意图文件缺失是常态（还没产生意图），只在结构坏掉时才告警
+        if (existsSync(intentFile))
+            warnings.push(intent.error);
+    }
+    else {
+        for (const rule of intent.file.rules) {
+            const names = new Set(asStringArray(rule.workflowName) ?? []);
+            const at = rules.findIndex((item) => (asStringArray(item.workflowName) ?? []).some((name) => names.has(name)));
+            if (at >= 0 && (asStringArray(rules[at].workflowName) ?? []).includes('*')) {
+                warnings.push(`用户意图不能覆盖通配条目「*」，已忽略：${[...names].join(',')}`);
+                continue;
+            }
+            if (at >= 0)
+                rules[at] = rule;
+            else
+                rules.push(rule);
+        }
+    }
+    return {
+        file: { schemaVersion: base.file.schemaVersion, defaults: { ...FALLBACK_DEFAULTS, ...base.file.defaults }, rules },
+        warnings,
+        dir,
+    };
+}
+/** 名称匹配：精确（别名全等）优先；否则模糊（包含）按权重升序、同权重按配置顺序。 */
+export function matchRule(rules, workflowName) {
+    const name = String(workflowName ?? '').trim();
+    const aliasesOf = (rule) => asStringArray(rule.workflowName) ?? [];
+    const indexOf = new Map();
+    rules.forEach((rule, index) => indexOf.set(rule, index));
+    if (name) {
+        const exact = rules.filter((rule) => aliasesOf(rule).includes(name));
+        if (exact.length > 0) {
+            const [rule] = exact;
+            return { rule, matchedBy: 'exact', index: indexOf.get(rule) ?? 0 };
+        }
+        const fuzzy = rules.filter((rule) => aliasesOf(rule).some((alias) => alias !== '*' && name.includes(alias)));
+        if (fuzzy.length > 0) {
+            const sorted = [...fuzzy].sort((a, b) => (a.weight ?? FALLBACK_DEFAULTS.weight) - (b.weight ?? FALLBACK_DEFAULTS.weight)
+                || (indexOf.get(a) ?? 0) - (indexOf.get(b) ?? 0));
+            const rule = sorted[0];
+            return { rule, matchedBy: 'fuzzy', index: indexOf.get(rule) ?? 0 };
+        }
+    }
+    const fallback = rules.find((rule) => aliasesOf(rule).includes('*'));
+    if (fallback)
+        return { rule: fallback, matchedBy: 'default', index: indexOf.get(fallback) ?? 0 };
+    return null;
+}
+/** 合并 defaults，得到生效规则。 */
+export function resolveRule(file, workflowName) {
+    const matched = matchRule(file.rules, workflowName);
+    if (!matched)
+        return null;
+    const defaults = { ...FALLBACK_DEFAULTS, ...file.defaults };
+    const raw = matched.rule;
+    const groupSummary = raw.aiGroup?.groupSummary;
+    const groupRule = raw.aiGroup?.groupRule;
+    return {
+        matchedBy: matched.matchedBy,
+        rule: {
+            workflowName: asStringArray(raw.workflowName) ?? [],
+            weight: raw.weight ?? defaults.weight,
+            needSummary: raw.needSummary ?? defaults.needSummary,
+            requestSummaryPrompt: raw.requestSummaryPrompt ?? defaults.requestSummaryPrompt,
+            summaryMaxChars: raw.summaryMaxChars ?? defaults.summaryMaxChars,
+            groupSummaryMaxChars: defaults.groupSummaryMaxChars,
+            groupSummaryTail: defaults.groupSummaryTail,
+            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,
+                }
+                : null,
+            ruleIndex: matched.index,
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// focusKeyword 求值
+// ---------------------------------------------------------------------------
+/** 日期口径：只比到「日」，用本地时区（`2026-10-28`）。 */
+export function dateOnly(value) {
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${value.getFullYear()}-${pad(value.getMonth() + 1)}-${pad(value.getDate())}`;
+}
+const RELATIVE_DAYS = { 今天: 0, 昨天: -1, 明天: 1 };
+/** 把「今天/昨天/明天」或 `2026-10-28 …` 归一成 `YYYY-MM-DD`；不是日期返回 null。 */
+export function normalizeDateLike(value, now = new Date()) {
+    const text = value.trim();
+    if (text in RELATIVE_DAYS) {
+        const date = new Date(now.getTime());
+        date.setDate(date.getDate() + RELATIVE_DAYS[text]);
+        return dateOnly(date);
+    }
+    const matched = /^(\d{4})[-/](\d{1,2})[-/](\d{1,2})/u.exec(text);
+    if (!matched)
+        return null;
+    const [, y, m, d] = matched;
+    return `${y}-${String(m).padStart(2, '0')}-${String(d).padStart(2, '0')}`;
+}
+function toNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    const text = String(value ?? '').replace(/[,¥￥\s]/gu, '');
+    if (!text)
+        return null;
+    const parsed = Number(text);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function comparableOf(value, now) {
+    if (value === null || value === undefined || value === '')
+        return null;
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? { kind: 'number', value } : null;
+    const text = String(value).trim();
+    if (!text)
+        return null;
+    const date = normalizeDateLike(text, now);
+    if (date)
+        return { kind: 'date', value: date };
+    const num = toNumber(text);
+    // 纯数字优先按数值比，避免「100」被当文本做字典序
+    if (num !== null && /^[¥￥]?\s*-?\d[\d,]*(?:\.\d+)?$/.test(text.replace(/\s/gu, ''))) {
+        return { kind: 'number', value: num };
+    }
+    return { kind: 'text', value: text };
+}
+function compare(a, b) {
+    if (a.kind === 'number' && b.kind === 'number')
+        return a.value - b.value;
+    if (a.kind === 'date' && b.kind === 'date')
+        return a.value < b.value ? -1 : a.value > b.value ? 1 : 0;
+    if (a.kind === 'text' || b.kind === 'text') {
+        const left = String(a.value);
+        const right = String(b.value);
+        return left < right ? -1 : left > right ? 1 : 0;
+    }
+    return null;
+}
+/**
+ * 单个条件求值。**取不到值（null/undefined/空串）一律判为不命中**（2026-10-28 用户定稿：不猜）。
+ */
+export function evaluateCondition(condition, actual, now = new Date()) {
+    const [metric, op, expected, upper] = condition;
+    const left = comparableOf(actual, now);
+    if (!left)
+        return false;
+    const right = comparableOf(expected, now);
+    if (!right)
+        return false;
+    switch (op) {
+        case '等于':
+        case '是':
+            return compare(left, right) === 0;
+        case '不等于':
+        case '不是':
+            return compare(left, right) !== 0;
+        case '大于': {
+            const diff = compare(left, right);
+            return diff !== null && diff > 0;
+        }
+        case '小于': {
+            const diff = compare(left, right);
+            return diff !== null && diff < 0;
+        }
+        case '大于等于': {
+            const diff = compare(left, right);
+            return diff !== null && diff >= 0;
+        }
+        case '小于等于': {
+            const diff = compare(left, right);
+            return diff !== null && diff <= 0;
+        }
+        case '介于': {
+            const top = comparableOf(upper, now);
+            if (!top)
+                return false;
+            const low = compare(left, right);
+            const high = compare(left, top);
+            return low !== null && high !== null && low >= 0 && high <= 0;
+        }
+        case '包含':
+            return String(left.value).includes(String(right.value));
+        default:
+            return false;
+    }
+}
+/**
+ * 一条规则的全部条件（AND）。任一条件取不到值即不命中。
+ * `resolve` 由调用方提供：sysArg=true 从列表条目属性取，false 从流程详情字段取。
+ */
+export function evaluateFocusKeywords(conditions, resolve, now = new Date()) {
+    if (conditions.length === 0)
+        return false;
+    return conditions.every((condition) => evaluateCondition(condition, resolve(condition[0]), now));
+}
+// ---------------------------------------------------------------------------
+// 进程内生效规则（一次 operation 只加载一次；纯读，不缓存到磁盘）
+// ---------------------------------------------------------------------------
+let activeFile = null;
+let activeDir = null;
+/** 加载并激活规则（每个 operation 开头调一次）。返回加载告警，由调用方并入 warnings。 */
+export function primeRules(ctx) {
+    const loaded = loadRules({ ctx });
+    activeFile = loaded.file;
+    activeDir = loaded.dir;
+    return loaded;
+}
+/** 当前生效的规则文件（未 prime 时按默认目录懒加载）。 */
+export function activeRules() {
+    if (!activeFile) {
+        const loaded = loadRules();
+        activeFile = loaded.file;
+        activeDir = loaded.dir;
+    }
+    return activeFile;
+}
+/** 当前规则目录（测试/诊断用）。 */
+export function activeRulesDir() {
+    return activeDir;
+}
+/** 某工作流名对应的生效规则（找不到返回 null）。 */
+export function activeRuleFor(workflowName) {
+    const name = String(workflowName ?? '').trim();
+    if (!name)
+        return null;
+    return resolveRule(activeRules(), name)?.rule ?? null;
+}
+/** 清空进程内缓存（单测用）。 */
+export function resetActiveRules() {
+    activeFile = null;
+    activeDir = null;
+}

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

@@ -0,0 +1,106 @@
+/**
+ * 用户意图规则库（`aigroup/user-intents.json`，落在 **CLI 状态目录**，不写进 skill 目录）的读写。
+ *
+ * 为什么需要 CLI 入口：意图是模型用自然语言理解出来的，但**落盘必须结构化**。
+ * 让模型直接写文件，一旦字段拼错（`focus: true` 却没给 `focusKeyword`、`workflowName` 用了 `*`），
+ * 后续整轮分组都会走错分支且很难定位；所以由 CLI 统一做「校验 → 按 workflowName 整条覆盖 → 落盘」。
+ *
+ * 覆盖规则（2026-10-28 用户定）：
+ *  - 同一 `workflowName` **整条覆盖**（不是字段合并），缺的字段由 `default.json` 的 defaults 补；
+ *  - **不允许覆盖通配条目 `*`**（系统默认的兜底规则不可被意图改掉）；
+ *  - 系统默认文件 `default.json` 永远只读。
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { workflowValidationError } from '../../errors.js';
+import { aigroupUserDir, emptyRuleFile, loadRuleFile, validateRuleFile, USER_INTENT_RULE_FILE, } from './aigroupRules.js';
+/** 把入参归一成规则条目数组：允许单条、数组、或 `{ rules: [...] }`。 */
+export function normalizeIntentPayload(payload) {
+    if (Array.isArray(payload))
+        return payload;
+    if (payload && typeof payload === 'object') {
+        const record = payload;
+        if (Array.isArray(record.rules))
+            return record.rules;
+        if (record.workflowName !== undefined)
+            return [record];
+    }
+    throw workflowValidationError('aigroup_invalid', '入参必须是规则对象、规则数组，或 { rules: [...] }');
+}
+function namesOf(rule) {
+    const raw = rule?.workflowName;
+    if (typeof raw === 'string')
+        return [raw.trim()].filter(Boolean);
+    if (Array.isArray(raw))
+        return raw.map((item) => String(item ?? '').trim()).filter(Boolean);
+    return [];
+}
+/**
+ * 校验并落盘用户意图规则。
+ *
+ * 校验直接复用 `validateRuleFile`（包一层 `{ defaults, rules }`），
+ * 所以「focus=true 必须给 focusKeyword」「focus=false 不给 focusKeyword」「groupSummary 必须二选一」等
+ * 全部与默认文件同一套规则，不会出现两套标准。
+ */
+export function saveUserIntents(payload, options = {}) {
+    const dir = options.dir ?? aigroupUserDir(options.ctx);
+    const warnings = [];
+    const entries = normalizeIntentPayload(payload);
+    if (entries.length === 0)
+        throw workflowValidationError('aigroup_invalid', '入参里没有规则条目');
+    const starred = entries.filter((rule) => namesOf(rule).includes('*'));
+    if (starred.length > 0) {
+        throw workflowValidationError('aigroup_wildcard_unsupported', '用户意图不能使用通配 workflowName「*」：兜底规则由 aigroup/default.json 决定');
+    }
+    const check = validateRuleFile({ schemaVersion: 2, defaults: {}, rules: entries });
+    if (check.length > 0) {
+        throw workflowValidationError('aigroup_invalid', `规则校验失败：${check.join('；')}`);
+    }
+    const file = join(dir, USER_INTENT_RULE_FILE);
+    const existing = existsSync(file) ? loadRuleFile(file) : emptyRuleFile();
+    if (existing.error) {
+        warnings.push(`${existing.error}；本次将重建该文件`);
+    }
+    const byName = new Map();
+    const replaced = [];
+    for (const rule of existing.file.rules) {
+        for (const name of namesOf(rule))
+            byName.set(name, rule);
+    }
+    for (const rule of entries) {
+        const names = namesOf(rule);
+        for (const name of names) {
+            if (byName.has(name))
+                replaced.push(name);
+            byName.set(name, rule);
+        }
+    }
+    // 同一份规则可能有多个别名：按对象去重后落盘
+    const merged = [...new Set(byName.values())];
+    // 用户文件**不写 defaults**：缺省值统一由 default.json 提供，避免两份 defaults 打架
+    const text = `${JSON.stringify({ schemaVersion: 2, rules: merged }, null, 2)}\n`;
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    writeFileSync(file, text, { mode: 0o600 });
+    return { file, saved: entries.length, total: merged.length, replaced: [...new Set(replaced)], warnings };
+}
+/** 读用户意图文件（诊断/展示用）。 */
+export function readUserIntents(options = {}) {
+    const dir = options.dir ?? aigroupUserDir(options.ctx);
+    const file = join(dir, USER_INTENT_RULE_FILE);
+    if (!existsSync(file))
+        return { dir, file, exists: false, error: null, rules: [] };
+    const loaded = loadRuleFile(file);
+    return { dir, file, exists: true, error: loaded.error, rules: loaded.file.rules };
+}
+/** 清空用户意图（只删内容、不删文件，保持目录结构）。 */
+export function clearUserIntents(options = {}) {
+    const dir = options.dir ?? aigroupUserDir(options.ctx);
+    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 });
+    return file;
+}
+/** 读原始文本（测试/排查用，避免被 loadRuleFile 的校验吞掉坏内容）。 */
+export function readRawUserIntents(file) {
+    return readFileSync(file, 'utf8');
+}

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

@@ -329,3 +329,50 @@ export function formatIssueSupportGroupSummary(input) {
     const restText = input.restCount > 0 ? `其余 ${input.restCount} 条按单条展示，` : '';
     return `含 ${input.count} 条已过期或今日到期的问题流程，${creatorText}${restText}${GROUP_SUMMARY_TAIL_TEXT}`;
 }
+/**
+ * 用 JSON 里的模板渲染组摘要（2026-10-28 用户定：文案从 `aigroup/default.json` 的 `template` 读）。
+ *
+ * 支持占位符：`{{count}}` `{{restCount}}` `{{categoryCount}}` `{{categories}}` `{{min}}` `{{max}}`
+ * `{{sum}}` `{{creators}}` `{{tail}}` `{{maxChars}}`。
+ *
+ * 两条防空规则（不产生 `（）` / `发起。` 这类残句）：
+ *  - 没有类别 ⇒ 整段 `（{{categories}}）` 删掉，`{{categoryCount}}` 至少为 1；
+ *  - 没有发起人 ⇒ 整段 `{{creators}}发起。` / `{{creators}}发起，` 删掉。
+ */
+export function renderGroupSummaryTemplate(input) {
+    let text = String(input.template ?? '');
+    if (!text.trim())
+        return '';
+    const allCategories = uniqueTexts(input.categories ?? []);
+    const shownCategories = allCategories.slice(0, 3);
+    const categoryCount = allCategories.length > 0 ? allCategories.length : 1;
+    const categories = shownCategories.length > 0
+        ? `${shownCategories.join('、')}${allCategories.length > shownCategories.length ? '等' : ''}`
+        : '';
+    const allCreators = normalizeCreators(input.creators ?? []);
+    const shownCreators = allCreators.slice(0, 3);
+    const creators = shownCreators.length > 0
+        ? `由${shownCreators.join('、')}${allCreators.length > 2 ? '等' : ''}`
+        : '';
+    if (!creators) {
+        text = text.replace(/\{\{creators\}\}发起[。，]/gu, '');
+    }
+    if (!categories) {
+        text = text.replace(/（\{\{categories\}\}）/gu, '');
+    }
+    const amounts = (input.amounts ?? []).filter((value) => typeof value === 'number' && Number.isFinite(value));
+    const replaced = text
+        .replace(/\{\{count\}\}/gu, String(input.count))
+        .replace(/\{\{restCount\}\}/gu, String(input.restCount ?? 0))
+        .replace(/\{\{categoryCount\}\}/gu, String(categoryCount))
+        .replace(/\{\{categories\}\}/gu, categories)
+        .replace(/\{\{min\}\}/gu, amounts.length > 0 ? formatNumber(Math.min(...amounts)) : '')
+        .replace(/\{\{max\}\}/gu, amounts.length > 0 ? formatNumber(Math.max(...amounts)) : '')
+        .replace(/\{\{sum\}\}/gu, amounts.length > 0
+        ? formatNumber(Number(amounts.reduce((total, value) => total + value, 0).toFixed(2)))
+        : '')
+        .replace(/\{\{creators\}\}/gu, creators)
+        .replace(/\{\{tail\}\}/gu, input.tail);
+    // 空占位没有可填内容时，别把 `¥` / 逗号留在句子里
+    return replaced.replace(/¥（\s*）/gu, '').replace(/\s*，\s*，/gu, '，').trim();
+}