evolcore 0.0.31 → 0.0.33

package/dist/core/thread/types.js

@@ -0,0 +1 @@
+export {};

package/dist/eck/message-renderer.js

@@ -50,6 +50,8 @@ function renderOneItem(item, sessionVars, sessionCache, contentSentinel) {
     };
     const isOwnerHint = item.kind === 'owner-hint';
     const isHandoff = item.kind === 'handoff';
+    const isThreadContext = item.kind === 'thread-context';
+    const isTriggerMsg = item.kind === 'trigger';
     const handoffPreviousSentinel = `\x00ECMSG-HANDOFF-PREV-${randomUUID()}\x00`;
     const requiredReplacements = (item.handoff?.requiredEntries ?? []).map(entry => ({
         entry,
@@ -131,6 +133,39 @@ function renderOneItem(item, sessionVars, sessionCache, contentSentinel) {
         injectTime: isOwnerHint
             ? formatLocalTime(item.injectTime ?? item.timestamp ?? Date.now(), sessionVars.timezone ? String(sessionVars.timezone) : undefined)
             : undefined,
+        // T4: 跨会话上下文（thread-inbox 注入）
+        isThreadContext,
+        threadContextOriginThreadId: item.threadContext?.originThreadId,
+        threadContextOriginPeer: item.threadContext?.originPeer,
+        threadContextTime: item.timestamp !== undefined
+            ? formatLocalTime(item.timestamp, sessionVars.timezone ? String(sessionVars.timezone) : undefined)
+            : undefined,
+        threadContextGapHasNewMessages: item.threadContext?.gapDetection.hasNewMessages === true,
+        threadContextGapCount: item.threadContext?.gapDetection.count,
+        // M1: 空洞检测失败（来源话题的 messages.jsonl 缺失/损坏）时，gapDetection 保守返回
+        // hasNewMessages=false，与"确实无新消息"渲染结果相同。透出 error 让模板提示"无法检测"，
+        // 避免 agent 把检测失败误读成"来源话题无更新"。
+        threadContextGapError: item.threadContext?.gapDetection.error,
+        threadContextGapRange: (() => {
+            const g = item.threadContext?.gapDetection;
+            if (!g?.hasNewMessages || g.firstTimestamp === undefined || g.lastTimestamp === undefined)
+                return undefined;
+            const tz = sessionVars.timezone ? String(sessionVars.timezone) : undefined;
+            return `${formatLocalTime(g.firstTimestamp, tz)} - ${formatLocalTime(g.lastTimestamp, tz)}`;
+        })(),
+        threadContextTriggerId: item.threadContext?.triggerId,
+        // T9: trigger 消息专属信封变量
+        isTriggerMsg,
+        triggerMsgId: isTriggerMsg ? item.triggerInfo?.triggerId : undefined,
+        triggerMsgName: isTriggerMsg ? item.triggerInfo?.triggerName : undefined,
+        triggerMsgFireTime: isTriggerMsg && item.triggerInfo?.fireTime !== undefined
+            ? formatLocalTime(item.triggerInfo.fireTime, sessionVars.timezone ? String(sessionVars.timezone) : undefined)
+            : undefined,
+        // T10: labels 路由 key（默认 'default'）+ 动态展开 triggerMsgLabel_<key>
+        triggerMsgKind: isTriggerMsg ? (item.triggerInfo?.labels?.kind ?? 'default') : undefined,
+        ...(isTriggerMsg && item.triggerInfo?.labels
+            ? Object.fromEntries(Object.entries(item.triggerInfo.labels).map(([k, v]) => [`triggerMsgLabel_${k}`, v]))
+            : {}),
         // msg send 跨会话一次性上下文
         isHandoff,
         handoffKind: item.handoff?.kind,

package/dist/index.js

@@ -22,7 +22,7 @@ import { createSessionIdentityResolver } from './config/peer-role-resolver.js';
 import { initializeStartupConfig, prepareStartupConfig, recordStartupConfig } from './config/boot-log.js';
 import { CONFIG_SCHEMA_VERSION } from './types.js';
 import { SessionManager } from './core/session/session-manager.js';
-import { SessionIdleMonitor, readRelationSessionIdleSeconds } from './core/session/session-idle-monitor.js';
+import { SessionIdleMonitor, readSessionLoopIdleSeconds } 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';
@@ -426,13 +426,15 @@ async function main() {
         getSessionById: sessionId => sessionManager.getSessionById(sessionId),
         isSessionBusy: sessionId => messageQueue.isProcessing(sessionId) || messageQueue.getQueueLength(sessionId) > 0,
         getSessionIdleTriggerIds: () => triggerSchedulers.sessionIdleTriggerIds(),
-        getSessionIdleSeconds: readRelationSessionIdleSeconds,
+        getSessionIdleSeconds: readSessionLoopIdleSeconds,
         getSessionEncrypt: sessionId => sessionManager.getSessionEncrypt(sessionId),
+        isCurrentMainSession: session => sessionManager.getActiveSessionSync(session.channel, session.channelId)?.id === session.id,
     });
     sessionIdleMonitor.start();
     onConfigWrite(({ target, selector }) => {
-        if (target === ConfigTarget.Relation && selector.self)
-            sessionIdleMonitor.refresh();
+        if (target === ConfigTarget.Relation && selector.self && selector.peerKey) {
+            void sessionIdleMonitor.refreshRelation(selector.self, selector.peerKey);
+        }
     });
     onShutdown(() => sessionIdleMonitor.stop());
     const targetSessionLocks = new TargetSessionLockRegistry();
@@ -490,10 +492,11 @@ async function main() {
         sessionManager,
         getAgent: aid => agentRegistry.get(aid),
         agentMap,
-        releaseSlot: aid => consolidationQueue.release(aid),
+        releaseSlot: (aid, sessionId) => consolidationQueue.release(aid, sessionId),
         enqueueConsolidation,
         sendFeedback: sendConsolidationFeedback,
     });
+    consolidationQueue.setFinalizer(finishConsolidationSession);
     registerConsolidationSessionEvents({
         eventBus,
         permissionGateway,
@@ -640,11 +643,11 @@ async function main() {
         getAgentRuntimeError: () => agentRuntimeError,
         daemonAid: daemonCfg.aid,
         getControlAidState: () => controlChannel?.getAidState(),
-    }), async (cmd, sessionId, delegationToken, delegationCommandHash) => {
+    }), async (argv, sessionId, delegationToken, delegationCommandHash) => {
         const delegation = agentDelegationRegistry.validate(delegationToken, sessionId, delegationCommandHash);
         if (!delegation.ok)
             return { ok: false, code: delegation.code, error: delegation.reason };
-        return cmdHandler.handleCtl(cmd, sessionId, delegation.grant);
+        return cmdHandler.handleManagedCliOperation(argv, sessionId, delegation.grant);
     });
     ipcServer.setDaemonRuntimeEpoch(agentDelegationRegistry.getRuntimeEpoch());
     const { reloadHooks, reloadCoordinator } = createAgentReloadRuntime({

package/dist/ipc.js

@@ -17,10 +17,12 @@ import { getProcessStartTime, isSameOrOlderProcess } from './utils/process-intro
 import { classifyProcessTree, ProcessTreeSampler, readProcessMetrics } from './utils/process-tree-stats.js';
 import { readSystemMemoryUsage } from './utils/system-memory.js';
 import { hashCurrentDelegatedCommand, hashDelegatedCommandArgv } from './core/auth/agent-delegation.js';
+import { resolveSkillRefreshArgv } from './core/skill/command-parser.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';
+import { MAIN_CLI_BIN } from './product.js';
 const isWindows = process.platform === 'win32';
 const isNamedPipe = (p) => isWindows && p.toLowerCase().startsWith('\\\\.\\pipe\\');
 const CPU_SAMPLE_INTERVAL_MS = 1000;
@@ -75,6 +77,16 @@ const LOCAL_CONTROL_COMMANDS = new Set([
     'remote-auth.redeem',
     'remote-auth.validate',
 ]);
+const MEMORY_COMMAND_ENDPOINTS = new Set([
+    'memory.note', 'memory.note.update', 'memory.note.drop', 'memory.note.list',
+    'memory.create', 'memory.update', 'memory.archive', 'memory.demote', 'memory.consolidate', 'memory.feedback',
+]);
+const DELEGATED_ARGV_ENDPOINTS = new Set([
+    'agent.op', 'config.op', 'contact.op', 'aid.op', 'group.op', 'msg.op', 'fs.op',
+    'ctl', 'diag', 'menu-client.request', 'task.resume', 'queue.op', 'storage.auth', 'storage.upload',
+    'trigger.op', 'skill.refresh', 'thread.op', 'local-command-context', 'evolagent.bootstrapComplete', ...MEMORY_COMMAND_ENDPOINTS,
+    'handoff-return', 'handoff-recover-return', 'handoff-status', 'handoff-list', 'handoff-trace',
+]);
 let ipcQuerySequence = 0;
 function ipcLogToken(value, fallback = 'unknown') {
     const token = String(value ?? '').replace(/[^A-Za-z0-9_.:-]/g, '_').slice(0, 128);
@@ -94,9 +106,17 @@ function nextIpcQueryId(cmd) {
 function requiresLocalControlToken(cmd) {
     // Managed calls use task delegation. Standalone queries must not gain
     // management scope merely by omitting (or emptying) sessionId.
-    return cmd.type === 'evolagent.initialize' || LOCAL_CONTROL_COMMANDS.has(String(cmd.type ?? ''))
-        || (['evolagent.bootstrapComplete', 'diag', 'handoff-status', 'handoff-list', 'handoff-trace', 'task.resume'].includes(String(cmd.type))
-            && !(typeof cmd.sessionId === 'string' && cmd.sessionId.trim()));
+    const type = String(cmd.type ?? '');
+    const sessionId = typeof cmd.sessionId === 'string' && cmd.sessionId.trim();
+    const delegated = typeof cmd.delegationToken === 'string' && cmd.delegationToken.trim();
+    if (cmd.type === 'evolagent.initialize' || LOCAL_CONTROL_COMMANDS.has(type))
+        return true;
+    if (type === 'debug-issue-token')
+        return true;
+    if (type === 'skill.refresh' || type === 'thread.op')
+        return !sessionId || !delegated;
+    return ['evolagent.bootstrapComplete', 'diag', 'handoff-status', 'handoff-list', 'handoff-trace', 'task.resume'].includes(type)
+        && !sessionId;
 }
 /** Preserve the pipe DACL and grant only the provisioned Codex users data I/O. */
 function grantWindowsSandboxPipeAccess(endpoint) {
@@ -153,6 +173,7 @@ export class IpcServer {
     aunAidStatsRecorder;
     menuExecutor;
     agentOperationExecutor;
+    skillRefreshExecutor;
     initializationExecutor;
     statsProvider;
     agentStatsProvider;
@@ -171,6 +192,7 @@ export class IpcServer {
     shutdownExecutor;
     taskRuntimeContextProvider;
     debugTaskRuntimeContextProvider;
+    debugIssueTokenExecutor;
     taskRuntimeContextAuthorizer;
     codexPreToolUseExecutor;
     aunMsgSender;
@@ -188,6 +210,7 @@ export class IpcServer {
     groupOperationExecutor;
     msgOperationExecutor;
     fsOperationExecutor;
+    threadOperationExecutor;
     dingtalkContactBindExecutor;
     feishuContactBindExecutor;
     qqbotContactBindExecutor;
@@ -275,6 +298,9 @@ export class IpcServer {
     setAgentOperationExecutor(executor) {
         this.agentOperationExecutor = executor;
     }
+    setSkillRefreshExecutor(executor) {
+        this.skillRefreshExecutor = executor;
+    }
     setConfigOperationExecutor(executor) {
         this.configOperationExecutor = executor;
     }
@@ -293,6 +319,9 @@ export class IpcServer {
     setFsOperationExecutor(executor) {
         this.fsOperationExecutor = executor;
     }
+    setThreadOperationExecutor(executor) {
+        this.threadOperationExecutor = executor;
+    }
     setAgentReloadExecutor(executor) {
         this.agentReloadExecutor = executor;
     }
@@ -428,7 +457,7 @@ export class IpcServer {
     setTriggerExecutor(executor) {
         this.triggerExecutor = executor;
     }
-    /** Inject daemon-level consolidation launcher that uses the real trigger scheduler. */
+    /** Inject daemon-level consolidation launcher (BackgroundSessionLauncher, via executor closure). */
     setConsolidationLaunchExecutor(executor) {
         this.consolidationLaunchExecutor = executor;
     }
@@ -444,15 +473,17 @@ export class IpcServer {
     setTaskRuntimeContextProvider(provider) {
         this.taskRuntimeContextProvider = provider;
     }
-    /** 仅开发仓（npm link）安装注册；正式安装不调用，debug 请求一律走正常路径。 */
     setDebugTaskRuntimeContextProvider(provider) {
         this.debugTaskRuntimeContextProvider = provider;
     }
+    /** debug 模式：注册 debug-issue-token executor，仅 EVOLCORE_DEBUG_MODE=1 时由 index.ts 调用。 */
+    setDebugIssueTokenExecutor(executor) {
+        this.debugIssueTokenExecutor = executor;
+    }
     /**
-     * memory 命令取运行时上下文：先查正在运行的任务；没有且请求带 debug 时，
-     * 再由开发仓专用的 provider 从会话文件重建。
+     * memory 命令取运行时上下文：查正在运行的任务。
      */
-    async resolveMemoryTaskCtx(sessionId, debug) {
+    async resolveMemoryTaskCtx(sessionId, debug = false) {
         const active = this.taskRuntimeContextProvider?.({ sessionId });
         if (active || !debug || !this.debugTaskRuntimeContextProvider)
             return active;
@@ -468,6 +499,14 @@ export class IpcServer {
     setAunMsgSender(sender) {
         this.aunMsgSender = sender;
     }
+    hasAunMsgSender() {
+        return this.aunMsgSender !== undefined;
+    }
+    async sendAunMsg(params) {
+        if (!this.aunMsgSender)
+            throw new Error('aunMsgSender not configured');
+        return this.aunMsgSender(params);
+    }
     setDiagExecutor(executor) { this.diagExecutor = executor; }
     setMenuClientExecutor(executor) { this.menuClientExecutor = executor; }
     /** Inject internal handoff result return executor for `ec handoff return`. */
@@ -917,6 +956,7 @@ export class IpcServer {
         }
         if (typeof cmd.delegationToken === 'string' && cmd.delegationToken
             && this.daemonRuntimeEpoch
+            && cmd.daemonRuntimeEpoch !== undefined
             && cmd.daemonRuntimeEpoch !== this.daemonRuntimeEpoch) {
             logger.warn(`[IPC] stale delegation rejected: session=${ipcLogToken(cmd.sessionId ?? cmd.originSessionId ?? cmd.actorSessionId)} type=${ipcLogToken(cmd.type)} cause=daemon_runtime_epoch_mismatch`);
             return {
@@ -925,6 +965,75 @@ export class IpcServer {
                 error: 'The task delegation token belongs to a previous daemon runtime; start a new task authorization and do not retry this command in the current task',
             };
         }
+        if (typeof cmd.delegationToken === 'string'
+            && (DELEGATED_ARGV_ENDPOINTS.has(cmd.type) || (cmd.type === 'aun-msg-send' && cmd.argv !== undefined))) {
+            if (!Array.isArray(cmd.argv) || cmd.argv.some(value => typeof value !== 'string')) {
+                return { ok: false, code: 'INVALID_REQUEST', error: 'Invalid command argv' };
+            }
+            const expectedHash = hashDelegatedCommandArgv([
+                MAIN_CLI_BIN,
+                ...(cmd.type === 'menu-client.request' ? ['menu-client'] : []),
+                ...cmd.argv,
+            ]);
+            if (!expectedHash || cmd.delegationCommandHash !== expectedHash) {
+                return { ok: false, code: 'INVALID_DELEGATION', error: 'Command hash does not match the submitted argv' };
+            }
+        }
+        if (cmd.argv !== undefined && ['handoff-status', 'handoff-list', 'handoff-trace'].includes(cmd.type)) {
+            try {
+                const { parseList, parseTrace } = await import('./cli/handoff-command.js');
+                if (!Array.isArray(cmd.argv) || cmd.argv[0] !== 'handoff' || `handoff-${cmd.argv[1]}` !== cmd.type) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'Handoff endpoint does not match argv' };
+                }
+                if (cmd.type === 'handoff-list') {
+                    const parsed = parseList(cmd.argv.slice(2));
+                    cmd = { ...cmd, agent: parsed.agent, state: parsed.state, filterSessionId: parsed.sessionId, limit: parsed.limit };
+                }
+                else {
+                    const parsed = parseTrace(cmd.argv.slice(2));
+                    if (cmd.type === 'handoff-status' && cmd.argv.length !== 3)
+                        throw new Error('Invalid handoff status arguments');
+                    cmd = { ...cmd, agent: parsed.agent, handoffId: parsed.handoffId, limit: parsed.limit };
+                }
+            }
+            catch (error) {
+                return { ok: false, code: 'INVALID_ARGUMENT', error: error instanceof Error ? error.message : String(error) };
+            }
+        }
+        if (MEMORY_COMMAND_ENDPOINTS.has(cmd.type)) {
+            if (typeof cmd.sessionId !== 'string' || !cmd.sessionId)
+                return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId' };
+            if (cmd.debug === true) {
+                if (cmd.delegationToken || !this.hasValidControlToken(cmd.controlToken)) {
+                    return { ok: false, code: 'INVALID_CONTROL_TOKEN', error: 'Memory debug requires a local control token, not task delegation' };
+                }
+            }
+            else {
+                if (!this.taskRuntimeContextAuthorizer)
+                    return { ok: false, code: 'DELEGATION_REQUIRED', error: 'Memory authorization is not configured' };
+                if (!Array.isArray(cmd.argv) || cmd.argv.some((value) => typeof value !== 'string') || cmd.argv.includes('--debug')) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'Managed memory requires argv without --debug' };
+                }
+                const authorization = this.taskRuntimeContextAuthorizer({
+                    sessionId: cmd.sessionId, delegationToken: cmd.delegationToken,
+                    delegationCommandHash: cmd.delegationCommandHash, consumeApproval: true,
+                });
+                if (!authorization.ok)
+                    return authorization;
+            }
+            if (cmd.argv !== undefined) {
+                try {
+                    const { resolveMemoryCommandArgv } = await import('./cli/memory-command.js');
+                    const operation = resolveMemoryCommandArgv(cmd.argv);
+                    if (operation.type !== cmd.type)
+                        return { ok: false, code: 'INVALID_REQUEST', error: 'Memory endpoint does not match argv' };
+                    cmd = { ...operation, sessionId: cmd.sessionId, debug: cmd.debug === true };
+                }
+                catch (error) {
+                    return { ok: false, code: 'INVALID_ARGUMENT', error: error instanceof Error ? error.message : String(error) };
+                }
+            }
+        }
         switch (cmd.type) {
             case 'diag':
                 return this.diagExecutor ? this.diagExecutor(cmd) : { ok: false, code: 'NOT_CONFIGURED', message: '诊断入口未配置' };
@@ -1168,6 +1277,7 @@ export class IpcServer {
                     sessionId: cmd.sessionId,
                     delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
                     delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
+                    argv: Array.isArray(cmd.argv) ? cmd.argv : undefined,
                 });
             }
             case 'status.auth': {
@@ -1191,6 +1301,7 @@ export class IpcServer {
                     return { ok: false, code: 'INVALID_REQUEST', error: 'invalid storage operation' };
                 }
                 return await this.storageAuthorizationExecutor({
+                    argv: cmd.argv,
                     sessionId: cmd.sessionId,
                     aid: cmd.aid,
                     operation: cmd.operation,
@@ -1208,6 +1319,7 @@ export class IpcServer {
                     return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId, aid, localFile, or remotePath' };
                 }
                 return await this.storageUploadExecutor({
+                    argv: cmd.argv,
                     sessionId: cmd.sessionId,
                     aid: cmd.aid,
                     localFile: cmd.localFile,
@@ -1235,9 +1347,10 @@ export class IpcServer {
                 }
             }
             case 'task.resume': {
-                const allowed = new Set(['type', 'targetSessionId', 'sessionId', 'delegationToken',
+                const allowed = new Set(['type', 'argv', 'targetSessionId', 'sessionId', 'delegationToken',
                     'delegationCommandHash', 'controlToken', 'daemonRuntimeEpoch', 'requestId', 'id']);
                 if (Object.keys(cmd).some(key => !allowed.has(key))
+                    || (cmd.argv !== undefined && (!Array.isArray(cmd.argv) || cmd.argv.some((value) => typeof value !== 'string')))
                     || typeof cmd.targetSessionId !== 'string' || !cmd.targetSessionId.trim()
                     || (cmd.sessionId !== undefined && (typeof cmd.sessionId !== 'string' || !cmd.sessionId.trim()))) {
                     return { ok: false, code: 'INVALID_REQUEST', error: 'task.resume accepts only a target session and caller credentials' };
@@ -1250,6 +1363,7 @@ export class IpcServer {
                 try {
                     return await this.taskResumeExecutor({
                         targetSessionId: cmd.targetSessionId,
+                        argv: Array.isArray(cmd.argv) ? cmd.argv : undefined,
                         sessionId: cmd.sessionId,
                         delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
                         delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
@@ -1260,6 +1374,34 @@ export class IpcServer {
                     return { ok: false, code: 'TASK_RESUME_FAILED', error: error instanceof Error ? error.message : String(error) };
                 }
             }
+            case 'local-command-context': {
+                if (!Array.isArray(cmd.argv) || cmd.argv.some((value) => typeof value !== 'string')
+                    || !['skill', 'stats'].includes(cmd.argv[0]) || typeof cmd.sessionId !== 'string' || !cmd.sessionId
+                    || typeof cmd.delegationToken !== 'string' || !cmd.delegationToken) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'Local command requires argv and task credentials' };
+                }
+                if (!this.taskRuntimeContextAuthorizer || !this.taskRuntimeContextProvider) {
+                    return { ok: false, code: 'DELEGATION_REQUIRED', error: 'Command authorization is unavailable' };
+                }
+                const authorization = this.taskRuntimeContextAuthorizer({
+                    sessionId: cmd.sessionId, delegationToken: cmd.delegationToken,
+                    delegationCommandHash: cmd.delegationCommandHash, consumeApproval: true,
+                });
+                if (!authorization.ok)
+                    return authorization;
+                const context = this.taskRuntimeContextProvider({ sessionId: cmd.sessionId });
+                if (!context?.selfAid || !context.peerRole || context.peerRole === 'none') {
+                    return { ok: false, code: 'NOT_ALLOWED', error: 'Current task identity and role are unavailable' };
+                }
+                if (cmd.argv[0] === 'stats' && cmd.argv.some((value) => /^--(?:sql|rebuild)(?:=|$)/.test(value))) {
+                    return { ok: false, code: 'NOT_ALLOWED', error: 'Managed stats cannot use --sql or --rebuild' };
+                }
+                if (cmd.argv[0] === 'skill' && context.permissionMode === 'readonly'
+                    && ['create', 'install', 'remove', 'enable', 'disable'].includes(cmd.argv[1])) {
+                    return { ok: false, code: 'NOT_ALLOWED', error: 'Readonly tasks cannot modify skills' };
+                }
+                return { ok: true, context };
+            }
             case 'task-runtime-context': {
                 if (!this.taskRuntimeContextProvider)
                     return { ok: false, error: 'task runtime context not configured' };
@@ -1272,13 +1414,35 @@ export class IpcServer {
                     sessionId: cmd.sessionId,
                     delegationToken: typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined,
                     delegationCommandHash: typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined,
+                    consumeApproval: false,
                 });
                 if (!authorization.ok)
                     return authorization;
                 const context = this.taskRuntimeContextProvider({ sessionId: cmd.sessionId }) ?? null;
                 return { ok: true, context };
             }
+            case 'debug-issue-token': {
+                if (cmd.delegationToken)
+                    return { ok: false, code: 'NOT_ALLOWED', error: 'Managed tasks cannot issue debug tokens' };
+                // 仅 EVOLCORE_DEBUG_MODE=1 时由 index.ts 注册 executor；非 debug 模式直接拒绝
+                if (!this.debugIssueTokenExecutor) {
+                    return { ok: false, error: 'debug mode is not enabled; start daemon with: ec start --debug' };
+                }
+                if (typeof cmd.sessionId !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(cmd.sessionId)) {
+                    return { ok: false, error: 'missing sessionId' };
+                }
+                return this.debugIssueTokenExecutor({ sessionId: cmd.sessionId });
+            }
             case 'aun-msg-send': {
+                if (cmd.argv !== undefined) {
+                    if (!this.aunMsgSender)
+                        return { ok: false, code: 'NOT_CONFIGURED', error: 'AUN sender is not configured' };
+                    return this.aunMsgSender({
+                        aid: '', to: '', scope: 'msg', argv: cmd.argv,
+                        originSessionId: cmd.originSessionId, originMessageId: cmd.originMessageId,
+                        delegationToken: cmd.delegationToken, delegationCommandHash: cmd.delegationCommandHash,
+                    });
+                }
                 if (cmd.handoffContext !== undefined && (typeof cmd.handoffContext !== 'string'
                     || !cmd.handoffContext.trim() || cmd.handoffContext.length > 64 * 1024 || cmd.scope === 'group')) {
                     return { ok: false, code: 'INVALID_HANDOFF_CONTEXT', error: 'Private handoff context must contain 1–65536 characters' };
@@ -1336,7 +1500,6 @@ export class IpcServer {
                             : undefined,
                         encrypt: typeof cmd.encrypt === 'boolean' ? cmd.encrypt : undefined,
                         thread: typeof cmd.thread === 'string' ? cmd.thread : undefined,
-                        returnPolicy: cmd.returnPolicy === 'required' || cmd.returnPolicy === 'none' ? cmd.returnPolicy : undefined,
                         handoffContext: cmd.handoffContext,
                         originSessionId: typeof cmd.originSessionId === 'string' ? cmd.originSessionId : undefined,
                         originMessageId: typeof cmd.originMessageId === 'string' ? cmd.originMessageId : undefined,
@@ -1356,6 +1519,7 @@ export class IpcServer {
                     return { ok: false, code: 'HANDOFF_RETURN_CONTENT_REQUIRED', error: 'missing content' };
                 try {
                     return await this.handoffReturnExecutor({
+                        argv: cmd.argv,
                         sessionId: typeof cmd.sessionId === 'string' ? cmd.sessionId : undefined,
                         handoffId: typeof cmd.handoffId === 'string' ? cmd.handoffId : undefined,
                         content: cmd.content,
@@ -1378,6 +1542,7 @@ export class IpcServer {
                     return { ok: false, code: 'HANDOFF_RETURN_CONTENT_REQUIRED', error: 'missing content' };
                 try {
                     return await this.handoffRecoverReturnExecutor({
+                        argv: cmd.argv,
                         sessionId: cmd.sessionId,
                         handoffId: cmd.handoffId,
                         content: cmd.content,
@@ -1444,10 +1609,13 @@ export class IpcServer {
             case 'ctl': {
                 if (!this.commandExecutor)
                     return { ok: false, error: 'ctl not configured' };
-                const { cmd: slashCmd, sessionId } = cmd;
-                if (!slashCmd || !sessionId)
-                    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);
+                const { sessionId, argv } = cmd;
+                if (!sessionId || !Array.isArray(argv))
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing argv or sessionId' };
+                if (argv.some(value => typeof value !== 'string')) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'Invalid command argv' };
+                }
+                return await this.commandExecutor(argv, 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;
@@ -1577,6 +1745,7 @@ export class IpcServer {
                         contextFilePath: r.contextFilePath,
                         ...(r.logFile ? { logFile: r.logFile } : {}),
                         mode: effectiveMode,
+                        ...(r.queued ? { queued: r.queued } : {}),
                     };
                 }
                 catch (e) {
@@ -1845,6 +2014,16 @@ export class IpcServer {
                 }
                 return await this.fsOperationExecutor(argv, sessionId, delegationToken, typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined);
             }
+            case 'thread.op': {
+                if (!this.threadOperationExecutor)
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'thread.op not configured' };
+                const delegated = typeof cmd.delegationToken === 'string' && cmd.delegationToken.trim();
+                const req = {
+                    ...cmd,
+                    localControl: !delegated && this.hasValidControlToken(cmd.controlToken),
+                };
+                return await this.threadOperationExecutor(req);
+            }
             case 'evolagent.initialize': {
                 if (cmd.sessionId || cmd.delegationToken)
                     return { ok: false, code: 'NOT_ALLOWED', error: 'Managed callers must use agent.op' };
@@ -1864,11 +2043,38 @@ export class IpcServer {
                 }
                 return await this.agentOperationExecutor(argv, sessionId, delegationToken, typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined);
             }
+            case 'skill.refresh': {
+                if (!this.skillRefreshExecutor) {
+                    return { ok: false, code: 'NOT_CONFIGURED', error: 'skill.refresh not configured' };
+                }
+                let { aid } = cmd;
+                const { sessionId, delegationToken } = cmd;
+                if (typeof aid !== 'string' || !aid) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing aid' };
+                }
+                if (sessionId !== undefined && typeof sessionId !== 'string') {
+                    return { ok: false, code: 'INVALID_REQUEST', error: 'sessionId must be a string' };
+                }
+                if (delegationToken !== undefined && typeof delegationToken !== 'string') {
+                    return { ok: false, code: 'INVALID_DELEGATION', error: 'delegationToken must be a string' };
+                }
+                if (sessionId && !delegationToken)
+                    return { ok: false, code: 'DELEGATION_REQUIRED', error: 'Managed skill refresh requires delegation' };
+                try {
+                    if (!Array.isArray(cmd.argv))
+                        throw new Error('Skill refresh requires argv');
+                    aid = resolveSkillRefreshArgv(cmd.argv);
+                }
+                catch (error) {
+                    return { ok: false, code: 'INVALID_REQUEST', error: error instanceof Error ? error.message : String(error) };
+                }
+                return await this.skillRefreshExecutor(aid, sessionId, delegationToken, typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined);
+            }
+            case 'trigger.op':
             case 'trigger.list':
             case 'trigger.show':
             case 'trigger.history':
             case 'trigger.eventCatalog':
-            case 'trigger.authorizeLocalFiles':
             case 'trigger.create':
             case 'trigger.update':
             case 'trigger.setEnabled':
@@ -1917,6 +2123,17 @@ export class IpcServer {
                 const aid = cmd.aid;
                 if (!aid || typeof aid !== 'string')
                     return { ok: false, error: 'missing aid' };
+                if (cmd.argv !== undefined) {
+                    if (!Array.isArray(cmd.argv) || cmd.argv.some((value) => typeof value !== 'string')) {
+                        return { ok: false, code: 'INVALID_REQUEST', error: 'Invalid command argv' };
+                    }
+                    const argv = cmd.argv;
+                    const validFormat = argv.length === 3
+                        || (argv.length === 5 && argv[3] === '--format' && argv[4] === 'json');
+                    if (argv[0] !== 'agent' || argv[1] !== 'ready' || argv[2] !== aid || !validFormat) {
+                        return { ok: false, code: 'INVALID_REQUEST', error: 'agent ready endpoint does not match argv' };
+                    }
+                }
                 if (!this.bootstrapCompleteExecutor)
                     return { ok: false, error: 'bootstrap complete executor not configured' };
                 try {
@@ -2333,7 +2550,7 @@ export async function ipcQuery(socketPath, cmd, timeoutMs = 3000, options = {})
 function ipcQueryOnce(socketPath, cmd, timeoutMs = 3000) {
     let authenticatedCmd = cmd;
     if (!process.env.EVOLCORE_SESSION_ID
-        && requiresLocalControlToken(cmd)
+        && (requiresLocalControlToken(cmd) || (MEMORY_COMMAND_ENDPOINTS.has(cmd.type) && cmd.debug === true))
         && typeof cmd.controlToken !== 'string') {
         try {
             const controlToken = fs.readFileSync(resolvePaths().controlToken, 'utf8').trim();
@@ -2345,7 +2562,7 @@ function ipcQueryOnce(socketPath, cmd, timeoutMs = 3000) {
     const requestArgv = Array.isArray(authenticatedCmd.argv)
         && authenticatedCmd.argv.every((value) => typeof value === 'string')
         ? [
-            'ec',
+            MAIN_CLI_BIN,
             ...(authenticatedCmd.type === 'menu-client.request' ? ['menu-client'] : []),
             ...authenticatedCmd.argv,
         ]

package/dist/paths.js

@@ -208,6 +208,26 @@ export function channelStatePath(channelKey, ...parts) {
 export function agentTriggersDir(aid) {
     return path.join(agentDir(aid), 'triggers');
 }
+/** 话题数据的统一根目录：索引、摘要、续读锚点、跨会话收件箱都收在这里。 */
+export function agentThreadsDir(aid) {
+    return path.join(agentDataDir(aid), 'threads');
+}
+export function agentThreadIndexPath(aid) {
+    return path.join(agentThreadsDir(aid), 'index.json');
+}
+export function agentThreadSummariesDir(aid) {
+    return path.join(agentThreadsDir(aid), 'summaries');
+}
+export function agentThreadSummaryPath(aid, sessionId) {
+    return path.join(agentThreadSummariesDir(aid), `${sessionId}.summary.jsonl`);
+}
+/** Thread Context 收件箱：跨话题发送后在目标会话侧留下的注入提醒。 */
+export function agentThreadInboxDir(aid) {
+    return path.join(agentThreadsDir(aid), 'inbox');
+}
+export function agentThreadInboxPath(aid, targetSessionId) {
+    return path.join(agentThreadInboxDir(aid), `${targetSessionId}.jsonl`);
+}
 function stripTrailingWindowsSeparators(value) {
     const stripped = value.replace(/[\\/]+$/g, '');
     // Keep a drive-root separator. `C:` is a drive-relative path on Windows.
@@ -414,6 +434,9 @@ export function kitsSchemasDir() {
 export function eckDebugDir() {
     return path.join(resolveRoot(), 'data', 'eck-debug');
 }
+export function debugSessionsDir() {
+    return path.join(resolveRoot(), 'data', 'debug-sessions');
+}
 export function getPackageRoot() {
     // import.meta.dirname is available in Node.js 21.2+ and always returns
     // the correct OS-native path, regardless of Git Bash or MSYS2 environment.