evolcore 0.0.28 → 0.0.29

package/dist/core/memory/consolidation-trigger.js

@@ -0,0 +1,394 @@
+/**
+ * consolidation-trigger.ts — 整理候选检查（v4，纯函数）
+ *
+ * 职责只有一个：**检查五类候选，返回该拉起哪些整理会话。**
+ *
+ *   ① pending 堆积超过 backlogHours 的关系 → notes 模式（无会话历史，凭 note 内容整理）
+ *   ② 带 to-generalize 的记忆              → generalize 模式
+ *   ③ 带 to-promote 的记忆                 → promote 模式
+ *   ④ 索引有变化且距上次画像超过 profileRegenDays → profile 模式
+ *   ⑤ 有记忆 mtime 超过 forgetAfterDays     → forget 模式
+ *
+ * 判据是**数文件和数标签**，不看轮次和工具调用次数——活干得多不代表写得出记忆，
+ * 只干两轮也可能产出五条要整理的内容。
+ *
+ * v4 变化：不再自己实现定时器（原 setInterval 类已删除）。定时由 evolcore trigger 的
+ * cron `execution.type='script'` 驱动，脚本调 daemon 的 `memory.check-consolidation`，
+ * daemon 侧调用本模块的 `checkConsolidationCandidates()`，结果经 enqueueConsolidation 入队。
+ *
+ * 因此本模块**不持有任何进程内状态**（无 lastTaskEndAt 空闲门控）——所有判据都读磁盘。
+ * 并发安全由 daemon 侧的整理队列保证（同 agent 串行）。
+ */
+import fs from 'fs';
+import path from 'path';
+import { getPackageRoot, resolveRoot } from '../../paths.js';
+import { atomicWriteJson } from '../../utils/atomic-write.js';
+import { normalizeTriggerDefinition } from '../../trigger/validation.js';
+import { DEFAULT_FORGET_AFTER_DAYS, collectCandidates, isDueForReview, deferCandidate, } from './staleness.js';
+import { readMemoryMeta } from './index-manager.js';
+import { getMemoryArray, parseMemoryDocument } from './memory-document.js';
+/**
+ * 走 `_meta.json` 快路径的规模阈值：本机 agent × 关系数超过此值才启用。
+ * 小规模下全量扫描开销可忽略，且无元数据陈旧风险，故作为默认。
+ */
+export const META_INDEX_THRESHOLD = 200;
+const DEFAULT_CRON = '17 * * * *';
+const SCRIPT_NAME = 'consolidation-check.cjs';
+export const CONSOLIDATION_CHECK_TRIGGER_ID = '__memory-consolidation-check';
+/** Register the periodic consolidation candidate check trigger. */
+export function seedConsolidationCheckTrigger(manager, owner, packageRoot = getPackageRoot()) {
+    const now = Date.now();
+    const definition = normalizeTriggerDefinition({
+        $schema_version: 3.1,
+        id: CONSOLIDATION_CHECK_TRIGGER_ID,
+        agentAid: owner.aid,
+        enabled: true,
+        name: CONSOLIDATION_CHECK_TRIGGER_ID,
+        description: 'System trigger: 定期检查记忆整理候选并拉起整理会话。',
+        createdAt: now,
+        updatedAt: now,
+        origin: {
+            channelKey: 'daemon', channelType: 'daemon', channelId: owner.aid, session: 'main',
+            peerId: owner.aid, sessionKey: `daemon#${owner.aid}#__memory-check__`,
+        },
+        source: { type: 'cron', expression: owner.cronExpression ?? DEFAULT_CRON, timezone: owner.timezone ?? 'Asia/Shanghai' },
+        execution: {
+            type: 'script', script: { path: SCRIPT_NAME, runtime: 'node', timeoutMs: 60_000 },
+            permissionMode: 'bypass', onError: 'fail', noopSentinel: '[[NOOP]]',
+        },
+        feedback: { strategy: 'silent' },
+        reliability: { concurrency: 'forbid', missedPolicy: 'run_once', retry: { maxAttempts: 0, backoffMs: 30_000 } },
+    });
+    const dir = manager.triggerDir(definition.id);
+    fs.mkdirSync(dir, { recursive: true });
+    const scriptPath = path.join(dir, SCRIPT_NAME);
+    fs.writeFileSync(scriptPath, buildConsolidationCheckScript(packageRoot, owner.aid));
+    fs.chmodSync(scriptPath, 0o755);
+    atomicWriteJson(manager.definitionPath(definition.id), definition);
+    fs.rmSync(manager.activePath(definition.id), { force: true });
+}
+export function removeConsolidationCheckTrigger(manager) {
+    fs.rmSync(manager.triggerDir(CONSOLIDATION_CHECK_TRIGGER_ID), { recursive: true, force: true });
+}
+function buildConsolidationCheckScript(packageRoot, selfAid) {
+    const ipcEntry = path.join(packageRoot, 'dist', 'ipc.js');
+    const pathsEntry = path.join(packageRoot, 'dist', 'paths.js');
+    return `#!/usr/bin/env node
+const { pathToFileURL } = require('node:url');
+const fs = require('node:fs');
+async function main() {
+  const { ipcQuery } = await import(pathToFileURL(${JSON.stringify(ipcEntry)}).href);
+  const { resolvePaths } = await import(pathToFileURL(${JSON.stringify(pathsEntry)}).href);
+  const paths = resolvePaths();
+  let controlToken;
+  try { controlToken = fs.readFileSync(paths.controlToken, 'utf8').trim(); } catch {}
+  const result = await ipcQuery(paths.socket, {
+    type: 'memory.check-consolidation',
+    selfAid: ${JSON.stringify(selfAid)},
+    ...(controlToken ? { controlToken } : {}),
+  }, 55_000);
+  if (!result) {
+    process.stdout.write(JSON.stringify({ outcome: 'error', text: 'daemon unreachable', files: [] }));
+    process.exitCode = 1;
+    return;
+  }
+  const launched = result.launched ?? [];
+  process.stdout.write(JSON.stringify({ outcome: 'success', text: launched.length > 0 ? '拉起 ' + launched.length + ' 个整理会话: ' + launched.map(l => l.mode).join(', ') : '[[NOOP]]', files: [] }));
+}
+main().catch(error => { process.stdout.write(JSON.stringify({ outcome: 'error', text: String(error && error.message || error), files: [] })); process.exitCode = 1; });
+`;
+}
+const DEFAULT_BACKLOG_HOURS = 24;
+const DEFAULT_PROFILE_REGEN_DAYS = 3;
+function effectiveConfig(config) {
+    const c = config ?? {};
+    return {
+        enableRelation: c.enableRelation ?? true,
+        enableAgent: c.enableAgent ?? true,
+        enableOwner: c.enableOwner ?? true,
+        backlogHours: c.backlogHours ?? DEFAULT_BACKLOG_HOURS,
+        forgetAfterDays: c.forgetAfterDays ?? DEFAULT_FORGET_AFTER_DAYS,
+        profileRegenDays: c.profileRegenDays ?? DEFAULT_PROFILE_REGEN_DAYS,
+    };
+}
+function relationMemoryDir(root, selfAid, peerKey) {
+    return path.join(root, 'agents', selfAid, 'relations', peerKey, 'memory');
+}
+/** pending/ 里最老一条 note 距今多少小时（没有 note 返回 -1）。 */
+function pendingBacklogHours(pendingDir, now) {
+    if (!fs.existsSync(pendingDir))
+        return -1;
+    let oldest;
+    for (const f of fs.readdirSync(pendingDir)) {
+        if (!f.endsWith('.md'))
+            continue;
+        try {
+            const m = fs.statSync(path.join(pendingDir, f)).mtimeMs;
+            if (oldest === undefined || m < oldest)
+                oldest = m;
+        }
+        catch { /* ignore */ }
+    }
+    if (oldest === undefined)
+        return -1;
+    return (now - oldest) / (60 * 60 * 1000);
+}
+/** 扫这些关系的 consolidated/，数带指定标签的文件。 */
+function findTagged(root, selfAid, peerKeys, tag) {
+    let count = 0;
+    for (const peerKey of peerKeys) {
+        const dir = path.join(relationMemoryDir(root, selfAid, peerKey), 'consolidated');
+        if (!fs.existsSync(dir))
+            continue;
+        for (const f of fs.readdirSync(dir)) {
+            if (!f.endsWith('.md'))
+                continue;
+            try {
+                const content = fs.readFileSync(path.join(dir, f), 'utf-8');
+                const tags = getMemoryArray(parseMemoryDocument(content), 'tags');
+                if (tags.includes(tag))
+                    count++;
+            }
+            catch { /* ignore */ }
+        }
+    }
+    return count > 0 ? { count } : null;
+}
+/** 找出对端是 owner 的关系目录名。peerKey 形如 aun#<ownerAid>。 */
+function findOwnerPeerKey(peerKeys, ownerAid) {
+    if (!ownerAid)
+        return null;
+    for (const peerKey of peerKeys) {
+        const peerId = peerKey.includes('#') ? peerKey.slice(peerKey.indexOf('#') + 1) : peerKey;
+        if (peerId === ownerAid)
+            return peerKey;
+    }
+    return null;
+}
+/** 在 consolidated/ 下找第一个带 profile tag 的文件路径。 */
+function findProfileMemoryPath(consolidatedDir) {
+    if (!fs.existsSync(consolidatedDir))
+        return null;
+    for (const f of fs.readdirSync(consolidatedDir)) {
+        if (!f.endsWith('.md'))
+            continue;
+        const fp = path.join(consolidatedDir, f);
+        try {
+            const content = fs.readFileSync(fp, 'utf-8');
+            const tags = getMemoryArray(parseMemoryDocument(content), 'tags');
+            if (tags.includes('profile'))
+                return fp;
+        }
+        catch { /* ignore */ }
+    }
+    return null;
+}
+/** consolidated/ 里有没有记忆。 */
+function hasAnyMemory(memDir) {
+    const dir = path.join(memDir, 'consolidated');
+    if (!fs.existsSync(dir))
+        return false;
+    return fs.readdirSync(dir).some(f => f.endsWith('.md'));
+}
+/** 画像是否该重建：索引 mtime 晚于画像 mtime，且画像超过 profileRegenDays 没更新。 */
+function profileDue(memDir, now, profileRegenDays) {
+    const indexPath = path.join(memDir, 'MEMORY.md');
+    const consolidatedDir = path.join(memDir, 'consolidated');
+    const profilePath = findProfileMemoryPath(consolidatedDir);
+    // 还没有画像：只要 consolidated/ 里已经有记忆，就该建。
+    // 不能要求索引存在 —— 索引是整理会话跑完才生成的，
+    // 而「有记忆但还没整理过」恰恰是最该建画像的时候。
+    if (!profilePath)
+        return hasAnyMemory(memDir);
+    if (!fs.existsSync(indexPath))
+        return false;
+    let indexMtime;
+    try {
+        indexMtime = fs.statSync(indexPath).mtimeMs;
+    }
+    catch {
+        return false;
+    }
+    let profileMtime;
+    try {
+        profileMtime = fs.statSync(profilePath).mtimeMs;
+    }
+    catch {
+        return false;
+    }
+    const days = (now - profileMtime) / (24 * 60 * 60 * 1000);
+    return indexMtime > profileMtime && days >= profileRegenDays;
+}
+/**
+ * 数带指定标签的记忆。
+ *
+ * useMetaIndex=true 时先读各关系的 `_meta.json`：
+ *   - to-generalize / to-promote 直接由布尔字段判定（无需读正文）
+ *   - 元数据缺失 → 该关系回退全量扫描
+ * 返回值只关心「有没有 + 有几条」，元数据只给出布尔，故命中时给个占位计数。
+ */
+function countTagged(root, selfAid, peerKeys, tag, useMetaIndex) {
+    if (!useMetaIndex)
+        return findTagged(root, selfAid, peerKeys, tag);
+    let count = 0;
+    const fallbackPeerKeys = [];
+    for (const peerKey of peerKeys) {
+        const memDir = relationMemoryDir(root, selfAid, peerKey);
+        const meta = readMemoryMeta(memDir);
+        if (!meta) {
+            fallbackPeerKeys.push(peerKey);
+            continue;
+        }
+        if (tag === 'to-generalize' ? meta.hasToGeneralize : meta.hasToPromote)
+            count++;
+    }
+    // 元数据缺失的关系回退全量扫描
+    if (fallbackPeerKeys.length > 0) {
+        const fallback = findTagged(root, selfAid, fallbackPeerKeys, tag);
+        if (fallback)
+            count += fallback.count;
+    }
+    return count > 0 ? { count } : null;
+}
+/**
+ * 画像是否该重建。
+ * useMetaIndex=true 时用 `_meta.json` 的 profileSlug/profileMtimeMs 判定；
+ * 元数据缺失或没有画像记录时回退全量扫描。
+ */
+function profileDueWithMeta(memDir, now, profileRegenDays, useMetaIndex) {
+    if (!useMetaIndex)
+        return profileDue(memDir, now, profileRegenDays);
+    const meta = readMemoryMeta(memDir);
+    if (!meta)
+        return profileDue(memDir, now, profileRegenDays);
+    const indexPath = path.join(memDir, 'MEMORY.md');
+    // 没有画像：只要 consolidated/ 里已经有记忆，就该建。
+    if (meta.profileSlug === null)
+        return meta.count > 0;
+    if (!fs.existsSync(indexPath))
+        return false;
+    let indexMtime;
+    try {
+        indexMtime = fs.statSync(indexPath).mtimeMs;
+    }
+    catch {
+        return false;
+    }
+    const profileMtime = meta.profileMtimeMs ?? 0;
+    const days = (now - profileMtime) / (24 * 60 * 60 * 1000);
+    return indexMtime > profileMtime && days >= profileRegenDays;
+}
+/**
+ * 检查一个作用域的超期记忆，并对**尚未到审查期**的长期记忆做减速。
+ *
+ * 两个时间戳分工：
+ *   mtime     进候选的门票（超 forgetAfterDays）。长期记忆进候选后由这里刷新 mtime，
+ *             于是 forgetAfterDays 内不会再进候选 —— 但 updatedAt 不动。
+ *   updatedAt 真正的审查节拍。普通记忆超 forgetAfterDays、长期记忆超 30 天才该审。
+ *
+ * 注意：本函数有副作用（刷新 mtime + 移动验签失败文件由上游负责）。
+ *
+ * @returns 真正该交给模型审查的条数
+ */
+function checkStale(consolidatedDir, now, forgetAfterDays) {
+    const thresholds = { forgetAfterDays };
+    let due = 0;
+    for (const info of collectCandidates(consolidatedDir, thresholds, now)) {
+        if (isDueForReview(info, thresholds, now)) {
+            due++;
+        }
+        else {
+            try {
+                deferCandidate(info.filePath, now);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    return due;
+}
+/**
+ * 是否该走 `_meta.json` 快路径。
+ * 小规模（agent × 关系数 ≤ 阈值）用全量扫描：实现简单、无陈旧风险。
+ */
+export function shouldUseMetaIndex(agentCount, relationCount) {
+    return agentCount * relationCount > META_INDEX_THRESHOLD;
+}
+/**
+ * 检查五类候选，返回该拉起的整理会话列表。
+ *
+ * 纯检查 + 少量副作用（forget 的长期记忆减速刷新 mtime）。
+ * 调用方负责把结果入队（见 index.ts 的 enqueueConsolidation）。
+ *
+ * 两种扫描路径：
+ *   - useMetaIndex=false（默认）：读每个 .md 全文数标签 / 找画像（全量扫描）
+ *   - useMetaIndex=true：先读 `_meta.json` 汇总；缺失或不符时该作用域回退全量扫描
+ */
+export function checkConsolidationCandidates(params) {
+    const { selfAid, ownerAid } = params;
+    const now = params.now ?? Date.now();
+    const root = params.root ?? resolveRoot();
+    const config = effectiveConfig(params.config);
+    const useMetaIndex = params.useMetaIndex ?? false;
+    const out = [];
+    if (!config.enableRelation)
+        return out;
+    const relationsDir = path.join(root, 'agents', selfAid, 'relations');
+    const peerKeys = fs.existsSync(relationsDir)
+        ? fs.readdirSync(relationsDir, { withFileTypes: true }).filter(d => d.isDirectory()).map(d => d.name)
+        : [];
+    // ① pending 堆积 → notes
+    for (const peerKey of peerKeys) {
+        const pendingDir = path.join(relationsDir, peerKey, 'memory', 'pending');
+        const backlog = pendingBacklogHours(pendingDir, now);
+        if (backlog >= config.backlogHours) {
+            out.push({
+                mode: 'notes',
+                peerKey,
+                reason: `pending 堆积 ${backlog.toFixed(1)}h（>${config.backlogHours}h）`,
+            });
+        }
+    }
+    // ② 待泛化 → generalize（扫所有关系）
+    if (config.enableAgent) {
+        const hit = countTagged(root, selfAid, peerKeys, 'to-generalize', useMetaIndex);
+        if (hit)
+            out.push({ mode: 'generalize', reason: `发现 ${hit.count} 条 to-generalize` });
+    }
+    // ③ 待提升 → promote（只看 owner 关系）
+    if (config.enableOwner && ownerAid) {
+        const ownerPeerKey = findOwnerPeerKey(peerKeys, ownerAid);
+        if (ownerPeerKey) {
+            const hit = countTagged(root, selfAid, [ownerPeerKey], 'to-promote', useMetaIndex);
+            if (hit) {
+                out.push({ mode: 'promote', peerKey: ownerPeerKey, reason: `发现 ${hit.count} 条 to-promote` });
+            }
+        }
+    }
+    // ④ 画像超期 → profile
+    for (const peerKey of peerKeys) {
+        const memDir = relationMemoryDir(root, selfAid, peerKey);
+        if (profileDueWithMeta(memDir, now, config.profileRegenDays, useMetaIndex)) {
+            out.push({ mode: 'profile', peerKey, reason: '索引有变化且画像超期' });
+        }
+    }
+    // ⑤ 超期记忆 → forget（关系级）
+    for (const peerKey of peerKeys) {
+        const dir = path.join(relationMemoryDir(root, selfAid, peerKey), 'consolidated');
+        const due = checkStale(dir, now, config.forgetAfterDays);
+        if (due > 0) {
+            out.push({ mode: 'forget', peerKey, scope: 'relation', reason: `${due} 条记忆超过审查周期（未续期）` });
+        }
+    }
+    // ⑤b 超期记忆 → forget（agent 级 / owner 级）
+    const agentConsolidated = path.join(root, 'agents', selfAid, 'personal', 'memory', 'consolidated');
+    if (config.enableAgent && checkStale(agentConsolidated, now, config.forgetAfterDays) > 0) {
+        out.push({ mode: 'forget', scope: 'agent', reason: 'agent 级记忆超期' });
+    }
+    if (config.enableOwner && ownerAid) {
+        const ownerConsolidated = path.join(root, 'memory', 'owner', ownerAid, 'consolidated');
+        if (checkStale(ownerConsolidated, now, config.forgetAfterDays) > 0) {
+            out.push({ mode: 'forget', scope: 'owner', reason: 'owner 级记忆超期' });
+        }
+    }
+    return out;
+}