evolcore 0.0.28 → 0.0.29

package/dist/index.js

@@ -1,7 +1,7 @@
 // 【重要】最先加载环境变量，确保后续模块初始化时可用
 import dotenv from 'dotenv';
 import path from 'path';
-import { ensureDataDirs, resolvePaths, getPackageRoot, agentMdPath, eckDebugDir, daemonControlDir, daemonQueuePath, daemonMessageDedupPath } from './paths.js';
+import { ensureDataDirs, resolvePaths, agentDir, getPackageRoot, agentMdPath, eckDebugDir, daemonControlDir, daemonQueuePath, daemonMessageDedupPath } from './paths.js';
 // 立即加载 .env 文件（在其他模块导入之前）
 try {
     dotenv.config({ path: path.join(resolvePaths().root, '.env') });
@@ -13,7 +13,7 @@ import { ClaudeSessionFileAdapter } from './core/session/adapters/claude-session
 import { CodexSessionFileAdapter } from './core/session/adapters/codex-session-file-adapter.js';
 import { GeminiSessionFileAdapter } from './core/session/adapters/gemini-session-file-adapter.js';
 import { EcagentSessionFileAdapter } from './core/session/adapters/ecagent-session-file-adapter.js';
-import { autoMigrateIfNeeded, loadDefaults, loadAllAgents, migrateIdentitiesIfNeeded, loadDaemonConfig, initializeEckSnapshotsConfig, isFullAccessEnabled } from './config-store.js';
+import { autoMigrateIfNeeded, loadDefaults, loadAllAgents, migrateIdentitiesIfNeeded, loadDaemonConfig, initializeEckSnapshotsConfig } from './config-store.js';
 import { migrateRelationSharedDirectories } from './core/relation/shared-data.js';
 import { DEFAULT_ECWEB_PORT, ecwebService } from './config/daemon-services.js';
 import { ConfigTarget, initConfigManager, onConfigWrite, read as readConfig, shouldFailFastForMissingOwners } from './config/config-manager.js';
@@ -28,6 +28,7 @@ import { ensureStartupConfigSnapshot, isConfigSnapshotsEnabled, retentionCleanup
 import { appendBootLog, selfDiagnose } from './config/boot-log.js';
 import { CONFIG_SCHEMA_VERSION } from './types.js';
 import { SessionManager } from './core/session/session-manager.js';
+import { SessionIdleMonitor } from './core/session/session-idle-monitor.js';
 import { ClaudeAgentPlugin } from './agents/claude-runner.js';
 import { CodexAgentPlugin } from './agents/codex-runner.js';
 import { GeminiAgentPlugin } from './agents/gemini-runner.js';
@@ -44,9 +45,10 @@ import { WecomChannelPlugin, registerPendingWecomContactBind } from './channels/
 import { buildEnvelope, isDeliveryTargetForChannel, replyContextFromSession } from './core/message/message-utils.js';
 import { ResponseEngine } from './core/message/response-engine.js';
 import { MessageQueue } from './core/message/message-queue.js';
+import { pendingInterruptHints } from './core/message/pending-hints.js';
 import { MessageBridge } from './core/message/message-bridge.js';
 import { evaluateOutboundContactAdmission } from './core/message/message-admission.js';
-import { enforceMenuResponseSize, evaluateMenuClientCompatibility, evolMenuResponseTransportMetadata, MenuRequestDeduper, hasValidMenuId, menuFailure, menuPayloadFingerprint, normalizeMenuResponseTiming, parseMenuControl, validateMenuRequest, withMenuProcessingTime, logMenuRequestCompleted, logMenuRequestReceived } from './core/command/menu-protocol.js';
+import { enforceMenuResponseSize, evaluateMenuClientCompatibility, evolMenuResponseTransportMetadata, MenuRequestDeduper, hasValidMenuId, menuFailure, menuPayloadFingerprint, normalizeMenuResponseTiming, parseMenuControl, validateMenuRequest, withMenuProcessingTime, logMenuRequestCompleted, logMenuRequestReceived, MENU_RESPONSE_MAX_BYTES, MENU_RESPONSE_SAFETY_MARGIN_BYTES } from './core/command/menu-protocol.js';
 import { computeBuildId, readBuildIdentity, readEvolcoreRuntimeFlavor, readEvolcoreStartedAtIso, readInstalledEvolcoreVersion, tagErrorTextWithEvolcoreVersion, } from './utils/evolcore-version.js';
 import { recoverAllRoleMutationsSync } from './core/command/role-menu.js';
 import { HandoffRuntime } from './core/handoff/runtime.js';
@@ -58,6 +60,17 @@ import { executeLocalInitializationCommand, AgentInitializationService, hasSuppl
 import { loadAgent } from './config-store.js';
 import { AgentApplicationService } from './core/agent-application-service.js';
 import { EventBus } from './core/event-bus.js';
+import { seedConsolidationCheckTrigger, removeConsolidationCheckTrigger } from './core/memory/consolidation-trigger.js';
+import { migrateLegacyConsolidationBatches } from './core/memory/consolidation-context.js';
+/** 由 checkIntervalHours 生成 cron 表达式（每小时检查的分钟位错开整点）。 */
+function consolidationCheckCron(intervalHours) {
+    const hours = intervalHours && intervalHours > 0 ? Math.floor(intervalHours) : 1;
+    if (hours === 1)
+        return '17 * * * *';
+    if (hours >= 24)
+        return '17 3 * * *';
+    return `17 */${hours} * * *`;
+}
 import { eventPatternIncludesInternal, getEventCatalog } from './core/event-catalog.js';
 import { StatsCollector } from './utils/stats.js';
 import { AidStatsCollector } from './utils/stats.js';
@@ -68,8 +81,8 @@ import { AgentDelegationRegistry, authorizeDelegatedAunMsgSend, hasTrustedFullAc
 import { authorizeOperation, buildAuthSubject, canApprovePersistentFullAccessTrigger, isCrossAgentTriggerOperationAllowed, } from './core/auth/auth-gateway.js';
 import { authorizationDenialData, formatAuthorizationDenial } from './core/auth/authorization-denial.js';
 import { auditFullAccessEvent } from './core/auth/authorization-audit.js';
-import { parsePeerKey } from './core/relation/peer-identity.js';
-import { isHClassPath, isSameOrDescendant } from './core/permission/protected-paths.js';
+import { formatPeerKey, parsePeerKey } from './core/relation/peer-identity.js';
+import { isHClassPath, isLClassPath, isSameOrDescendant } from './core/permission/protected-paths.js';
 import { ChannelLoader, tryParseChannelKey } from './core/channel-loader.js';
 import { AgentLoader } from './core/baseagent-loader.js';
 import { EvolAgentRegistry } from './core/evolagent-registry.js';
@@ -101,6 +114,7 @@ import { validateModelSelectionForRole } from './core/model/model-permission.js'
 import { constrainRuntimePermissionMode, validateRuntimeStringFieldOverride, } from './core/role/runtime-policy.js';
 import { atomicWriteJson } from './core/session/session-fs-store.js';
 import { DAEMON_RUNTIME_EPOCH_ENV, ensureProcessManagedTempDir } from './cli/task-context.js';
+import { isLinkedInstall } from './utils/npm-ops.js';
 import { appendMessageLog, buildOutboundEntry, classifyAunPayloadForLog } from './core/message/message-log.js';
 import { normalizeAunMentionEntries } from './aun/msg/mention-schema.js';
 import { sanitizeMenuLogValue } from './core/command/menu-protocol.js';
@@ -318,6 +332,44 @@ function originFromActorSession(session, authenticatedPeerId, authenticatedChann
         delivery: { chatType: 'private' },
     };
 }
+/** 整理会话未调用 `ec memory feedback` 时的默认反馈模板。 */
+function renderDefaultConsolidationFeedback(input) {
+    const triggerLabel = {
+        manual: '手动触发',
+        compress: '上下文压缩',
+        'session-new': '新会话',
+        'periodic-trigger': '定时检查',
+    };
+    const mode = input.mode ?? 'notes';
+    const cause = triggerLabel[input.triggeredBy] ?? input.triggeredBy;
+    if (!input.success) {
+        return [
+            '## 记忆整理失败',
+            '',
+            `**模式**：${mode}`,
+            `**触发**：${cause}`,
+            '',
+            '本次整理未完成，已回退未归档的改动。详情见整理批次：',
+            `\`${input.batchDir}\``,
+        ].join('\n');
+    }
+    const { created, updated, archived, errors } = input.summary;
+    const lines = [
+        '## 记忆整理完成',
+        '',
+        `**模式**：${mode}  `,
+        `**触发**：${cause}`,
+        '',
+        '### 处理结果',
+        `- 新建记忆：${created} 条`,
+        `- 更新记忆：${updated} 条`,
+        `- 归档记忆：${archived} 条`,
+    ];
+    if (errors > 0)
+        lines.push(`- 错误：${errors} 条`);
+    lines.push('', `整理批次：\`${input.batchDir}\``);
+    return lines.join('\n');
+}
 function seedUpgradeCheckTrigger(manager, owner) {
     const now = Date.now();
     const scriptName = 'upgrade-check.cjs';
@@ -442,6 +494,52 @@ function seedTaskRecoveryTrigger(manager, owner) {
     atomicWriteJson(manager.definitionPath(definition.id), definition);
     fs.rmSync(manager.activePath(definition.id), { force: true });
 }
+const SESSION_IDLE_CHECK_PROMPT = `本会话已闲置一段时间。请依据你的职责执行一次例行巡检：
+1. 判断群内是否存在成员有未完成的工作却停滞（如长时间无进展、被点名未回应、承诺后失联）。有，则向该成员催促一次并说明停滞事项，随后即止；无，则不做任何动作。大家都在正常工作或无待办时保持沉默。
+2. 巡检优先基于已有上下文判断，确需补充背景再查询历史，并遵守会话自身的发送规范。
+3. 判定无需任何对外动作时，本轮只输出 [[NOOP]]，不发送任何消息、不发布巡检结论。注意：最终对外输出必须是且仅是 [[NOOP]] 这一行——不要在输出它之前先发送任何说明文字或巡检判定，判定过程仅在内部完成。
+（本指令为通用模板，可按具体职责增删检查项。）`;
+function seedSessionIdleCheckTrigger(manager, owner) {
+    const now = Date.now();
+    const definition = normalizeTriggerDefinition({
+        $schema_version: 3.1,
+        id: '__session-idle-check',
+        agentAid: owner.aid,
+        enabled: true,
+        name: '__session-idle-check',
+        description: 'System trigger: inspect configured idle group sessions.',
+        createdAt: now,
+        updatedAt: now,
+        origin: {
+            channelKey: 'daemon',
+            channelType: 'daemon',
+            channelId: owner.originPeerId || owner.aid,
+            session: 'main',
+            peerId: owner.originPeerId || owner.aid,
+            sessionKey: `daemon#${owner.originPeerId || owner.aid}#__session-idle-check__`,
+        },
+        source: {
+            type: 'event',
+            eventPattern: 'session:idle',
+            filter: { match: { chatType: 'group' } },
+        },
+        execution: {
+            type: 'target_session',
+            prompt: SESSION_IDLE_CHECK_PROMPT,
+            onError: 'retry',
+            noopSentinel: '[[NOOP]]',
+        },
+        feedback: { strategy: 'event_session' },
+        reliability: {
+            concurrency: 'forbid',
+            missedPolicy: 'run_once',
+            retry: { maxAttempts: 2, backoffMs: 30_000 },
+        },
+    });
+    fs.mkdirSync(manager.triggerDir(definition.id), { recursive: true });
+    atomicWriteJson(manager.definitionPath(definition.id), definition);
+    fs.rmSync(manager.activePath(definition.id), { force: true });
+}
 function removeLegacyAgentUpgradeCheck(manager) {
     let existing;
     try {
@@ -874,7 +972,16 @@ async function main() {
     if (relationSharedMigration.copied > 0) {
         logger.info(`[migrate] Synced ${relationSharedMigration.copied} relation shared file(s) across ${relationSharedMigration.relations} relation(s)`);
     }
+    migrateLegacyConsolidationBatches();
     // daemon.json 的旧 ecweb/serviceProxy 结构已在启动前归一化为 services[]。
+    // ── Skill 监控器启动（采用懒加载机制）──
+    try {
+        const { startSkillWatcher } = await import('./core/skill/startup.js');
+        startSkillWatcher();
+    }
+    catch (e) {
+        logger.warn(`[skill] 监控器启动失败: ${e instanceof Error ? e.message : String(e)}`);
+    }
     // ── 配置体系初始化（schema 字段不相交硬约束校验）──
     try {
         initConfigManager();
@@ -1139,20 +1246,185 @@ async function main() {
             logger.info(`[PermissionGateway] Cancelled ${cancelled} stale management approval(s) after ${target} config write: agent=${selector.self}`);
         }
     });
+    // 整理会话结束（成功 / 失败 / 中断）：回撤、processing/ 归位、定稿 rebuild、forget 后置检查、反馈
+    // releaseSlot / feedbackSender 由后面的块赋值（避免暂时性死区）。
+    let releaseConsolidationSlotRef = () => { };
+    let sendConsolidationFeedbackRef = async () => { };
+    const finishConsolidationSession = async (sessionId, success) => {
+        let releaseAid;
+        try {
+            if (!sessionId)
+                return;
+            const session = await sessionManager.getSessionById(sessionId);
+            if (!session)
+                return;
+            const meta = (session.metadata ?? {});
+            const batchDir = (meta.consolidationBatchDir ?? meta.consolidationLogBase);
+            if (!batchDir)
+                return; // 不是整理会话
+            releaseAid = session.selfAID;
+            const { onConsolidationComplete, rollbackConsolidation } = await import('./core/memory/launch-consolidation.js');
+            const { appendOpsRecord, summarizeOpsRecords, collectAffectedScopes } = await import('./core/memory/consolidation-ops-records.js');
+            // ① 失败时先回撤写操作，再做 processing/ 归位
+            if (!success) {
+                await rollbackConsolidation(batchDir, session.selfAID);
+            }
+            // ② processing/ 归位（成功→archive/notes，失败→pending）+ 写 checkpoint
+            const completeResult = await onConsolidationComplete({
+                success,
+                batchDir,
+                chatDir: meta.consolidationChatDir,
+                memoryDir: meta.consolidationMemoryDir,
+            });
+            // ③ 收尾定稿 rebuild：对 ops.jsonl 里出现的所有 scope 各 rebuild 一次
+            // 无论成败都做，确保索引和磁盘文件一致（失败回撤后索引也跟着还原）
+            try {
+                const affectedScopes = collectAffectedScopes(batchDir); // Map<scope, memoryDir>
+                if (affectedScopes.size > 0) {
+                    const { rebuildIndex } = await import('./core/memory/index-manager.js');
+                    const selfAid = session.selfAID;
+                    const mc = selfAid ? agentRegistry?.get(selfAid)?.config?.memory : undefined;
+                    const maxBytes = mc?.indexMaxBytes ?? 5 * 1024;
+                    for (const [scope, memoryDir] of affectedScopes) {
+                        const consolidatedDir = path.join(memoryDir, 'consolidated');
+                        const indexPath = path.join(memoryDir, 'MEMORY.md');
+                        const invalidDir = path.join(memoryDir, 'archive', 'invalid');
+                        try {
+                            await rebuildIndex(consolidatedDir, indexPath, scope, invalidDir, undefined, maxBytes);
+                        }
+                        catch { /* 单个 scope rebuild 失败不影响其他 scope */ }
+                    }
+                }
+            }
+            catch { /* rebuild 失败下次整理时补上 */ }
+            // ④ 写 session-end 日志（落笔，记录最终状态）
+            appendOpsRecord(batchDir, {
+                ts: new Date().toISOString(),
+                op: 'session-end',
+                success,
+                movedNotes: completeResult.moved,
+                checkpointWritten: completeResult.checkpointWritten,
+            });
+            // ⑤ forget 后置检查：成功且有产出且不是 forget 模式本身
+            if (success) {
+                const memoryMode = meta.memoryMode;
+                if (memoryMode && memoryMode !== 'forget') {
+                    const opsSummary = summarizeOpsRecords(batchDir);
+                    const hasOutput = completeResult.moved > 0 || opsSummary.created > 0 || opsSummary.updated > 0;
+                    if (hasOutput) {
+                        try {
+                            const { collectAffectedScopes: getScopes } = await import('./core/memory/consolidation-ops-records.js');
+                            const { collectCandidates, isDueForReview, deferCandidate } = await import('./core/memory/staleness.js');
+                            const selfAid = session.selfAID;
+                            if (selfAid) {
+                                const mc = agentRegistry?.get(selfAid)?.config?.memory;
+                                const thresholds = { forgetAfterDays: mc?.forgetAfterDays ?? 3 };
+                                const now = Date.now();
+                                const affectedScopes = getScopes(batchDir);
+                                for (const [scope, memoryDir] of affectedScopes) {
+                                    const consolidatedDir = path.join(memoryDir, 'consolidated');
+                                    let due = 0;
+                                    try {
+                                        for (const info of collectCandidates(consolidatedDir, thresholds, now)) {
+                                            if (isDueForReview(info, thresholds, now))
+                                                due++;
+                                            else {
+                                                try {
+                                                    deferCandidate(info.filePath, now);
+                                                }
+                                                catch { /* ignore */ }
+                                            }
+                                        }
+                                    }
+                                    catch {
+                                        continue;
+                                    }
+                                    if (due > 0) {
+                                        const ownerAid = mc ? agentRegistry?.get(selfAid)?.config?.owners?.[0] : undefined;
+                                        // 构造最小 taskCtx，定时触发不需要 sessionId/peerKey
+                                        const taskCtx = { selfAid, peerKey: meta.peerKey };
+                                        void enqueueConsolidation({
+                                            taskCtx,
+                                            mode: 'forget',
+                                            triggeredBy: 'periodic-trigger',
+                                            ownerAid,
+                                            forgetAfterDays: mc?.forgetAfterDays,
+                                            scopeOverride: scope,
+                                        }).catch(() => { });
+                                    }
+                                }
+                            }
+                        }
+                        catch { /* forget 后置检查失败不影响主流程 */ }
+                    }
+                }
+            }
+            // ⑥ 会话历史导出 → <batchDir>/history.jsonl
+            const agentSessionId = session.agentSessionId;
+            const projectPath = session.projectPath;
+            const baseagent = session.baseagent ?? 'claude';
+            if (agentSessionId && projectPath) {
+                const fs = await import('fs');
+                const historyPath = path.join(batchDir, 'history.jsonl');
+                const runner = agentMap.get(`${session.selfAID}::${baseagent}`);
+                if (runner?.getSessionMessages) {
+                    try {
+                        const messages = await runner.getSessionMessages(agentSessionId, projectPath);
+                        fs.default.writeFileSync(historyPath, messages.map((m) => JSON.stringify(m)).join('\n') + '\n', 'utf-8');
+                    }
+                    catch { /* 导出失败不影响主流程 */ }
+                }
+                else {
+                    fs.default.writeFileSync(historyPath, JSON.stringify({ note: `runner ${baseagent} does not support getSessionMessages` }) + '\n', 'utf-8');
+                }
+            }
+            // ⑦ 反馈：非定时触发时，把整理结果投递回发起时的会话和话题
+            const feedbackOrigin = meta.feedbackOrigin;
+            const triggeredBy = meta.consolidationTriggeredBy;
+            if (feedbackOrigin && triggeredBy && triggeredBy !== 'periodic-trigger' && session.selfAID) {
+                try {
+                    const { readFeedbackText, summarizeOpsRecords } = await import('./core/memory/consolidation-ops-records.js');
+                    const customText = readFeedbackText(batchDir);
+                    const text = customText ?? renderDefaultConsolidationFeedback({
+                        mode: meta.memoryMode,
+                        triggeredBy,
+                        success,
+                        summary: summarizeOpsRecords(batchDir),
+                        batchDir,
+                    });
+                    await sendConsolidationFeedbackRef(feedbackOrigin, text, session.selfAID);
+                }
+                catch (e) {
+                    logger.warn(`[Memory] 整理反馈投递失败（session=${sessionId}）: ${e?.message}`);
+                }
+            }
+        }
+        catch (e) {
+            logger.warn(`[Memory] 整理收尾失败（session=${sessionId}）: ${e?.message}`);
+        }
+        finally {
+            // 释放该 agent 的并发位并推进队列（幂等：不在活跃集合里也无害）
+            if (releaseAid)
+                releaseConsolidationSlotRef(releaseAid);
+        }
+    };
     eventBus.subscribe('task:interrupted', (event) => {
         if ('sessionId' in event && event.sessionId) {
             permissionGateway.cancelAll(event.sessionId, event.reason || 'interrupted');
         }
+        void finishConsolidationSession(event.sessionId, false);
     });
     eventBus.subscribe('task:error', (event) => {
         if ('sessionId' in event && event.sessionId) {
             permissionGateway.cancelAll(event.sessionId, 'task_error', false);
         }
+        void finishConsolidationSession(event.sessionId, false);
     });
     eventBus.subscribe('task:completed', (event) => {
         if ('sessionId' in event && event.sessionId) {
             permissionGateway.cancelAll(event.sessionId, 'task_completed', false);
         }
+        void finishConsolidationSession(event.sessionId, true);
     });
     // 交互路由器
     const interactionRouter = new InteractionRouter();
@@ -1270,6 +1542,16 @@ async function main() {
     }, primaryRunnerKey);
     responseEngine.setAgentDelegationRegistry(agentDelegationRegistry);
     const processor = responseEngine;
+    responseEngine.setObserverHintConsumed((hint, target, meta) => {
+        const observerChannel = channelInstances.find(candidate => candidate.adapter.channelKey === target.channelKey
+            && candidate.channelType === 'aun')?.channel;
+        observerChannel?.notifyObserverHintConsumed(hint, target, meta);
+    });
+    responseEngine.setObserverHintFailed((hint, target, failure) => {
+        const observerChannel = channelInstances.find(candidate => candidate.adapter.channelKey === target.channelKey
+            && candidate.channelType === 'aun')?.channel;
+        observerChannel?.notifyObserverHintFailed(hint, target, failure);
+    });
     // 回填 processor 和 messageQueue 的引用
     cmdHandler.setProcessor(processor);
     // Inject EvolAgentRegistry (methods added by T6/T7)
@@ -1295,13 +1577,13 @@ async function main() {
         dedupPath: daemonMessageDedupPath(),
     });
     // 设置中断回调（精确中断正在处理的 agent）
-    messageQueue.setInterruptCallback(async (sessionKey, baseagent, evolagentName, reason = 'new_message', timeout) => {
+    messageQueue.setInterruptCallback(async (sessionKey, baseagent, evolagentName, reason = 'new_message', timeout, strict) => {
         void baseagent;
         void evolagentName;
         if (timeout)
             await responseEngine.timeoutSession(sessionKey, timeout);
         else
-            await responseEngine.interruptSession(sessionKey, reason);
+            await responseEngine.interruptSession(sessionKey, reason, strict);
     });
     messageQueue.setEventBus(eventBus);
     // Restore persisted input before Trigger schedulers start. Trigger-owned work
@@ -1369,6 +1651,37 @@ async function main() {
     cmdHandler.setHandoffRuntime(handoffRuntime);
     // Trigger runtime: daemon-level script + feedback scheduler.
     const triggerSchedulers = new Map();
+    const sessionIdleMonitor = new SessionIdleMonitor({
+        eventBus,
+        statePath: path.join(paths.dataDir, 'session-idle-state.json'),
+        getSessionById: sessionId => sessionManager.getSessionById(sessionId),
+        isSessionBusy: sessionId => messageQueue.isProcessing(sessionId) || messageQueue.getQueueLength(sessionId) > 0,
+        getSessionIdleTriggerIds: () => [...triggerSchedulers.values()].flatMap(scheduler => scheduler.list({ all: true })
+            .filter(definition => definition.source.type === 'event' && definition.source.eventPattern === 'session:idle')
+            .map(definition => definition.id)),
+        getSessionIdleSeconds: (session) => {
+            if (!session.selfAID || !session.channelId)
+                return undefined;
+            try {
+                const relation = readConfig(ConfigTarget.Relation, {
+                    self: session.selfAID,
+                    peerKey: formatPeerKey(session.channelType || session.channel, session.channelId),
+                }, { cache: true, expand: true });
+                return relation?.sessionIdleSec;
+            }
+            catch (error) {
+                logger.warn(`[SessionIdleMonitor] Failed to read relation config for ${session.id}: ${error instanceof Error ? error.message : String(error)}`);
+                return undefined;
+            }
+        },
+        getSessionEncrypt: sessionId => sessionManager.getSessionEncrypt(sessionId),
+    });
+    sessionIdleMonitor.start();
+    onConfigWrite(({ target, selector }) => {
+        if (target === ConfigTarget.Relation && selector.self)
+            sessionIdleMonitor.refresh();
+    });
+    onShutdown(() => sessionIdleMonitor.stop());
     const targetSessionLocks = new TargetSessionLockRegistry();
     const triggerAudit = new TriggerAuditLogger();
     const triggerScriptExecutor = new TriggerScriptExecutor();
@@ -1376,6 +1689,81 @@ async function main() {
         watchdogMs: daemonConversationWatchdogMs(globalSettings),
         totalExecutionMs: taskExecutionTtlMs,
     });
+    // ── 记忆整理队列：同 agent 串行 + 全局并发上限 ─────────────────────────
+    //
+    // 整理会话不再经 trigger 系统创建，改为 launchConsolidation 直接创建会话。
+    // 并发控制由这里接管（原来靠 trigger 的 reliability.concurrency='forbid'）：
+    //   - 同一 agent 同时最多 1 个整理会话
+    //   - 全局同时最多 MAX_CONCURRENT_CONSOLIDATION(5) 个 agent 在整理
+    //   - 超限的请求排队，前面的结束后自动启动下一个
+    const MAX_CONCURRENT_CONSOLIDATION = 5;
+    const activeConsolidationAgents = new Set(); // 正在整理的 agentAid
+    const consolidationQueues = new Map(); // agentAid → 待办
+    const startConsolidation = async (params) => {
+        const aid = params.taskCtx.selfAid;
+        if (!aid)
+            return null;
+        activeConsolidationAgents.add(aid);
+        try {
+            const { launchConsolidation } = await import('./core/memory/launch-consolidation.js');
+            return await launchConsolidation(daemonChannel, params);
+        }
+        catch (e) {
+            logger.warn(`[Memory] 拉起整理会话失败（aid=${aid}，mode=${params.mode}）: ${e?.message}`);
+            // 启动失败不进收尾事件，直接释放并发位并推进队列
+            activeConsolidationAgents.delete(aid);
+            void drainConsolidationQueue();
+            return null;
+        }
+    };
+    /** 有空位就从队列里取等待最久的请求启动。 */
+    const drainConsolidationQueue = async () => {
+        while (activeConsolidationAgents.size < MAX_CONCURRENT_CONSOLIDATION) {
+            // 找第一个队列非空、且该 agent 当前不活跃的请求
+            let picked;
+            for (const [aid, queue] of consolidationQueues) {
+                if (queue.length === 0)
+                    continue;
+                if (activeConsolidationAgents.has(aid))
+                    continue;
+                picked = { aid, params: queue.shift() };
+                break;
+            }
+            if (!picked)
+                break;
+            if (consolidationQueues.get(picked.aid)?.length === 0)
+                consolidationQueues.delete(picked.aid);
+            await startConsolidation(picked.params);
+        }
+    };
+    /**
+     * 整理请求统一入口。四种触发方式（手动 / compact / renew·new / 定时）都走这里。
+     * 该 agent 不活跃且全局有空位 → 立即启动并返回结果；否则入队并返回 null。
+     */
+    const enqueueConsolidation = async (params) => {
+        const aid = params.taskCtx.selfAid;
+        if (!aid)
+            return null;
+        const agentBusy = activeConsolidationAgents.has(aid);
+        const queue = consolidationQueues.get(aid) ?? [];
+        const globalFull = activeConsolidationAgents.size >= MAX_CONCURRENT_CONSOLIDATION;
+        if (!agentBusy && !globalFull && queue.length === 0) {
+            return await startConsolidation(params);
+        }
+        queue.push(params);
+        consolidationQueues.set(aid, queue);
+        logger.info(`[Memory] 整理请求入队（aid=${aid}，mode=${params.mode}，` +
+            `队列长度=${queue.length}，全局活跃=${activeConsolidationAgents.size}）`);
+        return null;
+    };
+    /** 整理会话结束（成功/失败/中断）时调用：释放并发位，推进队列。 */
+    const releaseConsolidationSlot = (aid) => {
+        activeConsolidationAgents.delete(aid);
+        void drainConsolidationQueue();
+    };
+    // 接到前面 finishConsolidationSession 的 holder（那个函数定义在本块之前）
+    releaseConsolidationSlotRef = releaseConsolidationSlot;
+    cmdHandler.setMemoryConsolidationLauncher(enqueueConsolidation);
     const triggerControlToken = crypto.randomBytes(32).toString('base64url');
     fs.writeFileSync(resolvePaths().controlToken, triggerControlToken, { mode: 0o600 });
     try {
@@ -1456,6 +1844,43 @@ async function main() {
             baseagent: agent.baseagent,
         };
     };
+    // 整理会话反馈投递：用发起时抓取的渠道三元组直接调 adapter.send()。
+    // 不查 sessionId——renew/`/new` 换了会话 ID 也不影响送达。
+    const sendConsolidationFeedback = async (origin, text, selfAid) => {
+        const { buildEnvelope } = await import('./core/message/message-utils.js');
+        const channelKey = origin.channelKey;
+        const channelId = origin.channelId;
+        if (!channelKey || !channelId) {
+            logger.warn(`[Memory] 反馈目标缺少 channelKey/channelId，跳过投递`);
+            return;
+        }
+        const binding = getTriggerChannel(selfAid, channelKey);
+        if (!binding) {
+            logger.warn(`[Memory] 找不到渠道绑定（aid=${selfAid}，channelKey=${channelKey}），跳过反馈`);
+            return;
+        }
+        const threadId = origin.threadId;
+        const chatType = origin.delivery?.chatType;
+        const replyContext = {};
+        if (threadId)
+            replyContext.threadId = threadId;
+        if (chatType)
+            replyContext.delivery = { chatType };
+        await binding.adapter.send(buildEnvelope({
+            taskId: `memory-feedback-${Date.now()}`,
+            channel: binding.adapter.channelKey,
+            channelId,
+            agentName: binding.agentName,
+            replyContext: Object.keys(replyContext).length > 0 ? replyContext : undefined,
+        }), {
+            kind: 'result.text',
+            text,
+            isFinal: true,
+            format: 'markdown',
+        });
+        logger.info(`[Memory] 整理反馈已投递（aid=${selfAid}，channelId=${channelId}）`);
+    };
+    sendConsolidationFeedbackRef = sendConsolidationFeedback;
     const validateTriggerFeedbackChannels = (definition) => {
         if (definition.feedback.strategy === 'silent' || definition.feedback.strategy === 'event_session')
             return;
@@ -1496,8 +1921,6 @@ async function main() {
     const hasDaemonTriggerAuthority = (subject) => (subject.isDaemonOwner || subject.processRole === 'daemon-service' || subject.dataScope === 'daemon');
     const validateTriggerDefinitionForActor = (definition, actor) => {
         if (definition.execution.permissionMode === 'fullaccess') {
-            if (!isFullAccessEnabled())
-                throw new Error('fullaccess is disabled by daemon.json');
             if (!actor.daemonOwner && !actor.fullAccess) {
                 throw new Error('persistent fullaccess Trigger requires DaemonOwner or fullaccess-run');
             }
@@ -1556,9 +1979,6 @@ async function main() {
         }
     };
     const authorizeTriggerExecution = (definition) => {
-        if (definition.execution.permissionMode === 'fullaccess' && !isFullAccessEnabled()) {
-            return { allowed: false, reason: 'fullaccess is disabled by daemon.json' };
-        }
         if (definition.execution.permissionMode === 'fullaccess') {
             if (!definition.authorizedBy) {
                 return { allowed: false, reason: 'fullaccess Trigger approval provenance is missing' };
@@ -1575,7 +1995,7 @@ async function main() {
         // task. Its origin remains useful for audit and feedback routing, but a
         // relation lookup on the origin actor would make a cross-Agent Trigger
         // persist successfully and then fail on every fire after creation.
-        // Approval provenance and the feature flag above remain mandatory; only
+        // Approval provenance remains mandatory; only
         // the ordinary creator relation gate is bypassed for this mode.
         if (definition.execution.permissionMode === 'fullaccess') {
             return { allowed: true };
@@ -1763,10 +2183,22 @@ async function main() {
         if (opts.seedUpgradeCheck) {
             seedUpgradeCheckTrigger(manager, owner);
             seedTaskRecoveryTrigger(manager, owner);
+            seedSessionIdleCheckTrigger(manager, owner);
         }
         else {
             removeLegacyAgentUpgradeCheck(manager);
         }
+        // 记忆整理定时检查（每个 agent 一个）。记忆关闭时不注册。
+        const memConfig = agentRegistry.get(owner.aid)?.config?.memory;
+        if (memConfig?.enableRelation !== false) {
+            seedConsolidationCheckTrigger(manager, {
+                aid: owner.aid,
+                cronExpression: consolidationCheckCron(memConfig?.checkIntervalHours),
+            });
+        }
+        else {
+            removeConsolidationCheckTrigger(manager);
+        }
         const state = new TriggerRunStateStore(manager);
         const agentTriggerAudit = triggerAudit.withHistory(manager.history);
         const dispatcher = new TriggerFeedbackDispatcher({
@@ -2048,6 +2480,12 @@ async function main() {
                 };
             });
         }
+        if (inst.channelType === 'aun') {
+            inst.channel.setObserverHintRuntime({
+                hasSession: target => responseEngine.hasObserverTargetSession(target),
+                schedule: target => responseEngine.scheduleObserverHint(target),
+            });
+        }
         // 5. 撤回消息 → 中断执行中任务
         inst.channel.onRecall?.((messageId, selfAID) => {
             msgBridge.cancel(messageId, selfAID);
@@ -2068,6 +2506,19 @@ async function main() {
             agent.status = 'running';
         }
     }
+    // 为所有已置为 running 的 agent 注册技能目录监控（懒加载机制）
+    // 必须在 agent.status = 'running' 之后执行，否则全部还是 'stopped'
+    try {
+        const { watchAgentSkills } = await import('./core/skill/startup.js');
+        for (const info of agentRegistry.list()) {
+            if (info.status === 'running') {
+                watchAgentSkills(info.aid);
+            }
+        }
+    }
+    catch (e) {
+        logger.warn(`[skill] agent 监控注册失败: ${e instanceof Error ? e.message : String(e)}`);
+    }
     if (agentRegistry.list().some((info) => info.status === 'running')) {
         agentRuntimeState = 'running';
         agentRuntimeError = undefined;
@@ -2278,10 +2729,23 @@ async function main() {
         })
             .join(', ');
     };
+    // ChannelLoader deliberately does not await onConnected. Keep the initial
+    // recovery promises so restored ordinary messages cannot start ahead of
+    // pending priority hints for the same session.
+    const startupObserverRecoveries = [];
+    let restoringStartupQueue = true;
+    const queuePendingObserverHints = (aid, channelKey) => pendingInterruptHints(paths.sessionsDir, aid)
+        .filter(pending => pending.channelKey === channelKey)
+        .map(pending => responseEngine.scheduleObserverHint({ ...pending, selfAid: aid })
+        .then(result => {
+        if (result === 'SESSION_NOT_FOUND')
+            logger.warn(`[ObserverHint] recovery target missing hint=${pending.hintId}`);
+    })
+        .catch(error => logger.warn(`[ObserverHint] recovery failed hint=${pending.hintId}: ${error}`)));
     const markChannelConnected = async (inst) => {
         const name = inst.adapter.channelName;
         const key = inst.adapter.channelKey;
-        if (connectedChannels.has(name))
+        if (connectedChannels.has(key))
             return;
         connectedChannels.add(name);
         connectedChannels.add(key);
@@ -2294,6 +2758,11 @@ async function main() {
         });
         // Run async operations in parallel
         const agent = agentRegistry.resolveByChannel(inst.adapter.channelKey) ?? agentRegistry.resolveByChannel(name);
+        if (inst.channelType === 'aun' && agent) {
+            const recoveries = queuePendingObserverHints(agent.aid, key);
+            if (restoringStartupQueue)
+                startupObserverRecoveries.push(...recoveries);
+        }
         await Promise.all([
             bootstrapService.tryStartBootstrap({
                 adapter: inst.adapter,
@@ -2441,6 +2910,7 @@ async function main() {
             logger.warn(`[startup] trigger scheduler start failed for ${agent.aid}: ${e}`);
         })),
     ]);
+    sessionIdleMonitor.activate();
     // ── 控制 AID（daemon 进程身份）：pureIdentity 接入 AUN，独立于 evolagent ──
     // 证书缺失检测/生成在 CLI 侧（ec start）完成。daemon 是后台进程无终端，
     // 这里只做兜底：证书缺失时 warn 并继续（AUNChannel 内部后台重连），绝不阻塞。
@@ -2500,11 +2970,11 @@ async function main() {
                     parsed = null;
                 }
                 const menuResponseContext = () => ({
-                    ...controlReplyContext(opts, evolMenuResponseTransportMetadata(opts.protectedHeaders?.sdk_version)),
+                    ...controlReplyContext(opts, evolMenuResponseTransportMetadata(opts.protectedHeaders?.sdk_version, opts.protectedHeaders?.menu_volatile_v1)),
                     ...(opts.peerDeviceId ? { toDeviceId: opts.peerDeviceId } : {}),
                 });
                 const sendControlMenuResponse = async (response) => {
-                    const timedResponse = withMenuProcessingTime(enforceMenuResponseSize(response, 128 * 1024 - 1024), menuTiming);
+                    const timedResponse = withMenuProcessingTime(enforceMenuResponseSize(response, MENU_RESPONSE_MAX_BYTES - MENU_RESPONSE_SAFETY_MARGIN_BYTES), menuTiming);
                     const request = activeMenuRequest ?? {
                         type: 'menu.unknown',
                         id: response.id,
@@ -2715,6 +3185,19 @@ async function main() {
     }
     const recoverHandoffsAndStartRestored = async () => {
         try {
+            // Recovery must not require the gateway to connect: pending interrupt
+            // hints are local durable work, while ordinary restored input may run
+            // even when its channel is offline. Scheduling twice is deduplicated by
+            // the ResponseEngine's per-session hint key.
+            for (const inst of channelInstances) {
+                if (inst.channelType !== 'aun')
+                    continue;
+                const agent = agentRegistry.resolveByChannel(inst.adapter.channelKey);
+                if (agent && recoveryAids.includes(agent.aid)) {
+                    startupObserverRecoveries.push(...queuePendingObserverHints(agent.aid, inst.adapter.channelKey));
+                }
+            }
+            await Promise.all(startupObserverRecoveries);
             const outcomes = await Promise.allSettled(recoveryAids.map(aid => handoffRuntime.recover([aid])));
             outcomes.forEach((outcome, index) => {
                 if (outcome.status === 'rejected') {
@@ -2723,6 +3206,8 @@ async function main() {
             });
         }
         finally {
+            restoringStartupQueue = false;
+            startupObserverRecoveries.length = 0;
             messageQueue.startRestored();
         }
     };
@@ -2976,6 +3461,22 @@ async function main() {
             aidStatsCollector.recordOutbound(params.aid, params.toPeer, Buffer.byteLength(params.text || '', 'utf-8'), params.text, false, params.encrypt, params.chatmode, 'send');
         });
         ipcServer.setTaskRuntimeContextProvider(({ sessionId }) => responseEngine.getTaskRuntimeContext(sessionId));
+        // `ec memory ... --debug <sessionId>`：仅开发仓安装从会话文件重建上下文，正式安装不注册
+        if (isLinkedInstall()) {
+            ipcServer.setDebugTaskRuntimeContextProvider(async ({ sessionId }) => {
+                const session = await sessionManager.getSessionById(sessionId);
+                if (!session)
+                    return null;
+                const { buildDebugTaskContext } = await import('./core/memory/launch-consolidation.js');
+                const { ensureSessionRuntimeDir } = await import('./cli/task-context.js');
+                return buildDebugTaskContext({
+                    session,
+                    getTrigger: (agentAid, triggerId) => new TriggerDefinitionManager(agentAid).get(triggerId),
+                    sessionRuntimeDir: ensureSessionRuntimeDir(session.id),
+                });
+            });
+            logger.info('[Memory] 开发仓安装：已启用 ec memory --debug <sessionId>');
+        }
         ipcServer.setTaskRuntimeContextAuthorizer(({ sessionId, delegationToken, delegationCommandHash }) => {
             // Codex persistent threads carry a command-scoped authorization. Looking
             // up fresh routing context must not consume the subsequent CLI operation.
@@ -3440,6 +3941,119 @@ async function main() {
             },
         });
         ipcServer.setAgentReloadExecutor((aid, options) => reloadCoordinator.reload(aid, options));
+        // ── 记忆整理定时检查（v4）：候选检查在 daemon 侧，定时由 cron script trigger 驱动 ──
+        //
+        // 脚本（consolidation-trigger.ts 生成）调 `memory.check-consolidation`，
+        // 本 executor 跑候选检查并把命中的候选经 enqueueConsolidation 入队。
+        ipcServer.setConsolidationCheckExecutor(async ({ selfAid }) => {
+            const { checkConsolidationCandidates, shouldUseMetaIndex } = await import('./core/memory/consolidation-trigger.js');
+            const agentConfig = agentRegistry.get(selfAid)?.config;
+            if (agentConfig?.memory?.enableRelation === false)
+                return { launched: [] };
+            const ownerAid = agentConfig?.owners?.[0];
+            // 规模决定扫描路径：agent 数 × 本 agent 关系数超过阈值才走 _meta.json 快路径。
+            const agentCount = agentRegistry.runnableAgents().length;
+            const relationsDir = path.join(agentDir(selfAid), 'relations');
+            let relationCount = 0;
+            try {
+                relationCount = fs.existsSync(relationsDir)
+                    ? fs.readdirSync(relationsDir, { withFileTypes: true }).filter(d => d.isDirectory()).length
+                    : 0;
+            }
+            catch { /* ignore */ }
+            const useMetaIndex = shouldUseMetaIndex(agentCount, relationCount);
+            const candidates = checkConsolidationCandidates({
+                selfAid,
+                ownerAid,
+                config: agentConfig?.memory,
+                useMetaIndex,
+            });
+            const launched = [];
+            for (const candidate of candidates) {
+                // 定时没有会话上下文，用 agent 级最小上下文（selfAid + peerKey）
+                const taskCtx = {
+                    selfAid,
+                    peerKey: candidate.peerKey,
+                    baseagent: undefined,
+                    sessionId: undefined,
+                };
+                try {
+                    await enqueueConsolidation({
+                        taskCtx,
+                        mode: candidate.mode,
+                        triggeredBy: 'periodic-trigger',
+                        ownerAid,
+                        forgetAfterDays: agentConfig?.memory?.forgetAfterDays,
+                        ...(candidate.scope ? { scopeOverride: candidate.scope } : {}),
+                    });
+                    launched.push({ mode: candidate.mode, ...(candidate.peerKey ? { peerKey: candidate.peerKey } : {}) });
+                }
+                catch (e) {
+                    logger.warn(`[Memory] 定时检查入队失败（aid=${selfAid}，mode=${candidate.mode}）: ${e?.message}`);
+                }
+            }
+            if (launched.length > 0) {
+                logger.info(`[Memory] 定时检查拉起 ${launched.length} 个整理会话（aid=${selfAid}）: ` +
+                    launched.map(l => `${l.mode}${l.peerKey ? `(${l.peerKey})` : ''}`).join(', '));
+            }
+            return { launched };
+        });
+        // ── T17：compact / session-new 节点自动触发 relation 整理 ────────────────
+        // 走统一的 enqueueConsolidation（notes 模式），与手动 consolidate 同一条队列。
+        const triggerRelationConsolidation = async (taskCtx, triggeredBy) => {
+            try {
+                if (!taskCtx?.selfAid || !taskCtx?.peerKey)
+                    return;
+                if (taskCtx.sessionType === 'memory')
+                    return;
+                const mc = agentRegistry?.get(taskCtx.selfAid)?.config?.memory;
+                if (mc?.enableRelation === false)
+                    return;
+                const ownerAid = agentRegistry?.get(taskCtx.selfAid)?.config?.owners?.[0];
+                await enqueueConsolidation({
+                    taskCtx,
+                    mode: 'notes',
+                    triggeredBy,
+                    ownerAid,
+                });
+            }
+            catch (e) {
+                logger.warn(`[MemoryT17] relation 整理触发失败（${triggeredBy}）: ${e?.message}`);
+            }
+        };
+        eventBus.subscribe('runner:compact-start', (event) => {
+            const { sessionId } = event;
+            if (!sessionId)
+                return;
+            const taskCtx = responseEngine.getTaskRuntimeContext(sessionId);
+            void triggerRelationConsolidation(taskCtx, 'compress');
+        });
+        eventBus.subscribe('session:created', (event) => {
+            const ev = event;
+            if (!ev.sourceSessionId)
+                return;
+            // 优先用事件快照构造 taskCtx（不依赖内存 map，renew/`/new` 后旧会话任务可能已结束）；
+            // 快照缺失时回退到内存 map（compact 等路径仍在活动任务内）。
+            let snapshot;
+            if (ev.sourceChannel && ev.sourceChannelId && ev.sourceSelfAid) {
+                // peerKey：群聊用群 ID（channelId），私聊用对端 AID（peerId）。
+                // 与 response-engine 的构造保持一致（见 formatPeerKey 用法）。
+                const peerKeyId = ev.sourceChatType === 'group' ? ev.sourceChannelId : (ev.sourcePeerId ?? ev.sourceChannelId);
+                const peerKey = peerKeyId ? `${ev.sourceChannel}#${encodeURIComponent(peerKeyId)}` : undefined;
+                snapshot = {
+                    sessionId: ev.sourceSessionId,
+                    selfAid: ev.sourceSelfAid,
+                    peerKey,
+                    channel: ev.sourceChannel,
+                    channelId: ev.sourceChannelId,
+                    peerId: ev.sourcePeerId ?? ev.sourceChannelId,
+                    chatType: ev.sourceChatType,
+                    threadId: ev.sourceThreadId,
+                };
+            }
+            const taskCtx = snapshot ?? responseEngine.getTaskRuntimeContext(ev.sourceSessionId);
+            void triggerRelationConsolidation(taskCtx, 'session-new');
+        });
         // Make reload hooks accessible to IPC handler & ctl handler (both run in this process)
         globalThis.__evolcore_reloadHooks = reloadHooks;
         // Hot-load handler: dynamically add a new agent at runtime
@@ -4035,6 +4649,22 @@ async function main() {
                     if (!argv.includes('--owner') && !argv.includes('--owners'))
                         return fail('INITIALIZE_OWNER_MISMATCH', 'Explicit Owner required');
                     const plan = resolveInitializationPlan(argv.slice(1));
+                    if (plan.avatarFile?.startsWith('attachment:')) {
+                        const { readRelationAttachment } = await import('./utils/media-cache.js');
+                        plan.avatarFile = readRelationAttachment(taskAid, delegation.grant.peerKey, plan.avatarFile.slice('attachment:'.length)).attachment.filePath;
+                    }
+                    else if (plan.avatarFile) {
+                        const session = await sessionManager.getSessionById(sessionId);
+                        const candidate = path.resolve(plan.avatarFile);
+                        const roots = [session?.projectPath, delegation.grant.sessionRuntimeDir]
+                            .filter((root) => !!root && path.isAbsolute(root))
+                            .map(root => fs.realpathSync(root));
+                        const real = fs.realpathSync(candidate);
+                        if (!roots.some(root => isSameOrDescendant(real, root)) || isHClassPath(real) || isLClassPath(real)) {
+                            return fail('AVATAR_INVALID', '--avatar-file must be a current project/TMPDIR file or authorized relation attachment');
+                        }
+                        plan.avatarFile = real;
+                    }
                     if (!plan.owners.includes(actor))
                         return fail('INITIALIZE_OWNER_MISMATCH', 'The authenticated requesting Owner must be retained');
                     return { ok: true, result: agentInitializationService.start(plan, actor, parsed.dryRun) };
@@ -4072,6 +4702,8 @@ async function main() {
                     description: value('--description'),
                     type: value('--type'),
                     tags,
+                    avatarFile: value('--avatar-file'),
+                    avatarUrl: value('--avatar-url'),
                     force: argv.includes('--force'),
                 });
                 const validationError = validateAgentCreatePlan(plan);
@@ -4131,7 +4763,33 @@ async function main() {
                     type: plan.type,
                     tags: plan.tags,
                     force: argv.includes('--force'),
+                    avatarFile: value('--avatar-file'),
+                    avatarUrl: value('--avatar-url'),
                 };
+                if (createOptions.avatarFile) {
+                    try {
+                        if (createOptions.avatarFile.startsWith('attachment:')) {
+                            const { readRelationAttachment } = await import('./utils/media-cache.js');
+                            const source = readRelationAttachment(taskAid, delegation.grant.peerKey, createOptions.avatarFile.slice('attachment:'.length));
+                            createOptions.avatarFile = source.attachment.filePath;
+                        }
+                        else {
+                            const session = await sessionManager.getSessionById(sessionId);
+                            const candidate = path.resolve(createOptions.avatarFile);
+                            const roots = [session?.projectPath, delegation.grant.sessionRuntimeDir]
+                                .filter((root) => !!root && path.isAbsolute(root))
+                                .map(root => fs.realpathSync(root));
+                            const real = fs.realpathSync(candidate);
+                            if (!roots.some(root => isSameOrDescendant(real, root)) || isHClassPath(real) || isLClassPath(real)) {
+                                return fail('AVATAR_INVALID', '--avatar-file must be a current project/TMPDIR file or authorized relation attachment');
+                            }
+                            createOptions.avatarFile = real;
+                        }
+                    }
+                    catch (error) {
+                        return fail('AVATAR_INVALID', error instanceof Error ? error.message : String(error));
+                    }
+                }
                 try {
                     const result = agentApplicationService
                         ? await agentApplicationService.create(createOptions)
@@ -4247,6 +4905,36 @@ async function main() {
                 return { ok: false, code: 'INVALID_LOCAL_FILE', error: error instanceof Error ? error.message : String(error) };
             }
         });
+        ipcServer.setConsolidationLaunchExecutor(async (params) => {
+            const selfAid = params.taskCtx.selfAid;
+            if (!selfAid)
+                throw new Error('无法确定当前 agent AID（selfAid 为空）');
+            // 手动触发也走统一队列：不忙时立即启动并拿回结果，忙时入队。
+            const launched = await enqueueConsolidation(params);
+            if (!launched) {
+                // 已入队：返回一个占位结果，告知调用方稍后执行
+                return { triggerId: '', contextFile: '', contextFilePath: '', logFile: '', batchDir: '', queued: true };
+            }
+            // 写 session-start 记录
+            {
+                const { appendOpsRecord } = await import('./core/memory/consolidation-ops-records.js');
+                appendOpsRecord(launched.batchDir, {
+                    ts: new Date().toISOString(),
+                    op: 'session-start',
+                    sessionId: launched.triggerId,
+                    mode: params.mode,
+                    triggeredBy: params.triggeredBy,
+                });
+            }
+            // 手动触发：等 runner 分配 agentSessionId 后再返回（超时返回已拿到的部分）。
+            // 会话刚创建时只有 executionSessionId，agentSessionId 要等 runner 初始化后才有。
+            const { waitForConsolidationSession } = await import('./core/memory/launch-consolidation.js');
+            const ids = await waitForConsolidationSession({
+                executionSessionId: launched.executionSessionId,
+                readAgentSessionId: async (id) => (await sessionManager.getSessionById(id))?.agentSessionId,
+            });
+            return { ...launched, ...ids };
+        });
         ipcServer.setTriggerExecutor(async (cmd) => {
             const schedulerFor = (agentAid) => {
                 const scheduler = triggerSchedulers.get(agentAid);
@@ -4516,8 +5204,6 @@ async function main() {
                         throw new Error(`trigger not found: ${cmd.triggerId}`);
                     if (cmd.enabled && existing.execution.permissionMode === 'fullaccess') {
                         rejectUnapprovedFullAccessConfiguration(existing, actor);
-                        if (!isFullAccessEnabled())
-                            throw new Error('fullaccess is disabled by daemon.json');
                         if (!actor.daemonOwner && !actor.fullAccess) {
                             throw new Error('enabling a fullaccess Trigger requires a DaemonOwner or fullaccess-run');
                         }
@@ -4652,6 +5338,10 @@ async function main() {
             // 断开插件系统的渠道
             removeGroupInviteConfigListener();
             await shutdownStep('stop group invitation review', () => groupInviteReviewService.dispose());
+            await shutdownStep('stop global skill watcher', async () => {
+                const { stopGlobalSkillWatcher } = await import('./core/skill/global-watcher.js');
+                await stopGlobalSkillWatcher();
+            });
             await shutdownStep('disconnect channels', () => channelLoader.disconnectAll(channelInstances));
             for (const inst of channelInstances) {
                 const type = inst.channelType || inst.adapter.channelName;