weaver-work-cli 0.1.32 → 0.1.36

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] || {};

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;
+}