evolcore 0.0.4 → 0.0.6

package/dist/core/session/session-manager.js

@@ -1,7 +1,7 @@
 import { ensureDir } from '../../utils/atomic-write.js';
 import { logger } from '../../utils/logger.js';
 import { encodePath } from '../../utils/cross-platform.js';
-import { chatDirPath, generateSessionId, formatTimestamp, atomicWriteJson, appendJsonl, readJsonFile, readLastJsonlLine, readAllJsonlLines, scanChatDirs, scanMetaFiles, ensureChatDir, readThreadIndex, writeThreadIndex, } from './session-fs-store.js';
+import { chatDirPath, generateSessionId, formatTimestamp, atomicWriteJson, atomicWriteText, appendJsonl, readJsonFile, readLastJsonlLine, readAllJsonlLines, scanChatDirs, scanMetaFiles, ensureChatDir, readThreadIndex, writeThreadIndex, } from './session-fs-store.js';
 import { sessionToFile, fileToSession } from './session-mapper.js';
 import { formatSessionKey, DEFAULT_THREAD_ID } from './session-key.js';
 import { tryParseChannelKey } from '../channel-loader.js';
@@ -38,8 +38,6 @@ export class SessionManager {
         this.sessionsDir = sessionsDir;
         this.eventBus = eventBus;
         this.identityResolver = identityResolver;
-        this.migrateChannelKeyFormat();
-        this.migrateWecomChannelDirs();
     }
     setIdentityResolver(resolver) {
         this.identityResolver = resolver;
@@ -378,7 +376,7 @@ export class SessionManager {
             logger.error(`[SessionManager] validateSessionFile: no adapter for baseagent=${session.baseagent}, session=${session.id}`);
             return agentSessionId;
         }
-        if (adapter.checkExists(session.projectPath, agentSessionId))
+        if (adapter.checkExists(session.projectPath, agentSessionId, session.selfAID))
             return agentSessionId;
         logger.warn(`Session file not found for ${session.baseagent}: ${agentSessionId}, clearing session ID`);
         session.agentSessionId = undefined;
@@ -1315,16 +1313,16 @@ export class SessionManager {
         });
         return session;
     }
-    async scanCliSessions(projectPath, baseagent, limit = 10) {
+    async scanCliSessions(projectPath, baseagent, limit = 10, agentAid) {
         const adapter = this.getFileAdapter(baseagent);
         if (!adapter)
             return [];
-        return adapter.scanCliSessions(projectPath, limit);
+        return adapter.scanCliSessions(projectPath, limit, agentAid);
     }
-    async listImportableCliSessions(projectPath, baseagent) {
+    async listImportableCliSessions(projectPath, baseagent, agentAid) {
         const boundSessionIds = this.listBoundAgentSessionIds(projectPath, baseagent);
         const displayLimit = 10;
-        const cliSessions = await this.scanCliSessions(projectPath, baseagent, boundSessionIds.size + displayLimit);
+        const cliSessions = await this.scanCliSessions(projectPath, baseagent, boundSessionIds.size + displayLimit, agentAid);
         return cliSessions
             .filter(session => !boundSessionIds.has(session.uuid))
             .slice(0, displayLimit);
@@ -1343,25 +1341,25 @@ export class SessionManager {
         }
         return sessionIds;
     }
-    checkSessionFileExists(projectPath, agentSessionId, baseagent) {
+    checkSessionFileExists(projectPath, agentSessionId, baseagent, agentAid) {
         const adapter = this.getFileAdapter(baseagent);
         if (!adapter)
             return false;
-        return adapter.checkExists(projectPath, agentSessionId);
+        return adapter.checkExists(projectPath, agentSessionId, agentAid);
     }
-    readSessionFirstMessage(projectPath, agentSessionId, baseagent) {
+    readSessionFirstMessage(projectPath, agentSessionId, baseagent, agentAid) {
         const adapter = this.getFileAdapter(baseagent);
         if (!adapter)
             return null;
-        return adapter.readFirstMessage(projectPath, agentSessionId);
+        return adapter.readFirstMessage(projectPath, agentSessionId, agentAid);
     }
-    readSessionLastUserMessage(projectPath, agentSessionId, baseagent) {
+    readSessionLastUserMessage(projectPath, agentSessionId, baseagent, agentAid) {
         const adapter = this.getFileAdapter(baseagent);
         if (!adapter)
             return null;
-        return adapter.readLastUserMessage(projectPath, agentSessionId);
+        return adapter.readLastUserMessage(projectPath, agentSessionId, agentAid);
     }
-    getSessionFileInfo(projectPath, agentSessionId, baseagent) {
+    getSessionFileInfo(projectPath, agentSessionId, baseagent, agentAid) {
         if (!baseagent) {
             logger.error(`[SessionManager] getSessionFileInfo: baseagent is empty, returning turns=0. agentSessionId=${agentSessionId}`);
             return { turns: 0 };
@@ -1371,13 +1369,13 @@ export class SessionManager {
             logger.error(`[SessionManager] getSessionFileInfo: no adapter for baseagent=${baseagent}, returning turns=0`);
             return { turns: 0 };
         }
-        return adapter.getFileInfo(projectPath, agentSessionId);
+        return adapter.getFileInfo(projectPath, agentSessionId, agentAid);
     }
-    async listSdkSessions(projectPath, baseagent) {
+    async listSdkSessions(projectPath, baseagent, agentAid) {
         const adapter = this.getFileAdapter(baseagent);
         if (!adapter?.listSdkSessions)
             return [];
-        return adapter.listSdkSessions(projectPath);
+        return adapter.listSdkSessions(projectPath, agentAid);
     }
     async getSessionByUuidPrefix(channel, channelId, uuidPrefix) {
         const chatDir = this.resolveChatDirSafe(channel, channelId);
@@ -1390,15 +1388,16 @@ export class SessionManager {
         }
         return matched[0];
     }
-    async importCliSession(channel, channelId, projectPath, agentSessionId, baseagent = 'claude') {
+    async importCliSession(channel, channelId, projectPath, agentSessionId, baseagent = 'claude', agentAid) {
         const inheritedChatType = this.getActiveChatType(channel, channelId);
-        const fileInfo = this.getSessionFileInfo(projectPath, agentSessionId, baseagent);
+        const resolvedAgentAid = agentAid || this.deriveChannelIdentity(channel, channelId).selfAID;
+        const fileInfo = this.getSessionFileInfo(projectPath, agentSessionId, baseagent, resolvedAgentAid);
         const name = fileInfo.title || `CLI会话-${new Date().toLocaleString('zh-CN', { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit' })}`;
         // Derive selfAID and channelType from existing sessions
         const existingDir = this.findExistingChatDir(channel, channelId);
         const identity = this.deriveChannelIdentity(channel, channelId);
         let channelType = identity.channelType;
-        let selfAID = identity.selfAID;
+        let selfAID = identity.selfAID || resolvedAgentAid || '';
         if (existingDir) {
             const active = readJsonFile(path.join(existingDir, 'active.json'));
             if (active) {
@@ -1662,4 +1661,209 @@ export class SessionManager {
             logger.info(`[SessionManager] Migrated ${migrated} WeCom session director${migrated === 1 ? 'y' : 'ies'} to channelKey isolation`);
         }
     }
+    /**
+     * Recover legacy AUN chats written beneath `_unknown` before selfAID was
+     * persisted. A channel key or persisted selfAID is required to make the
+     * migration unambiguous; all other directories remain untouched.
+     */
+    migrateUnknownAunDirs() {
+        const legacyDirs = scanChatDirs(this.sessionsDir)
+            .filter(entry => entry.channelType === 'aun' && entry.selfAID === '_unknown');
+        let migrated = 0;
+        for (const entry of legacyDirs) {
+            const selfAIDs = this.findAunSelfAIDCandidates(entry.dirPath);
+            if (selfAIDs.size !== 1) {
+                if (selfAIDs.size > 1) {
+                    logger.error(`[SessionManager] Cannot auto-migrate mixed unknown AUN session directory: ${entry.dirPath}`);
+                }
+                continue;
+            }
+            const selfAID = [...selfAIDs][0];
+            const target = chatDirPath(this.sessionsDir, 'aun', entry.channelId, selfAID);
+            try {
+                this.mergeUnknownAunDirectory(entry.dirPath, target, selfAID);
+                migrated++;
+            }
+            catch (error) {
+                logger.error(`[SessionManager] Failed to migrate unknown AUN session directory ${entry.dirPath}: ${String(error)}`);
+            }
+        }
+        if (migrated > 0) {
+            logger.info(`[SessionManager] Migrated ${migrated} unknown AUN session director${migrated === 1 ? 'y' : 'ies'} to selfAID isolation`);
+        }
+    }
+    findAunSelfAIDCandidates(chatDir) {
+        const candidates = new Set();
+        const visitRecord = (record) => {
+            if (!record || typeof record !== 'object')
+                return;
+            const session = record;
+            const direct = typeof session.selfAID === 'string' ? session.selfAID.trim() : '';
+            if (direct && direct !== '_unknown')
+                candidates.add(direct);
+            const channel = typeof session.channel === 'string' ? tryParseChannelKey(session.channel) : null;
+            if (channel?.type === 'aun' && channel.selfAID !== '_unknown')
+                candidates.add(channel.selfAID);
+        };
+        const visitJsonl = (filePath) => {
+            for (const record of readAllJsonlLines(filePath))
+                visitRecord(record);
+        };
+        visitRecord(readJsonFile(path.join(chatDir, 'active.json')));
+        for (const metaFile of scanMetaFiles(chatDir))
+            visitJsonl(path.join(chatDir, metaFile));
+        const threadDir = path.join(chatDir, '_threads');
+        for (const metaFile of scanMetaFiles(threadDir))
+            visitJsonl(path.join(threadDir, metaFile));
+        return candidates;
+    }
+    mergeUnknownAunDirectory(sourceDir, targetDir, selfAID) {
+        if (sourceDir === targetDir)
+            return;
+        fs.mkdirSync(targetDir, { recursive: true });
+        this.mergeUnknownAunDirectoryContents(sourceDir, targetDir, selfAID);
+        fs.rmdirSync(sourceDir);
+    }
+    mergeUnknownAunDirectoryContents(sourceDir, targetDir, selfAID) {
+        for (const entry of fs.readdirSync(sourceDir, { withFileTypes: true })) {
+            const sourcePath = path.join(sourceDir, entry.name);
+            const targetPath = path.join(targetDir, entry.name);
+            if (entry.isDirectory()) {
+                fs.mkdirSync(targetPath, { recursive: true });
+                this.mergeUnknownAunDirectoryContents(sourcePath, targetPath, selfAID);
+                fs.rmdirSync(sourcePath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (entry.name === 'active.json') {
+                this.mergeUnknownAunActiveFile(sourcePath, targetPath, selfAID);
+            }
+            else if (entry.name.endsWith('.jsonl')) {
+                this.mergeUnknownAunJsonlFile(sourcePath, targetPath, selfAID);
+            }
+            else if (entry.name.endsWith('.json')) {
+                this.mergeUnknownAunJsonFile(sourcePath, targetPath);
+            }
+            else if (!fs.existsSync(targetPath)) {
+                fs.renameSync(sourcePath, targetPath);
+            }
+            else if (fs.readFileSync(sourcePath).equals(fs.readFileSync(targetPath))) {
+                fs.unlinkSync(sourcePath);
+            }
+            else {
+                fs.renameSync(sourcePath, this.uniqueLegacyFilePath(targetPath));
+            }
+        }
+    }
+    mergeUnknownAunActiveFile(sourcePath, targetPath, selfAID) {
+        const source = this.normalizeAunSessionRecord(readJsonFile(sourcePath), selfAID);
+        const target = this.normalizeAunSessionRecord(readJsonFile(targetPath), selfAID);
+        const sourceUpdatedAt = typeof source?.updatedAt === 'number' ? source.updatedAt : 0;
+        const targetUpdatedAt = typeof target?.updatedAt === 'number' ? target.updatedAt : 0;
+        const selected = target && targetUpdatedAt >= sourceUpdatedAt ? target : source;
+        if (selected)
+            atomicWriteJson(targetPath, selected);
+        fs.unlinkSync(sourcePath);
+    }
+    mergeUnknownAunJsonlFile(sourcePath, targetPath, selfAID) {
+        const records = [
+            ...this.readNormalizedAunJsonl(sourcePath, selfAID),
+            ...this.readNormalizedAunJsonl(targetPath, selfAID),
+        ];
+        const seen = new Set();
+        const unique = records.filter(record => {
+            if (seen.has(record.key))
+                return false;
+            seen.add(record.key);
+            return true;
+        });
+        unique.sort((left, right) => left.timestamp - right.timestamp || left.order - right.order);
+        atomicWriteText(targetPath, unique.map(record => record.line).join('\n') + (unique.length ? '\n' : ''));
+        fs.unlinkSync(sourcePath);
+    }
+    readNormalizedAunJsonl(filePath, selfAID) {
+        let content;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+        return content.split('\n').flatMap((rawLine, order) => {
+            const line = rawLine.trim();
+            if (!line)
+                return [];
+            try {
+                const record = this.normalizeAunSessionRecord(JSON.parse(line), selfAID);
+                const normalizedLine = JSON.stringify(record);
+                return [{
+                        key: this.stableJson(record),
+                        line: normalizedLine,
+                        timestamp: this.recordTimestamp(record),
+                        order,
+                    }];
+            }
+            catch {
+                return [{ key: `raw:${line}`, line, timestamp: Number.MAX_SAFE_INTEGER, order }];
+            }
+        });
+    }
+    normalizeAunSessionRecord(record, selfAID) {
+        if (!record || typeof record !== 'object' || Array.isArray(record))
+            return record;
+        const result = { ...record };
+        const isSessionRecord = 'channel' in result || 'channelType' in result || 'sessionKey' in result || 'selfAID' in result;
+        if (!isSessionRecord)
+            return result;
+        if (!result.selfAID || result.selfAID === '_unknown')
+            result.selfAID = selfAID;
+        return result;
+    }
+    stableJson(value) {
+        if (Array.isArray(value))
+            return `[${value.map(item => this.stableJson(item)).join(',')}]`;
+        if (value && typeof value === 'object') {
+            return `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${this.stableJson(value[key])}`).join(',')}}`;
+        }
+        return JSON.stringify(value);
+    }
+    recordTimestamp(record) {
+        if (!record || typeof record !== 'object')
+            return Number.MAX_SAFE_INTEGER;
+        const value = record;
+        for (const key of ['ts', 'at', 'updatedAt', 'createdAt']) {
+            if (typeof value[key] === 'number' && Number.isFinite(value[key]))
+                return value[key];
+        }
+        return Number.MAX_SAFE_INTEGER;
+    }
+    mergeUnknownAunJsonFile(sourcePath, targetPath) {
+        if (!fs.existsSync(targetPath)) {
+            fs.renameSync(sourcePath, targetPath);
+            return;
+        }
+        const source = readJsonFile(sourcePath);
+        const target = readJsonFile(targetPath);
+        if (source && target && !Array.isArray(source) && !Array.isArray(target)) {
+            atomicWriteJson(targetPath, { ...source, ...target });
+            fs.unlinkSync(sourcePath);
+            return;
+        }
+        if (fs.readFileSync(sourcePath).equals(fs.readFileSync(targetPath))) {
+            fs.unlinkSync(sourcePath);
+            return;
+        }
+        fs.renameSync(sourcePath, this.uniqueLegacyFilePath(targetPath));
+    }
+    uniqueLegacyFilePath(targetPath) {
+        let index = 1;
+        let candidate = `${targetPath}.legacy-unknown`;
+        while (fs.existsSync(candidate)) {
+            candidate = `${targetPath}.legacy-unknown-${index++}`;
+        }
+        return candidate;
+    }
 }

package/dist/core/session/session-title.js

@@ -30,6 +30,7 @@ const BACKEND_SYNTHETIC_CLI_PROMPT_PREFIXES = {
     ],
     codex: [],
     gemini: [],
+    ecagent: [],
 };
 // Claude Code 斜杠命令 / skill / hook 注入的脚手架，经真实会话数据核对，形态包括：
 // - <local-command-caveat> / <local-command-stdout> / <local-command-stderr> 等 local-command 标签族

package/dist/core/session/session-turn-coordinator.js

@@ -142,9 +142,16 @@ export class SessionTurnCoordinator {
         if (evidence.openToolUseIds.length > 0)
             return { ok: false, reason: 'tool_open' };
         const madeProgress = evidence.textCount > 0 || evidence.toolUseCount > 0 || !!evidence.resultText?.trim();
-        if (!evidence.inputAccepted && !madeProgress)
+        // Not every runner can emit input_accepted. Token usage is equally strong
+        // evidence that the upstream model consumed the input, even for a silent result.
+        const inputConsumed = evidence.inputAccepted
+            || evidence.hasTokenUsage === true
+            || evidence.inputTokens > 0
+            || evidence.outputTokens > 0;
+        if (!inputConsumed && !madeProgress)
             return { ok: false, reason: 'input_not_consumed' };
         const emptySuccess = !evidence.explicitNoop
+            && !evidence.hasTokenUsage
             && evidence.inputTokens === 0
             && evidence.outputTokens === 0
             && !madeProgress;

package/dist/core/system-channels.js

@@ -14,6 +14,7 @@ export function isSystemControlChannel(channel) {
 export function isNonAgentSessionChannel(channel) {
     return channel === 'daemon' || isSystemControlChannel(channel);
 }
+/** Explicit maintenance helper; startup never invokes it. */
 export function cleanupLegacySystemControlSessions(sessionsDir) {
     const removed = [];
     for (const channel of LEGACY_SYSTEM_CONTROL_CHANNELS) {

package/dist/index.js

@@ -1,7 +1,7 @@
 // 【重要】最先加载环境变量，确保后续模块初始化时可用
 import dotenv from 'dotenv';
 import path from 'path';
-import { ensureDataDirs, resolvePaths, getPackageRoot, agentMdPath, eckDebugDir } from './paths.js';
+import { ensureDataDirs, resolvePaths, getPackageRoot, agentMdPath, eckDebugDir, daemonControlDir, daemonQueuePath } from './paths.js';
 // 立即加载 .env 文件（在其他模块导入之前）
 try {
     dotenv.config({ path: path.join(resolvePaths().root, '.env') });
@@ -12,6 +12,7 @@ catch {
 import { ClaudeSessionFileAdapter } from './core/session/adapters/claude-session-file-adapter.js';
 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 { loadDefaults, loadAllAgents, migrateIdentitiesIfNeeded, loadDaemonConfig, initializeEckSnapshotsConfig } from './config-store.js';
 import { ConfigTarget, initConfigManager, onConfigWrite } from './config/config-manager.js';
 import { ensureRoleConfigV4OnStartup } from './config/role-config-v4-startup.js';
@@ -30,6 +31,7 @@ import { SessionManager } from './core/session/session-manager.js';
 import { ClaudeAgentPlugin } from './agents/claude-runner.js';
 import { CodexAgentPlugin } from './agents/codex-runner.js';
 import { GeminiAgentPlugin } from './agents/gemini-runner.js';
+import { EcagentAgentPlugin } from './agents/ecagent-runner.js';
 import { FeishuChannelPlugin, registerPendingFeishuContactBind } from './channels/feishu.js';
 import { WechatChannelPlugin, registerPendingWechatContactBind } from './channels/wechat.js';
 import { AUN_HANDOFF_MARKER_FIELD, AUNChannel, AUNChannelPlugin } from './channels/aun.js';
@@ -78,13 +80,13 @@ import { TriggerAuditLogger } from './trigger/audit.js';
 import { TriggerScriptExecutor } from './trigger/script-executor.js';
 import { TriggerFeedbackDispatcher } from './trigger/feedback.js';
 import { TriggerRuntimeScheduler } from './trigger/scheduler.js';
+import { TargetSessionLockRegistry } from './trigger/session-lock.js';
 import { DaemonChannel } from './channels/daemon.js';
 import { definitionRevision, normalizeTriggerDefinition } from './trigger/validation.js';
 import { applyTriggerPatch } from './trigger/patch.js';
 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 { cleanupLegacySystemControlSessions } from './core/system-channels.js';
 import { appendMessageLog, buildOutboundEntry, classifyAunPayloadForLog } from './core/message/message-log.js';
 import fs from 'fs';
 import crypto from 'crypto';
@@ -844,21 +846,19 @@ async function main() {
         });
         return roleToSessionIdentity(detail.effectiveRole);
     };
-    const removedLegacyControlSessions = cleanupLegacySystemControlSessions(paths.sessionsDir);
-    if (removedLegacyControlSessions.length > 0) {
-        logger.info(`[startup] Removed legacy synthetic control sessions: ${removedLegacyControlSessions.join(', ')}`);
-    }
     const sessionManager = new SessionManager(paths.sessionsDir, eventBus, resolveSessionIdentity);
     logger.info('✓ Database initialized');
     // 注册会话文件适配器（Claude / Codex 各自的会话文件操作）
     sessionManager.registerFileAdapter(new ClaudeSessionFileAdapter());
     sessionManager.registerFileAdapter(new CodexSessionFileAdapter());
     sessionManager.registerFileAdapter(new GeminiSessionFileAdapter());
+    sessionManager.registerFileAdapter(new EcagentSessionFileAdapter());
     // Agent 插件系统：每个 EvolAgent × 每个 baseagent 一个独立 runner（H1/H2 修复）
     const agentLoader = new AgentLoader();
     agentLoader.register(new ClaudeAgentPlugin());
     agentLoader.register(new CodexAgentPlugin());
     agentLoader.register(new GeminiAgentPlugin());
+    agentLoader.register(new EcagentAgentPlugin());
     const agentInstances = agentLoader.createAll(agentRegistry, {
         onSessionIdUpdate: async (sessionId, agentSessionId) => {
             await sessionManager.updateAgentSessionIdBySessionId(sessionId, agentSessionId);
@@ -1010,7 +1010,7 @@ async function main() {
     const messageQueue = new MessageQueue(async (message) => {
         await processor.processMessage(message);
     }, {
-        persistencePath: path.join(resolvePaths().dataDir, 'message-queue.json'),
+        persistencePath: daemonQueuePath(),
     });
     // 设置中断回调（精确中断正在处理的 agent）
     messageQueue.setInterruptCallback(async (sessionKey, baseagent, evolagentName, reason = 'new_message') => {
@@ -1074,6 +1074,7 @@ async function main() {
     responseEngine.setHandoffRuntime(handoffRuntime);
     // Trigger runtime: daemon-level script + feedback scheduler.
     const triggerSchedulers = new Map();
+    const targetSessionLocks = new TargetSessionLockRegistry();
     const triggerAudit = new TriggerAuditLogger();
     const triggerScriptExecutor = new TriggerScriptExecutor();
     const daemonChannel = new DaemonChannel(sessionManager, messageQueue, {
@@ -1446,7 +1447,7 @@ async function main() {
             baseagent: owner.baseagent,
             getBaseagent: () => agentRegistry.get(owner.aid)?.baseagent || owner.baseagent,
             authorizeExecution: authorizeTriggerExecution,
-        }, eventBus);
+        }, eventBus, targetSessionLocks);
         triggerSchedulers.set(owner.aid, scheduler);
         try {
             await scheduler.init();
@@ -1710,7 +1711,7 @@ async function main() {
     }
     const connectedChannels = new Set();
     const onlineNoticeSent = new Set();
-    const pendingFile = path.join(resolvePaths().dataDir, 'restart-pending.json');
+    const pendingFile = path.join(daemonControlDir(), 'restart-pending.json');
     let pendingRestartNoticeInFlight = null;
     let pendingRestartNoticeSent = false;
     const sendOnlineNoticeForChannel = (inst) => {

package/dist/paths.js

@@ -25,15 +25,19 @@ export function _resetRoot() {
 }
 export function resolvePaths() {
     const root = resolveRoot();
+    const agentsDir = path.join(root, 'agents');
     return {
         root,
-        sessionsDir: path.join(root, 'data', 'sessions'),
+        // Session storage is partitioned by owning Agent. Keep the historical
+        // location separately so the explicit data migration can inventory it.
+        sessionsDir: agentsDir,
+        legacySessionsDir: path.join(root, 'data', 'sessions'),
         instanceDir: path.join(root, 'data', 'instance'),
         outboxDir: path.join(root, 'data', 'outbox'),
         dataDir: path.join(root, 'data'),
         claudeModelCache: path.join(root, 'data', 'claude-model-cache.json'),
         logs: path.join(root, 'logs'),
-        agentsDir: path.join(root, 'agents'),
+        agentsDir,
         lineStats: path.join(root, 'logs', 'line-stats.log'),
         readySignal: path.join(root, 'data', 'instance', 'ready.signal'),
         controlToken: path.join(root, 'data', 'instance', 'control.token'),
@@ -126,8 +130,36 @@ export function agentDataDir(aid) {
 export function agentDataCacheDir(aid) {
     return path.join(agentDataDir(aid), 'cache');
 }
+export function agentHandoffDir(aid) {
+    return path.join(agentDataDir(aid), 'handoff');
+}
+export function agentOutboxPath(aid) {
+    return path.join(agentDataDir(aid), 'outbox.jsonl');
+}
+/** Directory-safe channel instance key used by connector runtime state. */
+function encodePathKey(value) {
+    return encodeURIComponent(value);
+}
+export function daemonDataDir() {
+    return path.join(resolveRoot(), 'data', 'daemon');
+}
+export function daemonControlDir() {
+    return path.join(daemonDataDir(), 'control');
+}
+export function daemonQueuePath() {
+    return path.join(daemonDataDir(), 'message-queue.json');
+}
+export function channelStateDir(channelKey) {
+    if (!channelKey || channelKey === '.' || channelKey === '..') {
+        throw new Error('channelKey is required');
+    }
+    return path.join(resolveRoot(), 'data', 'channel-state', encodePathKey(channelKey));
+}
+export function channelStatePath(channelKey, ...parts) {
+    return path.join(channelStateDir(channelKey), ...parts);
+}
 export function agentTriggersDir(aid) {
-    return path.join(resolveRoot(), 'data', 'triggers', aid);
+    return path.join(agentDir(aid), 'triggers');
 }
 function resolveInstanceSocketPath(root) {
     if (isWindows) {
@@ -147,7 +179,6 @@ export function ensureDataDirs() {
     fs.mkdirSync(p.outboxDir, { recursive: true });
     fs.mkdirSync(p.eckDir, { recursive: true });
     fs.mkdirSync(aidsDir(), { recursive: true });
-    seedConfigTemplates();
     migrateFromAun();
 }
 const MIGRATION_MARKER = '.migrated-from-aun';
@@ -211,29 +242,6 @@ function migrateFromAun() {
     }
     catch { }
 }
-/**
- * 首次运行时从 assets/ 模板拷贝 .env 到 $EVOLCORE_HOME。
- * 已存在则跳过，不覆盖用户修改。
- */
-function seedConfigTemplates() {
-    const root = resolveRoot();
-    const assetsDir = path.join(getPackageRoot(), 'assets');
-    const templates = [
-        { src: '.env.template', dst: '.env' },
-    ];
-    for (const { src, dst } of templates) {
-        const dstPath = path.join(root, dst);
-        if (fs.existsSync(dstPath))
-            continue;
-        const srcPath = path.join(assetsDir, src);
-        if (!fs.existsSync(srcPath))
-            continue;
-        try {
-            fs.copyFileSync(srcPath, dstPath);
-        }
-        catch { /* best-effort */ }
-    }
-}
 // ── kits 路径（始终从包内读取，不复制到 EVOLCORE_HOME）──
 export function kitsDir() {
     return path.join(getPackageRoot(), 'kits');

package/dist/trigger/feedback.js

@@ -69,6 +69,7 @@ export class TriggerFeedbackDispatcher {
         const deadlineTimer = setTimeout(() => abortDelivery('timeout', new Error(`target session timed out after ${TARGET_SESSION_DEADLINE_MS}ms`)), TARGET_SESSION_DEADLINE_MS);
         deadlineTimer.unref?.();
         let outcome;
+        let releaseSessionLock;
         try {
             if (delivery.signal.aborted) {
                 const aborted = targetSessionCancellationError(abortKind, delivery.signal.reason, false);
@@ -128,6 +129,20 @@ export class TriggerFeedbackDispatcher {
                 }
                 return this.failed(feedback, [], 'session_error', err?.message || String(err));
             }
+            if (input.onSessionResolved) {
+                const access = await input.onSessionResolved(session);
+                if (access.kind === 'conflict') {
+                    return {
+                        status: 'skipped',
+                        reason: 'concurrency_forbid',
+                        conflictRunId: access.conflictRunId,
+                        feedback,
+                        effects: [],
+                        error: null,
+                    };
+                }
+                releaseSessionLock = access.release;
+            }
             const message = {
                 channel: target.channelKey,
                 channelType,
@@ -241,6 +256,7 @@ export class TriggerFeedbackDispatcher {
             }
         }
         finally {
+            releaseSessionLock?.();
             clearTimeout(deadlineTimer);
             input.signal?.removeEventListener('abort', onInputAbort);
             outcome?.cancel();

package/dist/trigger/legacy-session-history.js

@@ -0,0 +1,19 @@
+const HISTORY_CHANNELS = new Set(['aun', 'feishu', 'wechat', 'dingtalk', 'qqbot', 'wecom']);
+/**
+ * Turns legacy raw session-file references into the controlled history CLI.
+ * The replacement deliberately keeps the explicit peer/channel scope but
+ * never carries a filesystem location into a Trigger prompt.
+ */
+export function rewriteLegacyTriggerSessionPaths(prompt, triggerAid) {
+    const legacyPath = /data\/sessions\/([A-Za-z0-9_-]+)\/([^/\s`"'<>]+)(?:\/([^/\s`"'<>]+))?\/messages\.jsonl/g;
+    return prompt.replace(legacyPath, (match, channel, first, second) => {
+        if (!HISTORY_CHANNELS.has(channel))
+            return match;
+        const isAun = channel === 'aun';
+        const target = isAun ? second : first;
+        const selfAid = triggerAid ?? (isAun ? first : undefined);
+        if (!selfAid || !target)
+            return match;
+        return `ec msg history ${selfAid} ${target} --channel ${channel} --session all --direction in --format json`;
+    });
+}

package/dist/trigger/manager.js

@@ -4,6 +4,7 @@ import { agentTriggersDir } from '../paths.js';
 import { definitionRevision, normalizeTriggerDefinition, resolveScriptPath, safeRelativePath, } from './validation.js';
 import { atomicWriteJson } from '../core/session/session-fs-store.js';
 import { TriggerHistoryStore } from './history.js';
+import { rewriteLegacyTriggerSessionPaths } from './legacy-session-history.js';
 export class TriggerDefinitionManager {
     agentAid;
     rootDir;
@@ -34,7 +35,17 @@ export class TriggerDefinitionManager {
         if (!fs.existsSync(file))
             return undefined;
         const raw = JSON.parse(fs.readFileSync(file, 'utf-8'));
-        return normalizeTriggerDefinition(raw);
+        const definition = normalizeTriggerDefinition(raw);
+        if (typeof definition.execution.prompt === 'string') {
+            const rewritten = rewriteLegacyTriggerSessionPaths(definition.execution.prompt, definition.agentAid);
+            if (rewritten !== definition.execution.prompt) {
+                definition.execution = { ...definition.execution, prompt: rewritten };
+                definition.updatedAt = Date.now();
+                this.writeDefinition(definition);
+                this.history.recordDefinition('trigger.updated', definition, { reason: 'legacy-session-history-paths' });
+            }
+        }
+        return definition;
     }
     require(triggerId) {
         const def = this.get(triggerId);

package/dist/trigger/parser.js

@@ -210,11 +210,13 @@ function parseTriggerThread(flags) {
         return { ok: false, error: '--trigger-thread 不能为空' };
     if (raw === 'per-run')
         return { ok: true, value: 'per_run' };
+    if (raw === 'by-run')
+        return { ok: true, value: 'by_run' };
     if (raw === 'by-trigger')
         return { ok: true, value: 'by_trigger' };
-    if (raw === 'per_run' || raw === 'by_trigger')
+    if (raw === 'per_run' || raw === 'by_run' || raw === 'by_trigger')
         return { ok: true, value: raw };
-    return { ok: false, error: '--trigger-thread 只接受 per-run 或 by-trigger' };
+    return { ok: false, error: '--trigger-thread 只接受 by-run 或 by-trigger（兼容 per-run）' };
 }
 function parseTargetSession(flags) {
     if (!flags.has('target-session'))