evolcore 0.0.38 → 0.0.40

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

@@ -38,6 +38,10 @@ export const MODE_SCOPE = {
     promote: 'owner',
     profile: 'relation',
 };
+/** 系统自动发起、不向对端发反馈的触发来源。 */
+export function isSilentConsolidationTrigger(triggeredBy) {
+    return triggeredBy === 'periodic-trigger' || triggeredBy === 'relation-idle';
+}
 // 超期判据集中在 staleness.ts；这里做转发，保证 trigger 与 context 用同一套规则
 export { DEFAULT_FORGET_AFTER_DAYS, LONG_TERM_REVIEW_DAYS } from './staleness.js';
 // ── Checkpoint 读写 ──────────────────────────────────────────────────────────
@@ -136,6 +140,7 @@ function buildScopeContext(scope, input, selfAid,
 /** 候选来源作用域，默认与本作用域一致 */
 sourceScope) {
     const memoryDir = memoryDirOf(scope, selfAid, input.taskCtx.peerKey, input.ownerAid);
+    // 整理一律按关系进行：generalize / promote 的候选只来自本次会话所属关系（taskCtx.peerKey）。
     const candidateSourceDir = sourceScope === undefined || sourceScope === scope
         ? path.join(memoryDir, 'consolidated')
         : path.join(memoryDirOf(sourceScope, selfAid, input.taskCtx.peerKey, input.ownerAid), 'consolidated');
@@ -212,14 +217,24 @@ function scanCandidates(consolidatedDir, pick) {
     out.sort((a, b) => a.relPath.localeCompare(b.relPath));
     return out;
 }
+/**
+ * 给关系级候选补上来源关系前缀：`consolidated/x.md` → `<peerKey>/consolidated/x.md`。
+ * generalize / promote 的产出层（agent / owner）与候选层（relation）不同，不带前缀的
+ * 路径在产出层会解析成同名文件。
+ */
+function withPeerPrefix(candidates, peerKey) {
+    if (!peerKey)
+        return candidates;
+    return candidates.map(c => ({ ...c, relPath: `${peerKey}/${c.relPath}` }));
+}
 /** 按模式填充候选清单。 */
-function fillCandidates(ctx, mode, forgetAfterDays) {
+function fillCandidates(ctx, mode, forgetAfterDays, sourcePeerKey) {
     const source = ctx.candidateSourceDir ?? ctx.consolidatedDir;
     if (mode === 'generalize') {
-        ctx.candidates = scanCandidates(source, ({ tags }) => tags.includes('to-generalize'));
+        ctx.candidates = withPeerPrefix(scanCandidates(source, ({ tags }) => tags.includes('to-generalize')), sourcePeerKey);
     }
     else if (mode === 'promote') {
-        ctx.candidates = scanCandidates(source, ({ tags }) => tags.includes('to-promote'));
+        ctx.candidates = withPeerPrefix(scanCandidates(source, ({ tags }) => tags.includes('to-promote')), sourcePeerKey);
     }
     else if (mode === 'profile') {
         ctx.candidates = scanCandidates(source, () => true);
@@ -227,50 +242,15 @@ function fillCandidates(ctx, mode, forgetAfterDays) {
     else if (mode === 'forget') {
         const now = Date.now();
         const thresholds = { forgetAfterDays };
-        // forget + scope=agent：扫描所有 relation 的 consolidated 目录，以及 agent 自身的 consolidated
-        if (ctx.scope === 'agent') {
-            ctx.candidates = [];
-            // ctx.consolidatedDir 是 agents/<selfAid>/personal/memory/consolidated，
-            // 往上走三级才是 agents/<selfAid>
-            const agentDir = path.dirname(path.dirname(path.dirname(ctx.consolidatedDir)));
-            const relationsRoot = path.join(agentDir, 'relations');
-            if (fs.existsSync(relationsRoot)) {
-                for (const peerKey of fs.readdirSync(relationsRoot)) {
-                    const consolidatedDir = path.join(relationsRoot, peerKey, 'memory', 'consolidated');
-                    if (fs.existsSync(consolidatedDir)) {
-                        const candidates = collectCandidates(consolidatedDir, thresholds, now)
-                            .filter(info => isDueForReview(info, thresholds, now))
-                            .map(info => ({
-                            relPath: `${peerKey}/consolidated/${info.name}`,
-                            description: readFmValue(info.content, 'description') ?? info.name.replace(/\.md$/, ''),
-                            tags: info.tags,
-                        }));
-                        ctx.candidates.push(...candidates);
-                    }
-                }
-            }
-            // agent 自身的 consolidated（原 ⑤b 拉起 forget/agent 的来源）
-            if (fs.existsSync(ctx.consolidatedDir)) {
-                const own = collectCandidates(ctx.consolidatedDir, thresholds, now)
-                    .filter(info => isDueForReview(info, thresholds, now))
-                    .map(info => ({
-                    relPath: `consolidated/${info.name}`,
-                    description: readFmValue(info.content, 'description') ?? info.name.replace(/\.md$/, ''),
-                    tags: info.tags,
-                }));
-                ctx.candidates.push(...own);
-            }
-        }
-        else {
-            // relation / owner 级 forget：只扫描当前层级的 consolidated
-            ctx.candidates = collectCandidates(source, thresholds, now)
-                .filter(info => isDueForReview(info, thresholds, now))
-                .map(info => ({
-                relPath: `consolidated/${info.name}`,
-                description: readFmValue(info.content, 'description') ?? info.name.replace(/\.md$/, ''),
-                tags: info.tags,
-            }));
-        }
+        // 一次会话只审一层：relation / agent / owner 各自只扫本层 consolidated/。
+        // 关系层由关系整理链逐关系审，agent 层只审 personal/memory 自身。
+        ctx.candidates = collectCandidates(source, thresholds, now)
+            .filter(info => isDueForReview(info, thresholds, now))
+            .map(info => ({
+            relPath: `consolidated/${info.name}`,
+            description: readFmValue(info.content, 'description') ?? info.name.replace(/\.md$/, ''),
+            tags: info.tags,
+        }));
     }
 }
 // ── 渲染 ────────────────────────────────────────────────────────────────────
@@ -285,7 +265,10 @@ function renderScopeSection(ctx, mode, threadFiles) {
         lines.push(`- ownerAid: ${ctx.ownerAid}`);
     if (ctx.baseagent)
         lines.push(`- baseagent: ${ctx.baseagent}`);
-    lines.push(`- processingDir: ${ctx.processingDir}`);
+    // processingDir 只在 notes 模式下是有效输入（待整理的 note 在那里）。
+    // 其他模式不读它，列出来会诱导模型去 Glob 一个 hook 不放行的目录。
+    if (mode === 'notes')
+        lines.push(`- processingDir: ${ctx.processingDir}`);
     lines.push(`- consolidatedDir: ${ctx.consolidatedDir}`);
     lines.push(`- indexPath: ${ctx.indexPath}`);
     lines.push('');
@@ -499,7 +482,7 @@ export function serializeConsolidationContext(input) {
     const now = new Date();
     const forgetAfterDays = input.forgetAfterDays ?? DEFAULT_FORGET_AFTER_DAYS;
     for (const ctx of scopes) {
-        fillCandidates(ctx, input.mode, forgetAfterDays);
+        fillCandidates(ctx, input.mode, forgetAfterDays, input.taskCtx.peerKey);
     }
     // ── 批次目录（长期批次）────────────────────────────────────────────────────
     const batchRoot = path.join(resolveRoot(), 'memory', 'consolidation-batches');
@@ -564,16 +547,24 @@ export function serializeConsolidationContext(input) {
         '',
         ...scopes.flatMap(ctx => [renderScopeSection(ctx, input.mode, threadFiles), '', '---', '']),
     ];
-    // 列出可读根（工具 path/file_path 参数必须落在这些路径内）
+    // 列出可读根（工具 path/file_path 参数必须落在这些路径内）。
+    // 这份清单必须与 system-session/memory.ts 的 memoryReadRoots 一致——两边各算一份
+    // 就会出现"任务书让模型去读、hook 却拒绝"的假阴性。
     lines.push('', '**可读根（工具 path/file_path 参数必须落在这些路径内）**：');
     lines.push('- 批次目录：`' + batchDir + '`');
     for (const ctx of scopes) {
-        if (ctx.processingDir)
+        // 与 renderScopeSection 同判据：processingDir 只在 notes 模式可读
+        if (input.mode === 'notes' && ctx.processingDir)
             lines.push('- processingDir: `' + ctx.processingDir + '`');
         if (ctx.consolidatedDir)
             lines.push('- consolidatedDir: `' + ctx.consolidatedDir + '`');
         if (ctx.indexPath)
             lines.push('- indexPath: `' + ctx.indexPath + '`');
+        // generalize / promote 的候选在本关系的 consolidated/（hook 只放行该目录，不含关系级 MEMORY.md）
+        if ((input.mode === 'generalize' || input.mode === 'promote') && input.taskCtx.peerKey) {
+            const relationMemoryDir = path.join(resolveRoot(), 'agents', ctx.selfAid, 'relations', input.taskCtx.peerKey, 'memory');
+            lines.push('- relationConsolidatedDir: `' + path.join(relationMemoryDir, 'consolidated') + '`');
+        }
     }
     if (historyJsonlPath)
         lines.push('- 消息流水: `' + historyJsonlPath + '`');

package/dist/core/memory/consolidation-ops-records.js

@@ -76,15 +76,19 @@ export function readFeedbackText(batchDir) {
     return undefined;
 }
 /**
- * 收集 ops 记录里所有出现过的作用域及其 memory 根目录。
- * 供 finishConsolidationSession 决定要对哪几个 scope 重建索引。
- * 返回 Map<scope, memoryDir>；同一 scope 若出现多次取第一条（目录相同）。
+ * 收集 ops 记录里所有被写过的 memory 根目录及其作用域。
+ * 供 finishConsolidationSession 决定要对哪几个目录重建索引。
+ *
+ * 按 memoryDir 去重，不按 scope：同一 scope 可能涉及多个目录（群聊按发言人分流到
+ * 多条关系；archive 记的是源文件所属层）。按 scope 去重会只重建第一个目录的索引。
+ * 作用域优先从路径推断（archive 流水的 scope 是会话写入层，不一定是 memoryDir 所属层），
+ * 推不出来时用记录里的 scope。
  */
 export function collectAffectedScopes(batchDir) {
     const result = new Map();
     const filePath = path.join(batchDir, 'ops.jsonl');
     if (!fs.existsSync(filePath))
-        return result;
+        return [];
     try {
         for (const line of fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean)) {
             const entry = JSON.parse(line);
@@ -92,13 +96,41 @@ export function collectAffectedScopes(batchDir) {
                 continue;
             const e = entry;
             const s = e.scope;
-            if ((s === 'relation' || s === 'agent' || s === 'owner') && e.memoryDir && !result.has(s)) {
-                result.set(s, e.memoryDir);
+            if ((s === 'relation' || s === 'agent' || s === 'owner') && e.memoryDir && !result.has(e.memoryDir)) {
+                result.set(e.memoryDir, scopeOfMemoryDir(e.memoryDir) ?? s);
+            }
+            // create --replaces 跨层归档（如泛化把关系级源文件归档）：源文件所在层也被改了，
+            // 它的索引同样要重建。源路径是绝对路径，形如 <memoryDir>/consolidated/<file>。
+            for (const af of e.archivedFiles ?? []) {
+                if (!af.source || !path.isAbsolute(af.source))
+                    continue;
+                const consolidatedDir = path.dirname(af.source);
+                if (path.basename(consolidatedDir) !== 'consolidated')
+                    continue;
+                const srcMemoryDir = path.dirname(consolidatedDir);
+                const srcScope = scopeOfMemoryDir(srcMemoryDir);
+                if (srcScope && !result.has(srcMemoryDir))
+                    result.set(srcMemoryDir, srcScope);
             }
         }
     }
     catch { /* ignore */ }
-    return result;
+    return [...result].map(([memoryDir, scope]) => [scope, memoryDir]);
+}
+/** 从 memory 根目录路径推断作用域；不是标准布局时返回 undefined。 */
+function scopeOfMemoryDir(memoryDir) {
+    const parts = path.resolve(memoryDir).split(path.sep);
+    const last = parts.length - 1;
+    // .../agents/<selfAid>/relations/<peerKey>/memory
+    if (parts[last] === 'memory' && parts[last - 2] === 'relations')
+        return 'relation';
+    // .../agents/<selfAid>/personal/memory
+    if (parts[last] === 'memory' && parts[last - 1] === 'personal')
+        return 'agent';
+    // .../memory/owner/<ownerAid>
+    if (parts[last - 1] === 'owner' && parts[last - 2] === 'memory')
+        return 'owner';
+    return undefined;
 }
 /**
  * 读取 ops 记录里所有成功的写操作，按写入顺序倒序返回（最后写的先回撤）。

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

@@ -1,23 +1,20 @@
 /**
- * consolidation-trigger.ts — 整理候选检查（v4，纯函数）
+ * consolidation-trigger.ts — 整理候选判据（v5，纯函数）
  *
- * 职责只有一个：**检查五类候选，返回该拉起哪些整理会话。**
+ * 整理一律以关系为单位。两类判据：
  *
- *   ① pending 堆积超过 backlogHours 的关系 → notes 模式（无会话历史，凭 note 内容整理）
- *   ② 带 to-generalize 的记忆              → generalize 模式
- *   ③ 带 to-promote 的记忆                 → promote 模式
- *   ④ 索引有变化且距上次画像超过 profileRegenDays → profile 模式
- *   ⑤ 有记忆 mtime 超过 forgetAfterDays     → forget 模式
+ * **关系级**（`isRelationModeDue`，供关系整理链逐步调用，见 relation-sweep.ts）：
+ *   notes      pending/ 里有 note
+ *   generalize 本关系有 to-generalize
+ *   promote    本关系是 owner 关系且有 to-promote
+ *   profile    索引有变化且距上次画像超过 profileRegenDays（或还没有画像）
+ *   forget     本关系有超期记忆
  *
- * 判据是**数文件和数标签**，不看轮次和工具调用次数——活干得多不代表写得出记忆，
- * 只干两轮也可能产出五条要整理的内容。
+ * **全局定时检查**（`checkConsolidationCandidates`，cron script 驱动）：只管不属于任何关系的部分——
+ *   agent 层 / owner 层 forget，外加 pending 堆积超过 backlogHours 的兜底。
  *
- * v4 变化：不再自己实现定时器（原 setInterval 类已删除）。定时由 evolcore trigger 的
- * cron `execution.type='script'` 驱动，脚本调 daemon 的 `memory.check-consolidation`，
- * daemon 侧调用本模块的 `checkConsolidationCandidates()`，结果经 enqueueConsolidation 入队。
- *
- * 因此本模块**不持有任何进程内状态**（无 lastTaskEndAt 空闲门控）——所有判据都读磁盘。
- * 并发安全由 daemon 侧的整理队列保证（同 agent 串行）。
+ * 判据是**数文件和数标签**，不看轮次和工具调用次数。本模块不持有进程内状态，判据都读磁盘；
+ * 关系的空闲 / 兜底计时在 relation-idle-monitor.ts。
  */
 import fs from 'fs';
 import path from 'path';
@@ -321,22 +318,70 @@ function checkStale(consolidatedDir, now, forgetAfterDays) {
 export function shouldUseMetaIndex(agentCount, relationCount) {
     return agentCount * relationCount > META_INDEX_THRESHOLD;
 }
+/** 关系整理链的固定顺序。每步在上一步收尾后重新判定，notes 新产出的标签要被后面几步看到。 */
+export const RELATION_SWEEP_ORDER = ['notes', 'generalize', 'promote', 'profile', 'forget'];
+/** pending/ 里有没有待整理的 note。 */
+function hasPendingNotes(pendingDir) {
+    if (!fs.existsSync(pendingDir))
+        return false;
+    try {
+        return fs.readdirSync(pendingDir).some(f => f.endsWith('.md'));
+    }
+    catch {
+        return false;
+    }
+}
+/** 默认的关系空闲时长与兜底时长（小时）。 */
+export const DEFAULT_RELATION_IDLE_HOURS = 1;
+export const DEFAULT_MAX_UNCONSOLIDATED_HOURS = 8;
 /**
- * 检查五类候选，返回该拉起的整理会话列表。
+ * 单个关系的某个整理模式现在该不该跑。关系整理链逐步调用。
  *
- * 纯检查 + 少量副作用（forget 的长期记忆减速刷新 mtime）。
- * 调用方负责把结果入队（见 index.ts 的 enqueueConsolidation）。
+ * 与全局检查不同：notes 只要有 pending 就跑（关系已空闲 / 兜底到期，不再等堆积），
+ * promote 只在该关系就是 owner 关系时才可能命中。
+ */
+export function isRelationModeDue(params) {
+    const { mode, selfAid, peerKey } = params;
+    const now = params.now ?? Date.now();
+    const root = params.root ?? resolveRoot();
+    const config = effectiveConfig(params.config);
+    const useMetaIndex = params.useMetaIndex ?? false;
+    if (!config.enableRelation)
+        return false;
+    const memDir = relationMemoryDir(root, selfAid, peerKey);
+    switch (mode) {
+        case 'notes':
+            return hasPendingNotes(path.join(memDir, 'pending'));
+        case 'generalize':
+            return config.enableAgent && !!countTagged(root, selfAid, [peerKey], 'to-generalize', useMetaIndex);
+        case 'promote':
+            return config.enableOwner
+                && findOwnerPeerKey([peerKey], params.ownerAid) === peerKey
+                && !!countTagged(root, selfAid, [peerKey], 'to-promote', useMetaIndex);
+        case 'profile':
+            return profileDueWithMeta(memDir, now, config.profileRegenDays, useMetaIndex);
+        case 'forget':
+            return checkStale(path.join(memDir, 'consolidated'), now, config.forgetAfterDays) > 0;
+    }
+}
+/**
+ * 全局定时检查：只管**不属于任何一个关系**的部分，外加 pending 堆积兜底。
+ *
+ *   ① pending 堆积超过 backlogHours 的关系 → notes（由调用方转成该关系的整理链）
+ *   ② agent 层超期记忆（只看 personal/memory 自身）→ forget scope=agent
+ *   ③ owner 层超期记忆 → forget scope=owner
  *
- * 两种扫描路径：
- *   - useMetaIndex=false（默认）：读每个 .md 全文数标签 / 找画像（全量扫描）
- *   - useMetaIndex=true：先读 `_meta.json` 汇总；缺失或不符时该作用域回退全量扫描
+ * generalize / promote / profile / 关系层 forget 由关系整理链负责（relation-sweep.ts），
+ * 这里不再产出：整理一律以关系为单位。
+ *
+ * 纯检查 + 少量副作用（forget 的长期记忆减速刷新 mtime）。
+ * useMetaIndex 参数保留兼容：当前三类判据都不读 `_meta.json`（关系级判据见 isRelationModeDue）。
  */
 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;
@@ -356,50 +401,12 @@ export function checkConsolidationCandidates(params) {
             });
         }
     }
-    // ② 待泛化 → 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（agent 级，扫描所有 relation + agent 自身，合并成一个会话）
-    let hasRelationForget = false;
-    for (const peerKey of peerKeys) {
-        const dir = path.join(relationMemoryDir(root, selfAid, peerKey), 'consolidated');
-        const due = checkStale(dir, now, config.forgetAfterDays);
-        if (due > 0)
-            hasRelationForget = true;
-    }
-    // ⑤b agent 自身的 consolidated 超期
+    // ② agent 层超期 → forget scope=agent（只审 personal/memory 自身；关系层由关系整理链负责）
     const agentConsolidated = path.join(root, 'agents', selfAid, 'personal', 'memory', 'consolidated');
-    const hasAgentForget = config.enableAgent && checkStale(agentConsolidated, now, config.forgetAfterDays) > 0;
-    // 只要有任意一层超期，起一个 forget scope=agent 会话，由会话内统一扫描
-    if (hasRelationForget || hasAgentForget) {
-        const parts = [];
-        if (hasRelationForget)
-            parts.push('关系级记忆超期');
-        if (hasAgentForget)
-            parts.push('agent 级记忆超期');
-        out.push({ mode: 'forget', scope: 'agent', reason: parts.join('、') });
+    if (config.enableAgent && checkStale(agentConsolidated, now, config.forgetAfterDays) > 0) {
+        out.push({ mode: 'forget', scope: 'agent', reason: 'agent 级记忆超期' });
     }
-    // ⑤c owner 级 forget 保持独立（owner 层与 agent/relation 层是平行的）
+    // ③ owner 层超期 → forget scope=owner（owner 层与 agent / relation 层是平行的）
     if (config.enableOwner && ownerAid) {
         const ownerConsolidated = path.join(root, 'memory', 'owner', ownerAid, 'consolidated');
         if (checkStale(ownerConsolidated, now, config.forgetAfterDays) > 0) {