evolcore 0.0.28 → 0.0.29

package/dist/ipc.js

@@ -16,10 +16,11 @@ import { getPackageRoot, getWindowsInstanceSocketPathCandidates, normalizeIpcEnd
 import { getProcessStartTime, isSameOrOlderProcess } from './utils/process-introspect.js';
 import { classifyProcessTree, ProcessTreeSampler, readProcessMetrics } from './utils/process-tree-stats.js';
 import { readSystemMemoryUsage } from './utils/system-memory.js';
-import { hashCurrentDelegatedCommand } from './core/auth/agent-delegation.js';
+import { hashCurrentDelegatedCommand, hashDelegatedCommandArgv } from './core/auth/agent-delegation.js';
 import { normalizeAunMentionEntries } from './aun/msg/mention-schema.js';
 import { remoteAccessService } from './core/auth/remote-access-store.js';
 import { setModelCatalogDaemonOwner } from './core/model/model-catalog.js';
+import { RUNTIME_ENVIRONMENT_NAMES, setRuntimeEnvironmentOverride } from './config/runtime-env.js';
 const isWindows = process.platform === 'win32';
 const isNamedPipe = (p) => isWindows && p.toLowerCase().startsWith('\\\\.\\pipe\\');
 const CPU_SAMPLE_INTERVAL_MS = 1000;
@@ -30,6 +31,22 @@ const EVENT_LOOP_LAG_WARN_MS = 100;
 const SAMPLE_WARN_LOG_INTERVAL_MS = 60_000;
 const PROCESS_TREE_WORKER_REQUEST_TIMEOUT_MS = 15_000;
 const finiteTimestamp = (value) => (typeof value === 'number' && Number.isFinite(value) ? value : undefined);
+function parseRuntimeEnvironmentInput(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        return { ok: false, error: 'runtimeEnv must be an object' };
+    }
+    const values = {};
+    for (const name of RUNTIME_ENVIRONMENT_NAMES) {
+        if (!Object.prototype.hasOwnProperty.call(value, name))
+            continue;
+        const item = value[name];
+        if (item !== null && item !== undefined && typeof item !== 'string') {
+            return { ok: false, error: `${name} must be a string or null` };
+        }
+        values[name] = item;
+    }
+    return { ok: true, values };
+}
 const LOCAL_CONTROL_COMMANDS = new Set([
     'bind.begin',
     'bind.status',
@@ -40,6 +57,7 @@ const LOCAL_CONTROL_COMMANDS = new Set([
     'wecom.contact-bind.register',
     'wechat.contact-bind.register',
     'queue-snapshot',
+    'memory.check-consolidation',
     'aun-aid-stats-record-outbound',
     'evolagent.list',
     'evolagent.show',
@@ -146,10 +164,13 @@ export class IpcServer {
     storageAuthorizationExecutor;
     storageUploadExecutor;
     triggerExecutor;
+    consolidationLaunchExecutor;
+    consolidationCheckExecutor;
     bootstrapCompleteExecutor;
     agentReloadExecutor;
     shutdownExecutor;
     taskRuntimeContextProvider;
+    debugTaskRuntimeContextProvider;
     taskRuntimeContextAuthorizer;
     codexPreToolUseExecutor;
     aunMsgSender;
@@ -407,6 +428,14 @@ export class IpcServer {
     setTriggerExecutor(executor) {
         this.triggerExecutor = executor;
     }
+    /** Inject daemon-level consolidation launcher that uses the real trigger scheduler. */
+    setConsolidationLaunchExecutor(executor) {
+        this.consolidationLaunchExecutor = executor;
+    }
+    /** 注入定时检查 executor：跑候选检查并入队（整理队列在 index.ts）。 */
+    setConsolidationCheckExecutor(executor) {
+        this.consolidationCheckExecutor = executor;
+    }
     /** Complete an agent bootstrap in the daemon so disk and runtime state change together. */
     setBootstrapCompleteExecutor(executor) {
         this.bootstrapCompleteExecutor = executor;
@@ -415,6 +444,20 @@ export class IpcServer {
     setTaskRuntimeContextProvider(provider) {
         this.taskRuntimeContextProvider = provider;
     }
+    /** 仅开发仓（npm link）安装注册；正式安装不调用，debug 请求一律走正常路径。 */
+    setDebugTaskRuntimeContextProvider(provider) {
+        this.debugTaskRuntimeContextProvider = provider;
+    }
+    /**
+     * memory 命令取运行时上下文：先查正在运行的任务；没有且请求带 debug 时，
+     * 再由开发仓专用的 provider 从会话文件重建。
+     */
+    async resolveMemoryTaskCtx(sessionId, debug) {
+        const active = this.taskRuntimeContextProvider?.({ sessionId });
+        if (active || !debug || !this.debugTaskRuntimeContextProvider)
+            return active;
+        return this.debugTaskRuntimeContextProvider({ sessionId });
+    }
     setTaskRuntimeContextAuthorizer(authorizer) {
         this.taskRuntimeContextAuthorizer = authorizer;
     }
@@ -1406,6 +1449,330 @@ export class IpcServer {
                     return { ok: false, error: 'missing cmd or sessionId' };
                 return await this.commandExecutor(slashCmd, sessionId, typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined, typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined);
             }
+            case 'memory.note': {
+                const { sessionId, slug, content, tags, speakers } = cmd;
+                if (!sessionId)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId' };
+                if (typeof slug !== 'string' || !slug)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing slug' };
+                if (typeof content !== 'string' || !content)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing content' };
+                try {
+                    const taskCtx = await this.resolveMemoryTaskCtx(sessionId, cmd.debug === true);
+                    if (!taskCtx)
+                        return { ok: false, code: 'SESSION_NOT_FOUND', error: `未找到会话 ${sessionId} 的运行时上下文` };
+                    const memoryConfig = taskCtx.selfAid
+                        ? this.agentRegistry?.get(taskCtx.selfAid)?.config?.memory
+                        : undefined;
+                    const { writeMemoryNote } = await import('./core/memory/memory-writer.js');
+                    return await writeMemoryNote({
+                        content, slug,
+                        tags: Array.isArray(tags) ? tags : undefined,
+                        speakers: Array.isArray(speakers) ? speakers : undefined,
+                        taskCtx, memoryConfig,
+                    });
+                }
+                catch (e) {
+                    return { ok: false, error: e?.message || String(e) };
+                }
+            }
+            case 'memory.note.update': {
+                const { sessionId, slug, newSlug, tags, tagsProvided, content } = cmd;
+                if (!sessionId)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId' };
+                try {
+                    const taskCtx = await this.resolveMemoryTaskCtx(sessionId, cmd.debug === true);
+                    if (!taskCtx)
+                        return { ok: false, code: 'SESSION_NOT_FOUND', error: `未找到会话 ${sessionId} 的运行时上下文` };
+                    const memoryConfig = taskCtx.selfAid
+                        ? this.agentRegistry?.get(taskCtx.selfAid)?.config?.memory
+                        : undefined;
+                    const { updateMemoryNote } = await import('./core/memory/memory-writer.js');
+                    return await updateMemoryNote({
+                        taskCtx, target: slug, newSlug,
+                        tags: tagsProvided ? (Array.isArray(tags) ? tags : []) : undefined,
+                        content, memoryConfig,
+                    });
+                }
+                catch (e) {
+                    return { ok: false, error: e?.message || String(e) };
+                }
+            }
+            case 'memory.note.drop': {
+                const { sessionId, slug } = cmd;
+                if (!sessionId)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId' };
+                try {
+                    const taskCtx = await this.resolveMemoryTaskCtx(sessionId, cmd.debug === true);
+                    if (!taskCtx)
+                        return { ok: false, code: 'SESSION_NOT_FOUND', error: `未找到会话 ${sessionId} 的运行时上下文` };
+                    const memoryConfig = taskCtx.selfAid
+                        ? this.agentRegistry?.get(taskCtx.selfAid)?.config?.memory
+                        : undefined;
+                    const { dropMemoryNote } = await import('./core/memory/memory-writer.js');
+                    return await dropMemoryNote({ taskCtx, target: slug, memoryConfig });
+                }
+                catch (e) {
+                    return { ok: false, error: e?.message || String(e) };
+                }
+            }
+            case 'memory.note.list': {
+                const { sessionId } = cmd;
+                if (!sessionId)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId' };
+                try {
+                    const taskCtx = await this.resolveMemoryTaskCtx(sessionId, cmd.debug === true);
+                    if (!taskCtx)
+                        return { ok: false, code: 'SESSION_NOT_FOUND', error: `未找到会话 ${sessionId} 的运行时上下文` };
+                    const memoryConfig = taskCtx.selfAid
+                        ? this.agentRegistry?.get(taskCtx.selfAid)?.config?.memory
+                        : undefined;
+                    const { listMemoryNotes } = await import('./core/memory/memory-writer.js');
+                    return await listMemoryNotes({ taskCtx, memoryConfig });
+                }
+                catch (e) {
+                    return { ok: false, error: e?.message || String(e) };
+                }
+            }
+            case 'memory.consolidate': {
+                const { sessionId, mode } = cmd;
+                if (!sessionId)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId' };
+                if (!this.taskRuntimeContextProvider)
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'task runtime context not configured' };
+                try {
+                    const { CONSOLIDATION_MODES } = await import('./core/memory/consolidation-context.js');
+                    const effectiveMode = (mode ?? 'notes');
+                    if (!CONSOLIDATION_MODES.includes(effectiveMode)) {
+                        return { ok: false, code: 'INVALID_REQUEST', error: `mode must be one of ${CONSOLIDATION_MODES.join(' / ')}` };
+                    }
+                    const taskCtx = await this.resolveMemoryTaskCtx(sessionId, cmd.debug === true);
+                    if (!taskCtx)
+                        return { ok: false, code: 'SESSION_NOT_FOUND', error: `未找到会话 ${sessionId} 的运行时上下文` };
+                    const mc = this.agentRegistry?.get(taskCtx.selfAid ?? '')?.config?.memory;
+                    const disabled = this.checkMemoryEnabled(mc, effectiveMode, taskCtx);
+                    if (disabled)
+                        return disabled;
+                    const ownerAid = taskCtx.selfAid
+                        ? this.agentRegistry?.get(taskCtx.selfAid)?.config?.owners?.[0]
+                        : undefined;
+                    const { launchConsolidation } = await import('./core/memory/launch-consolidation.js');
+                    if (!this.consolidationLaunchExecutor) {
+                        // daemon 未注入 launcher —— 无法直接创建整理会话，明确报错而不是静默失败
+                        return { ok: false, code: 'NOT_CONFIGURED', error: 'daemon 未注入整理会话 launcher' };
+                    }
+                    const r = await this.consolidationLaunchExecutor({
+                        taskCtx,
+                        mode: effectiveMode,
+                        triggeredBy: 'manual',
+                        ownerAid,
+                        forgetAfterDays: mc?.forgetAfterDays,
+                    });
+                    return {
+                        ok: true,
+                        triggerId: r.triggerId,
+                        executionSessionId: r.executionSessionId,
+                        agentSessionId: r.agentSessionId,
+                        contextFile: r.contextFile,
+                        contextFilePath: r.contextFilePath,
+                        ...(r.logFile ? { logFile: r.logFile } : {}),
+                        mode: effectiveMode,
+                    };
+                }
+                catch (e) {
+                    return { ok: false, error: e?.message || String(e) };
+                }
+            }
+            case 'memory.create': {
+                const { sessionId, scope, slug, description, content, tags, keywords, replaces, targetPeerKey, generalizedFrom, promotedFrom } = cmd;
+                if (!sessionId)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId' };
+                try {
+                    const guard = await this.assertMemoryWriteSession(sessionId, scope, 'create', replaces, cmd.debug === true);
+                    if ('error' in guard)
+                        return guard.error;
+                    const { createMemory } = await import('./core/memory/memory-writer.js');
+                    const { appendOpsRecord } = await import('./core/memory/consolidation-ops-records.js');
+                    let createResult;
+                    try {
+                        createResult = await createMemory({
+                            taskCtx: guard.taskCtx,
+                            scope: scope,
+                            ownerAid: guard.ownerAid,
+                            slug, description, content,
+                            tags: Array.isArray(tags) ? tags : [],
+                            keywords: Array.isArray(keywords) ? keywords : undefined,
+                            replaces: Array.isArray(replaces) ? replaces : undefined,
+                            targetPeerKey: typeof targetPeerKey === 'string' ? targetPeerKey : undefined,
+                            generalizedFrom: typeof generalizedFrom === 'string' ? generalizedFrom : undefined,
+                            promotedFrom: typeof promotedFrom === 'string' ? promotedFrom : undefined,
+                        });
+                    }
+                    catch (e) {
+                        const batchDir = guard.taskCtx.consolidationBatchDir;
+                        if (batchDir)
+                            appendOpsRecord(batchDir, { ts: new Date().toISOString(), op: 'create', scope: scope ?? '', target: slug ?? '', ok: false, error: e?.message });
+                        throw e;
+                    }
+                    const batchDir = guard.taskCtx.consolidationBatchDir;
+                    if (batchDir)
+                        appendOpsRecord(batchDir, { ts: new Date().toISOString(), op: 'create', scope: scope ?? '', target: slug ?? '', filePath: createResult.filePath, archivedFiles: createResult.archived.map((dest, i) => ({ source: (Array.isArray(replaces) ? replaces : [])[i] ?? dest, archivedTo: dest })), tags: Array.isArray(tags) ? tags : [], memoryDir: createResult.scopeDirs.memoryDir, ok: true });
+                    return { ok: true, filePath: createResult.filePath, archived: createResult.archived };
+                }
+                catch (e) {
+                    return { ok: false, error: e?.message || String(e) };
+                }
+            }
+            case 'memory.update': {
+                const { sessionId, filePath, tags, touch } = cmd;
+                if (!sessionId)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId' };
+                try {
+                    const guard = await this.assertMemoryWriteSession(sessionId, undefined, 'update', undefined, cmd.debug === true);
+                    if ('error' in guard)
+                        return guard.error;
+                    const { updateMemory } = await import('./core/memory/memory-writer.js');
+                    const { appendOpsRecord } = await import('./core/memory/consolidation-ops-records.js');
+                    let updateResult;
+                    try {
+                        updateResult = await updateMemory({
+                            taskCtx: guard.taskCtx,
+                            scope: guard.writeScope,
+                            ownerAid: guard.ownerAid,
+                            target: filePath,
+                            tags: Array.isArray(tags) ? tags : undefined,
+                            touch: !!touch,
+                        });
+                    }
+                    catch (e) {
+                        const batchDir = guard.taskCtx.consolidationBatchDir;
+                        if (batchDir)
+                            appendOpsRecord(batchDir, { ts: new Date().toISOString(), op: 'update', scope: guard.writeScope, target: filePath ?? '', ok: false, error: e?.message });
+                        throw e;
+                    }
+                    const batchDirU = guard.taskCtx.consolidationBatchDir;
+                    if (batchDirU)
+                        appendOpsRecord(batchDirU, { ts: new Date().toISOString(), op: 'update', scope: guard.writeScope, target: filePath ?? '', tags: Array.isArray(tags) ? tags : undefined, prevTags: updateResult.prevTags, memoryDir: updateResult.scopeDirs.memoryDir, ok: true });
+                    return { ok: true, filePath: updateResult.filePath };
+                }
+                catch (e) {
+                    return { ok: false, error: e?.message || String(e) };
+                }
+            }
+            case 'memory.archive': {
+                const { sessionId, filePaths } = cmd;
+                if (!sessionId)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId' };
+                try {
+                    const guard = await this.assertMemoryWriteSession(sessionId, undefined, 'archive', undefined, cmd.debug === true);
+                    if ('error' in guard)
+                        return guard.error;
+                    const { archiveMemory } = await import('./core/memory/memory-writer.js');
+                    const { appendOpsRecord } = await import('./core/memory/consolidation-ops-records.js');
+                    let archiveResult;
+                    try {
+                        archiveResult = await archiveMemory({
+                            taskCtx: guard.taskCtx,
+                            scope: guard.writeScope,
+                            ownerAid: guard.ownerAid,
+                            targets: Array.isArray(filePaths) ? filePaths : [],
+                        });
+                    }
+                    catch (e) {
+                        const batchDir = guard.taskCtx.consolidationBatchDir;
+                        if (batchDir)
+                            appendOpsRecord(batchDir, { ts: new Date().toISOString(), op: 'archive', scope: guard.writeScope, target: (Array.isArray(filePaths) ? filePaths : []).join(', '), ok: false, error: e?.message });
+                        throw e;
+                    }
+                    const batchDirA = guard.taskCtx.consolidationBatchDir;
+                    if (batchDirA) {
+                        for (let i = 0; i < archiveResult.archived.length; i++) {
+                            const archivedTo = archiveResult.archived[i];
+                            const sourceFile = (Array.isArray(filePaths) ? filePaths : [])[i] ?? archivedTo;
+                            appendOpsRecord(batchDirA, { ts: new Date().toISOString(), op: 'archive', scope: guard.writeScope, target: archivedTo, sourceFile, archivedTo, memoryDir: archiveResult.scopeDirs.memoryDir, ok: true });
+                        }
+                    }
+                    return { ok: true, archived: archiveResult.archived };
+                }
+                catch (e) {
+                    return { ok: false, error: e?.message || String(e) };
+                }
+            }
+            case 'memory.demote': {
+                const { sessionId, slug, scope } = cmd;
+                if (!sessionId)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId' };
+                try {
+                    const taskCtx = await this.resolveMemoryTaskCtx(sessionId, cmd.debug === true);
+                    if (!taskCtx)
+                        return { ok: false, code: 'SESSION_NOT_FOUND', error: `未找到会话 ${sessionId} 的运行时上下文` };
+                    if (scope !== 'agent' && scope !== 'owner') {
+                        return { ok: false, code: 'INVALID_REQUEST', error: 'scope 必须是 agent 或 owner' };
+                    }
+                    const { demoteMemory } = await import('./core/memory/memory-writer.js');
+                    const ownerAid = taskCtx.ownerAid;
+                    const result = await demoteMemory({ taskCtx, slug, scope: scope, ownerAid });
+                    await this.rebuildMemoryIndexFor(taskCtx, result.srcScopeDirs, ownerAid);
+                    // 重建目标层索引：从 destMemoryDir 推导出 consolidatedDir 和 memoryDir
+                    const destConsolidatedDir = path.join(result.destMemoryDir, 'consolidated');
+                    await this.rebuildMemoryIndexFor(taskCtx, { memoryDir: result.destMemoryDir, consolidatedDir: destConsolidatedDir }, ownerAid);
+                    return {
+                        ok: true,
+                        destPath: result.destPath,
+                        ...(result.conflictArchived ? { conflictArchived: result.conflictArchived, note: '目标层已有同名文件，当前记忆已归档' } : {}),
+                    };
+                }
+                catch (e) {
+                    return { ok: false, error: e?.message || String(e) };
+                }
+            }
+            case 'memory.check-consolidation': {
+                const { selfAid } = cmd;
+                if (typeof selfAid !== 'string' || !selfAid) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing selfAid' };
+                }
+                if (!this.consolidationCheckExecutor) {
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'daemon 未注入整理检查 executor' };
+                }
+                try {
+                    const result = await this.consolidationCheckExecutor({ selfAid });
+                    return { ok: true, ...result };
+                }
+                catch (e) {
+                    return { ok: false, error: e?.message || String(e) };
+                }
+            }
+            case 'memory.feedback': {
+                const { sessionId, text } = cmd;
+                if (!sessionId)
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId' };
+                if (typeof text !== 'string' || !text.trim()) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing feedback text' };
+                }
+                try {
+                    const taskCtx = await this.resolveMemoryTaskCtx(sessionId, cmd.debug === true);
+                    if (!taskCtx)
+                        return { ok: false, code: 'SESSION_NOT_FOUND', error: `未找到会话 ${sessionId} 的运行时上下文` };
+                    // 只有整理会话可以记录反馈
+                    if (taskCtx.sessionType !== 'memory') {
+                        return { ok: false, code: 'NOT_MEMORY_SESSION', error: '`ec memory feedback` 只能在整理会话内调用' };
+                    }
+                    const batchDir = taskCtx.consolidationBatchDir;
+                    if (!batchDir) {
+                        return { ok: false, code: 'BATCH_DIR_NOT_FOUND', error: '整理会话缺少 consolidationBatchDir' };
+                    }
+                    const { appendOpsRecord } = await import('./core/memory/consolidation-ops-records.js');
+                    appendOpsRecord(batchDir, {
+                        ts: new Date().toISOString(),
+                        op: 'feedback-set',
+                        text,
+                    });
+                    return { ok: true };
+                }
+                catch (e) {
+                    return { ok: false, error: e?.message || String(e) };
+                }
+            }
             case 'config.op': {
                 if (!this.configOperationExecutor)
                     return { ok: false, code: 'NOT_CONFIGURED', error: 'config.op not configured' };
@@ -1568,6 +1935,12 @@ export class IpcServer {
                 const name = cmd.name;
                 if (!name || typeof name !== 'string')
                     return { ok: false, error: 'missing name' };
+                const runtimeEnv = cmd.runtimeEnv === undefined ? undefined : parseRuntimeEnvironmentInput(cmd.runtimeEnv);
+                if (runtimeEnv && !runtimeEnv.ok)
+                    return { ok: false, code: 'INVALID_REQUEST', error: runtimeEnv.error };
+                const target = this.agentRegistry?.get(name);
+                if (runtimeEnv?.ok && target)
+                    setRuntimeEnvironmentOverride(target.aid, runtimeEnv.values);
                 if (this.agentApplicationService) {
                     const result = await this.agentApplicationService.reload(name, { force: cmd.force === true });
                     if (!result.ok) {
@@ -1622,6 +1995,15 @@ export class IpcServer {
                 }
             }
             case 'evolagent.resync': {
+                const runtimeEnv = cmd.runtimeEnv === undefined ? undefined : parseRuntimeEnvironmentInput(cmd.runtimeEnv);
+                if (runtimeEnv && !runtimeEnv.ok)
+                    return { ok: false, code: 'INVALID_REQUEST', error: runtimeEnv.error };
+                if (runtimeEnv?.ok) {
+                    setRuntimeEnvironmentOverride(undefined, runtimeEnv.values);
+                    for (const agent of this.agentRegistry?.list() ?? []) {
+                        setRuntimeEnvironmentOverride(agent.aid, runtimeEnv.values);
+                    }
+                }
                 if (this.agentApplicationService) {
                     const result = await this.agentApplicationService.resync();
                     return result.ok
@@ -1663,6 +2045,15 @@ export class IpcServer {
                     const actorAid = typeof suppliedAuth?.actorAid === 'string' && suppliedAuth.actorAid.trim()
                         ? suppliedAuth.actorAid.trim()
                         : null;
+                    const ecwebRequestId = typeof suppliedAuth?.ecwebRequestId === 'string' && suppliedAuth.ecwebRequestId.trim()
+                        ? suppliedAuth.ecwebRequestId.trim()
+                        : undefined;
+                    const endpoint = typeof suppliedAuth?.endpoint === 'string' && suppliedAuth.endpoint.trim()
+                        ? suppliedAuth.endpoint.trim()
+                        : undefined;
+                    const logicalToolName = typeof suppliedAuth?.logicalToolName === 'string' && suppliedAuth.logicalToolName.trim()
+                        ? suppliedAuth.logicalToolName.trim()
+                        : undefined;
                     const response = await this.menuExecutor(cmd.payload, {
                         source: 'ecweb',
                         // The ECWeb process resolved this actor from its bearer token. The
@@ -1670,6 +2061,9 @@ export class IpcServer {
                         // menu handler still checks that actorAid remains a configured owner.
                         actorAid,
                         localDirect: suppliedAuth?.localDirect === true,
+                        ecwebRequestId,
+                        endpoint,
+                        logicalToolName,
                         // Reaching this handler means the control token gate succeeded.
                         // Never trust an authenticated flag supplied by the caller.
                         authenticated: true,
@@ -1712,6 +2106,164 @@ export class IpcServer {
                 return { error: `unknown command: ${cmd.type}` };
         }
     }
+    // ── 记忆整理辅助 ──────────────────────────────────────────────────────────
+    /**
+     * 检查记忆开关。relation 是总开关：它关闭则整个记忆系统停用。
+     * 返回 null 表示可用，否则返回错误响应。
+     */
+    checkMemoryEnabled(mc, mode, taskCtx) {
+        if (mc?.enableRelation === false) {
+            return { ok: false, code: 'SCOPE_DISABLED', error: '记忆系统已停用（memory.enableRelation=false）' };
+        }
+        if (mode === 'generalize' && mc?.enableAgent === false) {
+            return { ok: false, code: 'SCOPE_DISABLED', error: '泛化模式已停用（memory.enableAgent=false）' };
+        }
+        if (mode === 'promote' && mc?.enableOwner === false) {
+            return { ok: false, code: 'SCOPE_DISABLED', error: '提升模式已停用（memory.enableOwner=false）' };
+        }
+        if (mode === 'promote' && !taskCtx.selfAid) {
+            return { ok: false, code: 'INVALID_REQUEST', error: '无法确定当前 agent AID' };
+        }
+        return null;
+    }
+    /**
+     * 写正式记忆前的会话校验：必须是整理会话（sessionType=memory），
+     * 且模式与作用域匹配。返回授权后的上下文。
+     */
+    async assertMemoryWriteSession(sessionId, requestedScope, op, replaces, debug = false) {
+        if (!this.taskRuntimeContextProvider) {
+            return { error: { ok: false, code: 'NOT_CONFIGURED', error: 'task runtime context not configured' } };
+        }
+        const taskCtx = await this.resolveMemoryTaskCtx(sessionId, debug);
+        if (!taskCtx) {
+            return { error: { ok: false, code: 'SESSION_NOT_FOUND', error: `未找到会话 ${sessionId} 的运行时上下文` } };
+        }
+        // 只有整理会话能写正式记忆
+        const sessionType = taskCtx?.sessionType;
+        if (sessionType !== 'memory') {
+            return {
+                error: {
+                    ok: false, code: 'ROLE_ACCESS_DENIED',
+                    error: `${op} 只能由整理会话（sessionType=memory）调用；主会话请用 \`ec memory note\``,
+                },
+            };
+        }
+        const mode = taskCtx?.memoryMode;
+        const { MODE_SCOPE, CONSOLIDATION_MODES } = await import('./core/memory/consolidation-context.js');
+        if (!mode || !CONSOLIDATION_MODES.includes(mode)) {
+            return { error: { ok: false, code: 'INVALID_REQUEST', error: '当前会话没有有效的 memoryMode' } };
+        }
+        // forget 是分层审查：一次会话只审一层，允许写哪个作用域取决于会话带下来的
+        // memoryScope（关系级索引重建 → relation；agent 级 → agent；owner 级 → owner）。
+        // 其余四种模式由 MODE_SCOPE 唯一决定。
+        const sessionScope = taskCtx?.memoryScope;
+        const allowed = mode === 'forget' ? sessionScope : MODE_SCOPE[mode];
+        if (!allowed) {
+            return {
+                error: {
+                    ok: false, code: 'INVALID_REQUEST',
+                    error: mode === 'forget'
+                        ? 'forget 会话缺少 memoryScope，无法确定该写哪个作用域'
+                        : `${mode} 模式没有可写作用域`,
+                },
+            };
+        }
+        if (op === 'create' && requestedScope !== allowed) {
+            return {
+                error: {
+                    ok: false, code: 'ROLE_ACCESS_DENIED',
+                    error: `${mode} 模式只能写 --scope ${allowed}，收到 ${requestedScope ?? '(空)'}`,
+                },
+            };
+        }
+        // 二次查开关
+        const mc = this.agentRegistry?.get(taskCtx.selfAid ?? '')?.config?.memory;
+        const disabled = this.checkMemoryEnabled(mc, mode, taskCtx);
+        if (disabled)
+            return { error: disabled };
+        const ownerAid = taskCtx.selfAid
+            ? this.agentRegistry?.get(taskCtx.selfAid)?.config?.owners?.[0]
+            : undefined;
+        if (allowed === 'owner' && !ownerAid) {
+            return { error: { ok: false, code: 'INVALID_REQUEST', error: '当前 agent 未配置 owner' } };
+        }
+        return { taskCtx, writeScope: allowed, ownerAid };
+    }
+    /** 保存成功后重建对应作用域的索引。失败不影响写入结果。 */
+    async rebuildMemoryIndexFor(taskCtx, dirs, ownerAid) {
+        try {
+            // owner: .../memory/owner/<ownerAid>  → dirname 的 basename 是 'owner'
+            // relation: .../relations/<peerKey>/memory → dirname 的 basename 是 peerKey，不是 'relations'
+            // 用路径段列表判断，比看直接父目录名可靠。
+            const memParts = dirs.memoryDir.split(path.sep);
+            const scope = path.basename(path.dirname(dirs.memoryDir)) === 'owner'
+                ? 'owner'
+                : memParts.includes('relations')
+                    ? 'relation'
+                    : 'agent';
+            const { rebuildIndex } = await import('./core/memory/index-manager.js');
+            const mc = this.agentRegistry?.get(taskCtx.selfAid ?? '')?.config?.memory;
+            const maxBytes = mc?.indexMaxBytes ?? 5 * 1024;
+            const buildResult = await rebuildIndex(dirs.consolidatedDir, path.join(dirs.memoryDir, 'MEMORY.md'), scope, path.join(dirs.memoryDir, 'archive', 'invalid'), undefined, // 验签门控尚未开启，不传 verifyFn
+            maxBytes);
+            // 索引重建后顺手检查这一层有没有超期记忆 —— 有则建触发器拉一个独立的遗忘会话。
+            await this.maybeTriggerForget(taskCtx, scope, dirs.consolidatedDir, mc, buildResult.verifiedFiles);
+        }
+        catch { /* 索引重建失败下次整理时会补上 */ }
+    }
+    /**
+     * 重建索引后检查超期记忆；有到期的就建触发器拉起遗忘会话。
+     *
+     * 判据与定时检查共用 staleness.ts：mtime 决定进不进候选，
+     * updatedAt 决定是否真的交给模型审查。未到期的长期记忆在这里被刷新 mtime（减速）。
+     */
+    async maybeTriggerForget(taskCtx, scope, consolidatedDir, mc, 
+    /** 本次索引重建中验签通过的文件名；其余文件不做审查 */
+    verifiedFiles) {
+        const selfAid = taskCtx.selfAid;
+        if (!selfAid)
+            return;
+        const { collectCandidates, isDueForReview, deferCandidate } = await import('./core/memory/staleness.js');
+        const thresholds = { forgetAfterDays: mc?.forgetAfterDays ?? 3 };
+        const now = Date.now();
+        const verified = new Set(verifiedFiles);
+        let due = 0;
+        try {
+            for (const info of collectCandidates(consolidatedDir, thresholds, now)) {
+                // 验签失败的记忆不审查、不减速、也不进候选
+                if (!verified.has(info.name))
+                    continue;
+                if (isDueForReview(info, thresholds, now))
+                    due++;
+                else {
+                    try {
+                        deferCandidate(info.filePath, now);
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+        }
+        catch {
+            return;
+        }
+        if (due === 0)
+            return;
+        // 该层有超期记忆 → 经统一队列拉独立遗忘会话
+        try {
+            if (!this.consolidationLaunchExecutor)
+                return;
+            const ownerAid = this.agentRegistry?.get(selfAid)?.config?.owners?.[0];
+            await this.consolidationLaunchExecutor({
+                taskCtx,
+                mode: 'forget',
+                triggeredBy: 'manual',
+                ownerAid,
+                forgetAfterDays: mc?.forgetAfterDays,
+                scopeOverride: scope,
+            });
+        }
+        catch { /* 触发失败不影响本次写入结果 */ }
+    }
     hasValidControlToken(value) {
         if (!this.controlToken || typeof value !== 'string')
             return false;
@@ -1789,9 +2341,19 @@ function ipcQueryOnce(socketPath, cmd, timeoutMs = 3000) {
         }
         catch { }
     }
+    const requestArgv = Array.isArray(authenticatedCmd.argv)
+        && authenticatedCmd.argv.every((value) => typeof value === 'string')
+        ? [
+            'ec',
+            ...(authenticatedCmd.type === 'menu-client.request' ? ['menu-client'] : []),
+            ...authenticatedCmd.argv,
+        ]
+        : undefined;
     const delegationCommandHash = typeof authenticatedCmd.delegationToken === 'string'
         && typeof authenticatedCmd.delegationCommandHash !== 'string'
-        ? hashCurrentDelegatedCommand()
+        ? requestArgv
+            ? hashDelegatedCommandArgv(requestArgv)
+            : hashCurrentDelegatedCommand()
         : undefined;
     const request = {
         ...(delegationCommandHash ? { ...authenticatedCmd, delegationCommandHash } : authenticatedCmd),