evolcore 0.0.9 → 0.0.11

package/dist/core/data-migration.js

@@ -54,6 +54,14 @@ function operationTopologyKey(operation) {
         sessionChannelKey: operation.sessionChannelKey,
     });
 }
+function operationProofTopologyKey(operation) {
+    if (operation.kind !== 'contact-audit-partition')
+        return operationTopologyKey(operation);
+    return JSON.stringify({
+        kind: operation.kind,
+        source: operation.source,
+    });
+}
 /**
  * Manifests written before allowExistingDestinationMerge was introduced still
  * need safe recovery. Re-derive that narrow permission from their immutable
@@ -125,26 +133,40 @@ function acknowledgeCompletedCopies(root, operations) {
             if (manifest.planSignature === currentPlanSignature)
                 return;
             for (const operation of manifest.operations ?? []) {
-                if (operation.kind !== 'copy' || (operation.status !== 'committed' && operation.status !== 'skipped') || !operation.sourceHash)
+                if ((operation.kind !== 'copy' && operation.kind !== 'contact-audit-partition')
+                    || (operation.status !== 'committed' && operation.status !== 'skipped')
+                    || !operation.sourceHash)
                     continue;
-                const key = operationTopologyKey(operation);
-                if (!proofs.has(key))
-                    proofs.set(key, { migrationId: manifest.id, sourceHash: operation.sourceHash });
+                const key = operationProofTopologyKey(operation);
+                if (!proofs.has(key)) {
+                    proofs.set(key, {
+                        migrationId: manifest.id,
+                        sourceHash: operation.sourceHash,
+                        destinations: operation.kind === 'contact-audit-partition'
+                            ? [...(operation.destinations ?? [])]
+                            : operation.destination ? [operation.destination] : [],
+                    });
+                }
             }
         }
     }
     catch { }
     for (const operation of operations) {
-        if (operation.kind !== 'copy' || !operation.destination || !fs.existsSync(operation.destination))
+        if (operation.kind !== 'copy' && operation.kind !== 'contact-audit-partition')
             continue;
-        const proof = proofs.get(operationTopologyKey(operation));
+        const proof = proofs.get(operationProofTopologyKey(operation));
         if (!proof)
             continue;
+        if (operation.kind === 'copy' && (!operation.destination || !fs.existsSync(operation.destination)))
+            continue;
+        if (operation.kind === 'contact-audit-partition' && proof.destinations.some(destination => !fs.existsSync(destination)))
+            continue;
         try {
             if (treeHash(operation.source, operation.exclude) !== proof.sourceHash)
                 continue;
             operation.status = 'acknowledged';
             operation.acknowledgedBy = proof.migrationId;
+            operation.sourceHash = proof.sourceHash;
         }
         catch { }
     }
@@ -1419,6 +1441,18 @@ function atomicWriteText(target, content) {
 function hashContent(content) {
     return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
 }
+function mergeJsonlContent(existing, incoming, deduplicateExisting = false) {
+    const existingLines = existing.split('\n').filter(line => line.trim());
+    const merged = deduplicateExisting ? [...new Set(existingLines)] : [...existingLines];
+    const lines = new Set(merged);
+    for (const line of incoming.split('\n')) {
+        if (!line.trim() || lines.has(line))
+            continue;
+        lines.add(line);
+        merged.push(line);
+    }
+    return merged.length ? `${merged.join('\n')}\n` : '';
+}
 function appendIssue(operation, issue) {
     const issues = operation.issues ?? [];
     if (!issues.includes(issue))
@@ -1457,20 +1491,18 @@ function executeContactAudit(manifest, operation, checkpoint) {
     for (const [aid, lines] of groups) {
         const destination = path.join(manifest.root, 'agents', aid, 'data', 'contact-audit.jsonl');
         const content = lines.join('\n') + '\n';
-        const expectedHash = hashContent(content);
+        const existing = fs.existsSync(destination) ? fs.readFileSync(destination, 'utf8') : undefined;
+        if (existing !== undefined)
+            strictJsonValidation(destination);
+        const expectedContent = existing === undefined ? content : mergeJsonlContent(existing, content);
+        const expectedHash = hashContent(expectedContent);
         operation.destinations.push(destination);
         operation.destinationHashes[destination] = expectedHash;
-        if (fs.existsSync(destination)) {
-            const existing = fs.readFileSync(destination, 'utf8');
+        if (existing !== undefined) {
             if (hashContent(existing) !== expectedHash) {
-                // Audit logs are append-only. An exact existing prefix is a partial
-                // prior copy, so replacing it with the verified complete partition is
-                // lossless; every other mismatch remains a manual conflict.
-                if (!content.startsWith(existing)) {
-                    appendIssue(operation, `destination conflict: ${destination}`);
-                    continue;
-                }
-                atomicWriteText(destination, content);
+                // The per-Agent audit may have advanced after an earlier migration.
+                // Preserve its order and append only legacy records not already present.
+                atomicWriteText(destination, expectedContent);
             }
             continue;
         }
@@ -1600,15 +1632,7 @@ function trackMergeSources(operation) {
     return sources;
 }
 function mergeJsonl(target, source) {
-    const lines = new Set(fs.readFileSync(target, 'utf8').split('\n').filter(line => line.trim()));
-    const merged = [...lines];
-    for (const line of fs.readFileSync(source, 'utf8').split('\n')) {
-        if (!line.trim() || lines.has(line))
-            continue;
-        lines.add(line);
-        merged.push(line);
-    }
-    fs.writeFileSync(target, merged.length ? `${merged.join('\n')}\n` : '');
+    fs.writeFileSync(target, mergeJsonlContent(fs.readFileSync(target, 'utf8'), fs.readFileSync(source, 'utf8'), true));
 }
 function copyTree(source, destination) {
     const stat = fs.statSync(source);
@@ -1741,6 +1765,34 @@ export function readDataMigration(root, id) {
         throw new Error(`migration manifest not found: ${id}`);
     return manifest;
 }
+function completedMigrationMatchesPlan(manifest, plan, planSignature) {
+    if (manifest.state !== 'completed' || manifest.planSignature !== planSignature)
+        return false;
+    const proofs = new Map(manifest.operations.map(operation => [operationProofTopologyKey(operation), operation]));
+    for (const operation of plan.operations.filter(item => item.status !== 'acknowledged')) {
+        const proof = proofs.get(operationProofTopologyKey(operation));
+        if (!proof || (proof.status !== 'committed' && proof.status !== 'skipped' && proof.status !== 'acknowledged'))
+            return false;
+        try {
+            for (const source of operationSources(operation)) {
+                const expected = proof.sourceHashes?.[source]
+                    ?? (source === proof.source ? proof.sourceHash : undefined);
+                if (!expected || treeHash(source, operation.exclude) !== expected)
+                    return false;
+            }
+        }
+        catch {
+            return false;
+        }
+        if ((operation.kind === 'copy' || operation.kind === 'merge-copy')
+            && (!operation.destination || !fs.existsSync(operation.destination)))
+            return false;
+        if (operation.kind === 'contact-audit-partition'
+            && (proof.destinations ?? []).some(destination => !fs.existsSync(destination)))
+            return false;
+    }
+    return true;
+}
 /**
  * Startup gate for the explicit migration workflow. Legacy source files are
  * deliberately retained after success, so their mere presence is not enough
@@ -1763,7 +1815,7 @@ export function inspectDataMigrationRequirement(root) {
             if (!entry.isFile() || !entry.name.endsWith('.json'))
                 continue;
             const manifest = readJson(path.join(migrationDir(root), entry.name));
-            if (manifest?.state !== 'completed' || manifest.planSignature !== planSignature)
+            if (!manifest || !completedMigrationMatchesPlan(manifest, plan, planSignature))
                 continue;
             completedMigrationId = manifest.id;
             break;

package/dist/core/evolagent-registry.js

@@ -5,7 +5,7 @@ import { logger } from '../utils/logger.js';
 import { agentPersonalDir } from '../paths.js';
 import { invalidateAgentDisplayName, resolveAgentDisplayName } from '../aun/aid/agentmd.js';
 import { loadAllAgents, ensureAgentDirSkeleton, loadAgent, validateAgentConfig, } from '../config-store.js';
-import { resolveEffective } from '../config/config-manager.js';
+import { ConfigTarget, read as readConfig, resolveEffective } from '../config/config-manager.js';
 // ── Channel Fingerprint ───────────────────────────────────────────────────
 // 用于检测多 agent 之间复用同一外部凭证的冲突（appId、aid、token 等）。
 // 格式：{type}:{primaryKey}
@@ -84,18 +84,20 @@ export class EvolAgentRegistry {
         this.skipped = [];
         const { agents: rawAgents, skipped, invalidAgents = [] } = loadAllAgents({ includeInvalid: true });
         this.skipped = skipped;
-        for (const raw of rawAgents) {
+        for (const expandedRaw of rawAgents) {
             try {
-                const merged = resolveEffective({ self: raw.aid });
+                const raw = readConfig(ConfigTarget.Agent, { self: expandedRaw.aid }, { cache: true }) ?? expandedRaw;
+                const merged = resolveEffective({ self: expandedRaw.aid }, { expand: true });
                 const agent = new EvolAgent(raw, merged);
-                ensureAgentDirSkeleton(raw.aid);
+                ensureAgentDirSkeleton(expandedRaw.aid);
                 this.agents.set(agent.aid, agent);
             }
             catch (e) {
-                logger.warn(`[EvolAgentRegistry] failed to construct agent ${raw.aid}: ${e}`);
+                logger.warn(`[EvolAgentRegistry] failed to construct agent ${expandedRaw.aid}: ${e}`);
             }
         }
-        for (const { agent: raw, reason } of invalidAgents) {
+        for (const { agent: expandedRaw, reason } of invalidAgents) {
+            const raw = readConfig(ConfigTarget.Agent, { self: expandedRaw.aid }, { cache: true }) ?? expandedRaw;
             this.registerErrorAgent(raw, reason);
         }
         this.detectAndFlagConflicts();
@@ -119,7 +121,7 @@ export class EvolAgentRegistry {
     }
     resolveMergedForErrorAgent(raw, reason) {
         try {
-            return resolveEffective({ self: raw.aid });
+            return resolveEffective({ self: raw.aid }, { expand: true });
         }
         catch (e) {
             const message = e instanceof Error ? e.message : String(e);
@@ -225,9 +227,9 @@ export class EvolAgentRegistry {
             logger.info(`[EvolAgentRegistry] agent ${aid} already loaded, skipping`);
             return this.agents.get(aid);
         }
-        let raw = null;
+        let expandedRaw = null;
         try {
-            raw = loadAgent(aid);
+            expandedRaw = loadAgent(aid);
         }
         catch (e) {
             const reason = e instanceof Error ? e.message : String(e);
@@ -239,22 +241,23 @@ export class EvolAgentRegistry {
                 channels: [],
             }, reason);
         }
-        if (!raw) {
+        if (!expandedRaw) {
             logger.warn(`[EvolAgentRegistry] loadNewAgent: ${aid}/config.json not found`);
             return null;
         }
-        const errs = validateAgentConfig(raw);
+        const errs = validateAgentConfig(expandedRaw);
         if (errs.length > 0) {
             const reason = errs.join('; ');
             logger.warn(`[EvolAgentRegistry] loadNewAgent ${aid}: ${reason}`);
-            return this.registerErrorAgent(raw, reason);
+            return this.registerErrorAgent(expandedRaw, reason);
         }
-        const conflict = this.checkConflictForReload(raw, aid);
+        const conflict = this.checkConflictForReload(expandedRaw, aid);
         if (conflict) {
             logger.warn(`[EvolAgentRegistry] loadNewAgent ${aid}: ${conflict}`);
-            return this.registerErrorAgent(raw, `Channel conflict: ${conflict}`);
+            return this.registerErrorAgent(expandedRaw, `Channel conflict: ${conflict}`);
         }
-        const merged = resolveEffective({ self: aid });
+        const raw = readConfig(ConfigTarget.Agent, { self: aid }, { cache: true }) ?? expandedRaw;
+        const merged = resolveEffective({ self: aid }, { expand: true });
         const agent = new EvolAgent(raw, merged);
         ensureAgentDirSkeleton(aid);
         this.agents.set(aid, agent);
@@ -268,13 +271,14 @@ export class EvolAgentRegistry {
         const oldAgent = this.agents.get(aidOrName);
         if (!oldAgent)
             throw new Error(`Agent "${aidOrName}" not found`);
-        const raw = loadAgent(oldAgent.aid);
-        if (!raw)
+        const expandedRaw = loadAgent(oldAgent.aid);
+        if (!expandedRaw)
             throw new Error(`Agent ${oldAgent.aid}/config.json missing on reload`);
-        const errs = validateAgentConfig(raw);
+        const errs = validateAgentConfig(expandedRaw);
         if (errs.length > 0)
             throw new Error(`Invalid config after edit: ${errs.join('; ')}`);
-        const merged = resolveEffective({ self: raw.aid });
+        const raw = readConfig(ConfigTarget.Agent, { self: oldAgent.aid }, { cache: true }) ?? expandedRaw;
+        const merged = resolveEffective({ self: raw.aid }, { expand: true });
         if (oldAgent.status === 'disabled' && raw.enabled !== false) {
             oldAgent.swapConfig(raw, merged);
             const hotLoad = globalThis.__evolcore_hotLoadAgent;
@@ -289,32 +293,69 @@ export class EvolAgentRegistry {
         }
         if (oldAgent.status !== 'disabled' && raw.enabled === false) {
             let prepared = false;
+            let runnerTransaction;
+            const disconnectedChannels = [];
+            const previousConfig = oldAgent.captureConfigSnapshot();
+            const previousStatus = oldAgent.status;
+            const previousError = oldAgent.error;
             try {
                 await hooks.prepareHandoffReload?.(oldAgent.aid);
                 prepared = true;
+                runnerTransaction = await hooks.stageAgentRunners?.(new EvolAgent(raw, merged));
                 for (const ch of oldAgent.channelInstanceNames()) {
                     try {
                         await hooks.drainChannel(ch);
                     }
                     catch { }
-                    try {
-                        await hooks.disconnectChannel(ch);
-                    }
-                    catch { }
+                    await hooks.disconnectChannel(ch);
+                    disconnectedChannels.push(ch);
                 }
                 oldAgent.swapConfig(raw, merged);
                 oldAgent.status = 'disabled';
                 this.channelIndex.clear();
                 this.buildChannelIndex();
+                runnerTransaction?.commit();
+                try {
+                    await runnerTransaction?.finalize();
+                }
+                catch (error) {
+                    logger.warn(`[Reload] Failed to dispose previous runners after disabling "${aidOrName}": ${error instanceof Error ? error.message : String(error)}`);
+                }
+                prepared = false;
                 logger.info(`[Reload] Agent "${aidOrName}" disabled`);
                 return;
             }
             catch (error) {
+                const rollbackErrors = [];
+                oldAgent.swapConfig(previousConfig.rawAgent, previousConfig.merged);
+                oldAgent.invalidatePersonaCache();
+                oldAgent.status = previousStatus;
+                oldAgent.error = previousError;
+                await runnerTransaction?.rollback().catch(rollbackError => {
+                    rollbackErrors.push(`runners: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+                });
+                for (const ch of disconnectedChannels) {
+                    try {
+                        await hooks.startChannel(oldAgent, ch);
+                    }
+                    catch (restartError) {
+                        rollbackErrors.push(`restart ${ch}: ${restartError instanceof Error ? restartError.message : String(restartError)}`);
+                    }
+                }
+                this.channelIndex.clear();
+                this.buildChannelIndex();
                 if (prepared) {
                     try {
                         await hooks.completeHandoffReload?.(oldAgent.aid);
                     }
-                    catch { }
+                    catch (resumeError) {
+                        rollbackErrors.push(`handoff: ${resumeError instanceof Error ? resumeError.message : String(resumeError)}`);
+                    }
+                }
+                if (rollbackErrors.length > 0) {
+                    oldAgent.status = 'error';
+                    oldAgent.error = `Disable failed; rollback incomplete: ${rollbackErrors.join('; ')}`;
+                    logger.error(`[Reload] Disable rollback incomplete for "${aidOrName}": ${rollbackErrors.join('; ')}`);
                 }
                 throw error;
             }
@@ -324,13 +365,18 @@ export class EvolAgentRegistry {
             throw new Error(`Channel conflict: ${conflict}`);
         const removedSuccessfully = [];
         const addedSuccessfully = [];
+        let runnerTransaction;
         let prepared = false;
+        const previousConfig = oldAgent.captureConfigSnapshot();
+        const previousStatus = oldAgent.status;
+        const previousError = oldAgent.error;
         try {
             await hooks.prepareHandoffReload?.(oldAgent.aid);
             prepared = true;
+            runnerTransaction = await hooks.stageAgentRunners?.(new EvolAgent(raw, merged));
             const oldChannels = new Set(oldAgent.channelInstanceNames());
             const aunKey = oldAgent.effectiveChannelName('aun', 'main');
-            const otherKeys = raw.channels.filter(c => c.type !== 'aun').map(c => oldAgent.effectiveChannelName(c.type, c.name));
+            const otherKeys = merged.channels.filter(c => c.type !== 'aun').map(c => oldAgent.effectiveChannelName(c.type, c.name));
             const newChannels = new Set([aunKey, ...otherKeys]);
             const toRemove = [...oldChannels].filter(c => !newChannels.has(c));
             const toAdd = [...newChannels].filter(c => !oldChannels.has(c));
@@ -338,7 +384,7 @@ export class EvolAgentRegistry {
             const credentialsChanged = [];
             for (const ch of kept) {
                 const oldInst = oldAgent.findChannelInstance(ch);
-                const newInst = findInstanceByKey(raw, oldAgent, ch);
+                const newInst = findInstanceByKey(merged, oldAgent, ch);
                 if (oldInst && newInst && JSON.stringify(oldInst) !== JSON.stringify(newInst)) {
                     credentialsChanged.push(ch);
                 }
@@ -360,28 +406,72 @@ export class EvolAgentRegistry {
             oldAgent.status = 'running';
             this.channelIndex.clear();
             this.buildChannelIndex();
-            await hooks.completeHandoffReload?.(oldAgent.aid);
-            prepared = false;
+            runnerTransaction?.commit();
+            try {
+                await hooks.completeHandoffReload?.(oldAgent.aid);
+            }
+            catch (error) {
+                logger.warn(`[Reload] Handoff recovery failed after commit for "${aidOrName}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+            finally {
+                prepared = false;
+            }
+            try {
+                await hooks.afterReload?.(oldAgent);
+            }
+            catch (error) {
+                logger.warn(`[Reload] Post-reload hook failed after commit for "${aidOrName}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+            try {
+                await runnerTransaction?.finalize();
+            }
+            catch (error) {
+                logger.warn(`[Reload] Failed to dispose previous runners for "${aidOrName}": ${error instanceof Error ? error.message : String(error)}`);
+            }
         }
         catch (err) {
-            logger.error(`[Reload] Failed: ${err}. Attempting rollback for "${aidOrName}".`);
-            for (const ch of addedSuccessfully) {
+            logger.error(`[Reload] Failed before commit: ${err}. Attempting rollback for "${aidOrName}".`);
+            const rollbackErrors = [];
+            for (const ch of [...addedSuccessfully].reverse()) {
                 try {
                     await hooks.disconnectChannel(ch);
                 }
-                catch { }
+                catch (error) {
+                    rollbackErrors.push(`disconnect ${ch}: ${error instanceof Error ? error.message : String(error)}`);
+                }
             }
+            oldAgent.swapConfig(previousConfig.rawAgent, previousConfig.merged);
+            oldAgent.invalidatePersonaCache();
+            await runnerTransaction?.rollback().catch(error => {
+                rollbackErrors.push(`runners: ${error instanceof Error ? error.message : String(error)}`);
+            });
+            for (const ch of [...new Set(removedSuccessfully)]) {
+                try {
+                    await hooks.startChannel(oldAgent, ch);
+                }
+                catch (error) {
+                    rollbackErrors.push(`restart ${ch}: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            this.channelIndex.clear();
+            this.buildChannelIndex();
             if (prepared) {
                 try {
                     await hooks.completeHandoffReload?.(oldAgent.aid);
                 }
                 catch (resumeError) {
-                    logger.error(`[Reload] Failed to resume Handoff dispatcher for "${aidOrName}":`, resumeError);
+                    rollbackErrors.push(`handoff: ${resumeError instanceof Error ? resumeError.message : String(resumeError)}`);
                 }
             }
-            void removedSuccessfully;
-            oldAgent.status = 'error';
-            oldAgent.error = `Reload failed (rollback partial): ${err instanceof Error ? err.message : String(err)}`;
+            if (rollbackErrors.length === 0) {
+                oldAgent.status = previousStatus;
+                oldAgent.error = previousError;
+            }
+            else {
+                oldAgent.status = 'error';
+                oldAgent.error = `Reload failed; rollback incomplete: ${rollbackErrors.join('; ')}`;
+                logger.error(`[Reload] Rollback incomplete for "${aidOrName}": ${rollbackErrors.join('; ')}`);
+            }
             throw err;
         }
     }

package/dist/core/evolagent.js

@@ -52,7 +52,7 @@ export class EvolAgent {
         const ba = this.baseagent;
         // 动态读取配置（基于 fileCache + mtime），使配置变更立即体现在显示中
         try {
-            const effective = resolveEffective({ self: this.aid }, { cache: true });
+            const effective = resolveEffective({ self: this.aid }, { cache: true, expand: true });
             const block = effective.baseagents?.[ba];
             return block?.model;
         }
@@ -66,7 +66,7 @@ export class EvolAgent {
         const ba = this.baseagent;
         // 动态读取配置（基于 fileCache + mtime），使配置变更立即体现在显示中
         try {
-            const effective = resolveEffective({ self: this.aid }, { cache: true });
+            const effective = resolveEffective({ self: this.aid }, { cache: true, expand: true });
             const block = effective.baseagents?.[ba];
             if (ba === 'codex')
                 return block?.effort ?? block?.reasoning;
@@ -257,7 +257,8 @@ export class EvolAgent {
         this.persist();
     }
     setLifecycle(value) {
-        this.rawAgent = withLifecycleForWrite(this.rawAgent, value);
+        const current = cfgRead(ConfigTarget.Agent, { self: this.aid });
+        this.rawAgent = withLifecycleForWrite(current || this.rawAgent, value);
         this.rawAgent.$schema_version = Math.max(this.rawAgent.$schema_version || 0, this.merged.$schema_version || 0);
         this.merged.lifecycle = value;
         delete this.merged.initialized;
@@ -318,6 +319,10 @@ export class EvolAgent {
         this.rawAgent = rawAgent;
         this.merged = merged;
     }
+    /** Reload uses the current object references as an in-memory rollback snapshot. */
+    captureConfigSnapshot() {
+        return { rawAgent: this.rawAgent, merged: this.merged };
+    }
     // ── 内部辅助 ─────────────────────────────────────────────────────────
     /**
      * 找 rawAgent.channels 里的可变实例，用于写入。

package/dist/core/inference/text-inference.js

@@ -1,4 +1,5 @@
 import { normalizeBaseagent, resolveAnthropicDirectConfig, resolveEcagentConfig, resolveOpenaiDirectConfig, } from '../../agents/baseagent.js';
+import { buildModelRequestHeaders } from '../../agents/request-identity.js';
 function apiEndpoint(baseUrl, resource) {
     const configured = baseUrl?.trim();
     if (!configured)
@@ -119,12 +120,25 @@ export class EcagentTextInferenceProvider {
     baseagent = 'ecagent';
     constructor(config) {
         this.config = config;
+        this.config = {
+            ...config,
+            headers: buildModelRequestHeaders({
+                baseagent: 'ecagent',
+                baseUrl: config.baseUrl,
+                agentAid: config.evolcoreAgentAid,
+                configuredHeaders: config.headers,
+            }),
+        };
     }
     async completeText(request) {
         const response = await fetch(apiEndpoint(this.config.baseUrl, 'chat/completions'), {
             method: 'POST',
             signal: request.signal,
-            headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${this.config.apiKey}` },
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.config.apiKey}`,
+                ...this.config.headers,
+            },
             body: JSON.stringify({
                 model: request.model,
                 messages: [{ role: 'system', content: request.system }, { role: 'user', content: request.input }],
@@ -150,15 +164,35 @@ export function createTextInferenceProvider(baseagent, config) {
     const canonical = normalizeBaseagent(baseagent).canonical;
     if (canonical === 'claude') {
         const resolved = resolveAnthropicDirectConfig(config.baseagents?.claude);
-        return resolved ? new AnthropicTextInferenceProvider(resolved) : undefined;
+        return resolved ? new AnthropicTextInferenceProvider({
+            ...resolved,
+            headers: buildModelRequestHeaders({
+                baseagent: 'claude',
+                baseUrl: resolved.baseUrl,
+                agentAid: config.aid,
+                configuredHeaders: resolved.headers,
+            }),
+        }) : undefined;
     }
     if (canonical === 'codex') {
         const resolved = resolveOpenaiDirectConfig(config.baseagents?.codex);
-        return resolved ? new OpenAITextInferenceProvider(resolved) : undefined;
+        return resolved ? new OpenAITextInferenceProvider({
+            ...resolved,
+            headers: buildModelRequestHeaders({
+                baseagent: 'codex',
+                baseUrl: resolved.baseUrl,
+                agentAid: config.aid,
+                configuredHeaders: resolved.headers,
+            }),
+        }) : undefined;
     }
     if (canonical === 'ecagent') {
         try {
-            const resolved = resolveEcagentConfig({ agents: { ecagent: config.baseagents?.ecagent } }, config.baseagents?.ecagent);
+            const override = {
+                ...(config.baseagents?.ecagent ?? {}),
+                evolcoreAgentAid: config.aid,
+            };
+            const resolved = resolveEcagentConfig({ agents: { ecagent: override } }, override);
             return new EcagentTextInferenceProvider(resolved);
         }
         catch {

package/dist/core/message/message-bridge.js

@@ -760,7 +760,7 @@ export class MessageBridge {
                         channelKey,
                         channelType: msg.channelType || effectiveChannelType,
                         channelId: msg.channelId,
-                        recipientId: actorId,
+                        recipientId: roleDetail.actor.principalId || actorId,
                         recipientName: msg.peerName,
                         source: 'inbound',
                     });

package/dist/core/message/message-log.js

@@ -229,6 +229,27 @@ function formatTimestampMs(epochMs) {
 export function messageLogPath(chatDir) {
     return path.join(chatDir, MESSAGE_LOG_FILE);
 }
+export function hasMessageLogOperation(chatDir, operationId) {
+    const file = messageLogPath(chatDir);
+    if (!fs.existsSync(file))
+        return false;
+    try {
+        return fs.readFileSync(file, 'utf-8').split('\n').some(line => {
+            if (!line.trim())
+                return false;
+            try {
+                const entry = JSON.parse(line);
+                return entry?.dir === 'out' && entry.operationId === operationId;
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        return false;
+    }
+}
 export function resolveChatDir(sessionsDir, channelType, channelId, selfAID) {
     return chatDirPath(sessionsDir, channelType, channelId, selfAID);
 }
@@ -323,6 +344,7 @@ export function buildOutboundEntry(opts) {
         transport: opts.transport,
         peerType: opts.peerType,
         source: opts.source ?? 'daemon',
+        operationId: opts.operationId,
         handoff_trace: opts.handoff_trace,
     };
 }

package/dist/core/message/message-queue.js

@@ -1361,9 +1361,9 @@ export class MessageQueue {
     isAgentMuted(agentName) {
         return this.mutedAgents.has(agentName);
     }
-    /** 中断指定 agent 所有正在处理中的会话。 */
-    interruptByAgent(agentName) {
+    beginAgentInterrupt(agentName) {
         let interrupted = 0;
+        const barriers = [];
         for (const [queueKey, name] of this.processingAgent) {
             if ((name || DEFAULT_AGENT_NAME) === agentName) {
                 interrupted++;
@@ -1378,11 +1378,26 @@ export class MessageQueue {
                     causation: this.activeBatches.get(queueKey)?.message.causation,
                 });
                 if (this.interruptCallback) {
-                    void this.triggerInterrupt(queueKey, sessionKey, activeState?.baseagent, name, 'stop');
+                    barriers.push(this.triggerInterrupt(queueKey, sessionKey, activeState?.baseagent, name, 'stop'));
                 }
             }
         }
-        return interrupted;
+        return {
+            count: interrupted,
+            barrier: Promise.allSettled(barriers).then(() => undefined),
+        };
+    }
+    /** 中断指定 agent 所有正在处理中的会话。 */
+    interruptByAgent(agentName) {
+        const interruption = this.beginAgentInterrupt(agentName);
+        void interruption.barrier;
+        return interruption.count;
+    }
+    /** 中断指定 agent 的会话，并等待 runner 中断屏障完成。 */
+    async interruptByAgentAndWait(agentName) {
+        const interruption = this.beginAgentInterrupt(agentName);
+        await interruption.barrier;
+        return interruption.count;
     }
     // ── Queue query/management methods ──
     /**