evolcore 0.0.2 → 0.0.4

package/dist/agents/codex-runner.js

@@ -17,6 +17,8 @@ import { isRetryableError } from '../utils/error-utils.js';
 import { renderActionAsText } from '../core/interaction-router.js';
 import { buildEnvelope, sendInteractionPayload } from '../core/message/message-utils.js';
 import { resolveCodexCapabilityThreadConfigForProject } from '../core/capability/capability-manager.js';
+import { AGENT_DELEGATION_TOKEN_ENV, hashDelegatedCommandArgv } from '../core/auth/agent-delegation.js';
+import { classifyEvolcoreShellCommand, parseLiteralShellArgv } from '../core/permission/ec-command-parser.js';
 import { compareVersions } from '../utils/npm-ops.js';
 import { resolvePaths, resolveRoot } from '../paths.js';
 import { buildSessionTurnList } from '../core/session/session-turns.js';
@@ -111,6 +113,7 @@ const CODEX_CATALOG_FALLBACK = [
     { slug: 'gpt-5.3-codex', efforts: ['low', 'medium', 'high', 'xhigh'] },
     { slug: 'gpt-5.2', efforts: ['low', 'medium', 'high', 'xhigh'] },
 ];
+const CODEX_DELEGATION_CARRIER_METADATA_KEY = '__codexDelegationCarrierV1';
 let codexCatalogCache = null;
 // The permission bridge is version-locked to the v2 schema audited below:
 // named profiles, approvalsReviewer, additional/network approval context, and
@@ -211,6 +214,7 @@ export class CodexRunner {
     threadExternalToolFingerprints = new Map();
     threadExternalToolBoundaries = new Map();
     trackedApprovalItems = new Map();
+    threadDelegationCarriers = new Map();
     pendingInterrupts = new Map();
     appServerClient = null;
     onSessionIdUpdate;
@@ -257,12 +261,98 @@ export class CodexRunner {
         }
         return this.appServerClient;
     }
+    createDelegationCarrier() {
+        return randomBytes(32).toString('base64url');
+    }
+    approvedEvolcoreCommandArgv(toolInput) {
+        const explicitArgv = Array.isArray(toolInput.commandArgv)
+            && toolInput.commandArgv.every(value => typeof value === 'string')
+            ? toolInput.commandArgv
+            : undefined;
+        if (explicitArgv?.[0] === 'ec')
+            return explicitArgv;
+        const command = typeof toolInput.command === 'string' ? toolInput.command : '';
+        const classification = classifyEvolcoreShellCommand(command);
+        if (classification.kind === 'bounded-output')
+            return classification.command.argv;
+        if (classification.kind !== 'literal')
+            return undefined;
+        const argv = parseLiteralShellArgv(command);
+        return argv?.[0] === 'ec' ? argv : undefined;
+    }
+    armApprovedDelegationCommand(sessionId, toolInput) {
+        const threadId = this.activeSessions.get(sessionId);
+        const carrierToken = threadId ? this.threadDelegationCarriers.get(threadId) : undefined;
+        const argv = this.approvedEvolcoreCommandArgv(toolInput);
+        if (!carrierToken || !argv)
+            return false;
+        const commandHash = hashDelegatedCommandArgv(argv);
+        const arm = this.permissionContexts.get(sessionId)?.armApprovedDelegationCommand;
+        if (!commandHash || !arm)
+            return false;
+        return arm(carrierToken, commandHash);
+    }
+    async readThreadDelegationCarrier(appServer, threadId) {
+        try {
+            const result = await appServer.threadShellCommand(threadId, `node -e "process.stdout.write(process.env.${AGENT_DELEGATION_TOKEN_ENV}||String())"`);
+            const carrier = result.output.trim();
+            if (result.exitCode !== undefined && result.exitCode !== 0)
+                return undefined;
+            return /^[A-Za-z0-9_-]{32,128}$/.test(carrier) ? carrier : undefined;
+        }
+        catch (error) {
+            logger.warn(`[CodexRunner] failed to recover delegation carrier for loaded thread ${threadId}: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    }
+    async loadPersistedDelegationCarrier(sessionManager, sessionId, threadId) {
+        if (typeof sessionManager?.getSessionById !== 'function')
+            return undefined;
+        try {
+            const session = await sessionManager.getSessionById(sessionId);
+            const persisted = session?.metadata?.[CODEX_DELEGATION_CARRIER_METADATA_KEY];
+            if (!persisted || typeof persisted !== 'object' || Array.isArray(persisted))
+                return undefined;
+            if (persisted.threadId !== threadId || typeof persisted.carrier !== 'string')
+                return undefined;
+            return /^[A-Za-z0-9_-]{32,128}$/.test(persisted.carrier)
+                ? persisted.carrier
+                : undefined;
+        }
+        catch (error) {
+            logger.debug(`[CodexRunner] failed to load persisted delegation carrier: session=${sessionId} error=${error}`);
+            return undefined;
+        }
+    }
+    async persistDelegationCarrier(sessionManager, sessionId, threadId, carrier) {
+        if (typeof sessionManager?.getSessionById !== 'function'
+            || typeof sessionManager?.updateSession !== 'function')
+            return;
+        try {
+            const session = await sessionManager.getSessionById(sessionId);
+            if (!session)
+                return;
+            const current = session.metadata?.[CODEX_DELEGATION_CARRIER_METADATA_KEY];
+            if (current?.threadId === threadId && current?.carrier === carrier)
+                return;
+            await sessionManager.updateSession(sessionId, {
+                metadata: {
+                    ...(session.metadata ?? {}),
+                    [CODEX_DELEGATION_CARRIER_METADATA_KEY]: { threadId, carrier },
+                },
+            });
+        }
+        catch (error) {
+            logger.warn(`[CodexRunner] failed to persist delegation carrier: session=${sessionId} thread=${threadId} error=${error}`);
+        }
+    }
     resetAppServerClient() {
         const client = this.appServerClient;
         this.appServerClient = null;
         this.threadExternalToolFingerprints.clear();
         this.threadExternalToolBoundaries.clear();
         this.trackedApprovalItems.clear();
+        this.threadDelegationCarriers.clear();
         client?.close().catch(error => {
             logger.debug(`[CodexRunner] Failed to close stale app-server client: ${error}`);
         });
@@ -656,6 +746,7 @@ export class CodexRunner {
     // ── Core: runQuery ──
     async runQuery(sessionId, prompt, projectPath, initialAgentSessionId, images, systemPromptAppend, sessionManager, modelOverride, runtimeEnv) {
         let agentSessionId = initialAgentSessionId || this.activeSessions.get(sessionId);
+        const resumingThread = !!agentSessionId;
         const callModel = modelOverride?.model || this.model;
         const callEffort = modelOverride?.effort ?? this.effort;
         // per-call 权限模式：优先 override（message-processor 解析后传入），缺省回落实例级 currentMode。
@@ -674,13 +765,24 @@ export class CodexRunner {
         const externalToolConfig = await this.resolveExternalToolApprovalConfig(appServer, projectPath, capabilityConfig, callMode);
         const managedTempInstruction = this.managedTempInstruction(sessionId);
         const developerInstructions = [systemPromptAppend, managedTempInstruction].filter(Boolean).join('\n\n') || undefined;
+        let knownDelegationCarrier = agentSessionId
+            ? this.threadDelegationCarriers.get(agentSessionId)
+            : undefined;
+        if (agentSessionId && !knownDelegationCarrier) {
+            knownDelegationCarrier = await this.loadPersistedDelegationCarrier(sessionManager, sessionId, agentSessionId);
+            if (knownDelegationCarrier) {
+                this.threadDelegationCarriers.set(agentSessionId, knownDelegationCarrier);
+            }
+        }
+        const delegationCarrierCandidate = knownDelegationCarrier ?? this.createDelegationCarrier();
+        const hasTaskDelegation = typeof runtimeEnv?.[AGENT_DELEGATION_TOKEN_ENV] === 'string';
         const threadOptions = {
             model: callModel,
             effort: callEffort,
             approvalPolicy: effectiveApprovalPolicy,
             approvalsReviewer: 'user',
             ...(executionSandbox.sandbox ? { sandbox: executionSandbox.sandbox } : {}),
-            config: this.mergeThreadConfig(executionSandbox.permissionProfileConfig, runtimeEnv ? { shell_environment_policy: { set: runtimeEnv } } : undefined, capabilityConfig, externalToolConfig, this.buildEvolcoreShellEnvironmentConfig(sessionId), this.buildLifecycleLockdownConfig()),
+            config: this.mergeThreadConfig(executionSandbox.permissionProfileConfig, runtimeEnv ? { shell_environment_policy: { set: runtimeEnv } } : undefined, capabilityConfig, externalToolConfig, this.buildEvolcoreShellEnvironmentConfig(sessionId, delegationCarrierCandidate), this.buildLifecycleLockdownConfig()),
             ...(developerInstructions ? { developerInstructions } : {}),
         };
         logger.info(`[CodexRunner] runQuery permMode=${requestedPermissionMode}->${callMode} ` +
@@ -688,9 +790,39 @@ export class CodexRunner {
         const threadResponse = agentSessionId
             ? await appServer.threadResume(agentSessionId, projectPath, threadOptions)
             : await appServer.threadStart(projectPath, threadOptions);
-        const threadId = threadResponse.thread?.id || agentSessionId;
+        let threadId = threadResponse.thread?.id || agentSessionId;
         if (!threadId)
             throw new Error('Codex app-server did not return a thread id');
+        if (!resumingThread) {
+            this.threadDelegationCarriers.set(threadId, delegationCarrierCandidate);
+            await this.persistDelegationCarrier(sessionManager, sessionId, threadId, delegationCarrierCandidate);
+        }
+        else if (hasTaskDelegation && !knownDelegationCarrier) {
+            let recoveredCarrier = await this.readThreadDelegationCarrier(appServer, threadId);
+            if (!recoveredCarrier) {
+                const staleThreadId = threadId;
+                logger.warn(`[CodexRunner] loaded thread has no recoverable delegation carrier; forking once to preserve history: thread=${staleThreadId}`);
+                const forked = await appServer.threadFork(staleThreadId, projectPath, undefined, {
+                    model: callModel,
+                    effort: callEffort,
+                    approvalPolicy: effectiveApprovalPolicy,
+                    approvalsReviewer: 'user',
+                    ...(executionSandbox.sandbox ? { sandbox: executionSandbox.sandbox } : {}),
+                    config: threadOptions.config,
+                });
+                const forkedThreadId = forked.thread?.id;
+                if (!forkedThreadId)
+                    throw new Error('Codex delegation-carrier recovery fork did not return a thread id');
+                threadId = forkedThreadId;
+                recoveredCarrier = delegationCarrierCandidate;
+            }
+            this.threadDelegationCarriers.set(threadId, recoveredCarrier);
+            await this.persistDelegationCarrier(sessionManager, sessionId, threadId, recoveredCarrier);
+        }
+        else if (knownDelegationCarrier) {
+            this.threadDelegationCarriers.set(threadId, knownDelegationCarrier);
+            await this.persistDelegationCarrier(sessionManager, sessionId, threadId, knownDelegationCarrier);
+        }
         agentSessionId = threadId;
         this.activeSessions.set(sessionId, threadId);
         this.threadProjectPaths.set(threadId, path.resolve(projectPath));
@@ -704,11 +836,13 @@ export class CodexRunner {
         controller.signal.addEventListener('abort', () => queue.end(), { once: true });
         const state = {
             threadId,
+            model: callModel,
             streamedAgentMessageIds: new Set(),
             agentMessageDeltaText: new Map(),
             completedItemIds: new Set(),
             emittedEditCallIds: new Set(),
             completedTurnIds: new Set(),
+            openToolCalls: new Map(),
         };
         const unsubscribe = appServer.onNotification(notification => {
             // 仅从 turn/started 锁定权威 turnId — resume 时会有上一轮 turn 的残留通知
@@ -827,6 +961,7 @@ export class CodexRunner {
         const previousThreadId = this.activeSessions.get(sessionId);
         if (previousThreadId && previousThreadId !== agentSessionId) {
             this.threadProjectPaths.delete(previousThreadId);
+            this.threadDelegationCarriers.delete(previousThreadId);
             this.unbindExternalToolBoundary(previousThreadId);
             this.clearTrackedApprovalItemsForThread(previousThreadId);
         }
@@ -850,6 +985,7 @@ export class CodexRunner {
         this.cleanupSessionTempDir(sessionId);
         if (threadId) {
             this.threadProjectPaths.delete(threadId);
+            this.threadDelegationCarriers.delete(threadId);
             this.unbindExternalToolBoundary(threadId);
         }
         this.clearTrackedApprovalItemsForThread(threadId);
@@ -882,6 +1018,7 @@ export class CodexRunner {
         this.chatModes.delete(sessionId);
         this.cleanupSessionTempDir(sessionId);
         this.threadProjectPaths.delete(threadId);
+        this.threadDelegationCarriers.delete(threadId);
         this.unbindExternalToolBoundary(threadId);
         this.clearTrackedApprovalItemsForThread(threadId);
         this.onSessionIdUpdate?.(sessionId, '');
@@ -904,15 +1041,18 @@ export class CodexRunner {
                 const executionSandbox = this.buildExecutionSandboxOptions(_sessionId, compactMode, _projectPath);
                 const capabilityConfig = await this.resolveCapabilityThreadConfig(_projectPath);
                 const externalToolConfig = await this.resolveExternalToolApprovalConfig(appServer, _projectPath, capabilityConfig, compactMode);
+                const compactDelegationCarrier = this.threadDelegationCarriers.get(agentSessionId)
+                    ?? this.createDelegationCarrier();
                 await appServer.threadResume(agentSessionId, _projectPath, {
                     model: this.model,
                     effort: this.effort,
                     approvalPolicy: compactPolicy,
                     approvalsReviewer: 'user',
                     ...(executionSandbox.sandbox ? { sandbox: executionSandbox.sandbox } : {}),
-                    config: this.mergeThreadConfig(executionSandbox.permissionProfileConfig, capabilityConfig, externalToolConfig, this.buildEvolcoreShellEnvironmentConfig(_sessionId), this.buildLifecycleLockdownConfig()),
+                    config: this.mergeThreadConfig(executionSandbox.permissionProfileConfig, capabilityConfig, externalToolConfig, this.buildEvolcoreShellEnvironmentConfig(_sessionId, compactDelegationCarrier), this.buildLifecycleLockdownConfig()),
                 });
                 this.threadProjectPaths.set(agentSessionId, path.resolve(_projectPath));
+                this.threadDelegationCarriers.set(agentSessionId, compactDelegationCarrier);
                 this.bindExternalToolBoundary(agentSessionId, externalToolConfig);
                 return await this.startAndWaitForCompact(appServer, agentSessionId);
             }
@@ -1052,17 +1192,19 @@ export class CodexRunner {
         const capabilityConfig = await this.resolveCapabilityThreadConfig(projectPath);
         const appServer = this.getAppServerClient();
         const externalToolConfig = await this.resolveExternalToolApprovalConfig(appServer, projectPath, capabilityConfig, mode);
+        const delegationCarrier = this.createDelegationCarrier();
         const response = await appServer.threadFork(agentSessionId, projectPath, title, {
             model: this.model,
             effort: this.effort,
             approvalPolicy: this.toApprovalPolicy(mode),
             approvalsReviewer: 'user',
             ...(executionSandbox.sandbox ? { sandbox: executionSandbox.sandbox } : {}),
-            config: this.mergeThreadConfig(executionSandbox.permissionProfileConfig, capabilityConfig, externalToolConfig, this.buildEvolcoreShellEnvironmentConfig(sessionKey), this.buildLifecycleLockdownConfig()),
+            config: this.mergeThreadConfig(executionSandbox.permissionProfileConfig, capabilityConfig, externalToolConfig, this.buildEvolcoreShellEnvironmentConfig(sessionKey, delegationCarrier), this.buildLifecycleLockdownConfig()),
         });
         const forkedThreadId = response.thread?.id;
         if (!forkedThreadId)
             throw new Error('Codex fork did not return a thread id');
+        this.threadDelegationCarriers.set(forkedThreadId, delegationCarrier);
         this.threadProjectPaths.set(forkedThreadId, path.resolve(projectPath));
         this.bindExternalToolBoundary(forkedThreadId, externalToolConfig);
         return forkedThreadId;
@@ -1225,6 +1367,16 @@ export class CodexRunner {
         logger.info(`[CodexRunner] app-server approval request id=${request.id} method=${request.method} session=${sessionKey} mode=${sessionMode} tool=${toolName} summary=${summary}`);
         try {
             const decision = await this.resolvePermissionDecision(sessionKey, toolName, toolInput, summary, reason, workspacePath, operationCwd);
+            if (decision !== 'deny'
+                && (request.method === 'item/commandExecution/requestApproval' || request.method === 'execCommandApproval')
+                && this.approvedEvolcoreCommandArgv(toolInput)) {
+                if (!this.armApprovedDelegationCommand(sessionKey, toolInput)) {
+                    // Approval policy and delegation authority are separate boundaries.
+                    // If no ticket can be armed, the CLI still fails closed at IPC token
+                    // validation instead of changing an otherwise valid tool decision.
+                    logger.warn(`[CodexRunner] EC command approved without a task-bound delegation ticket: session=${sessionKey}`);
+                }
+            }
             const response = this.toAppServerApprovalResponse(request.method, decision, toolInput, unattended);
             logger.info(`[CodexRunner] app-server approval response id=${request.id} method=${request.method} decision=${decision} response=${JSON.stringify(response)}`);
             return response;
@@ -2083,7 +2235,10 @@ export class CodexRunner {
                 break;
             }
             case 'item/started': {
-                yield* this.mapAppServerItemStarted(params.item, state);
+                for (const event of this.mapAppServerItemStarted(params.item, state)) {
+                    this.trackAppServerToolLifecycle(event, state);
+                    yield event;
+                }
                 break;
             }
             case 'item/agentMessage/delta': {
@@ -2099,11 +2254,17 @@ export class CodexRunner {
                 const item = params.item;
                 if (item?.id)
                     state.completedItemIds.add(item.id);
-                yield* this.mapAppServerItemCompleted(item, state);
+                for (const event of this.mapAppServerItemCompleted(item, state)) {
+                    this.trackAppServerToolLifecycle(event, state);
+                    yield event;
+                }
                 break;
             }
             case 'item/fileChange/patchUpdated': {
-                yield* this.mapAppServerFileChangePatchUpdated(params, state);
+                for (const event of this.mapAppServerFileChangePatchUpdated(params, state)) {
+                    this.trackAppServerToolLifecycle(event, state);
+                    yield event;
+                }
                 break;
             }
             case 'turn/plan/updated': {
@@ -2131,6 +2292,7 @@ export class CodexRunner {
                 if (turnId)
                     state.completedTurnIds.add(turnId);
                 this.activeTurns.delete(sessionId);
+                yield* this.reconcileOpenAppServerToolCalls(state, turnId);
                 if (turn.status === 'failed' && turn.error?.message) {
                     if (isRetryableError(new Error(turn.error.message))) {
                         throw new Error(turn.error.message);
@@ -2154,6 +2316,36 @@ export class CodexRunner {
             }
         }
     }
+    trackAppServerToolLifecycle(event, state) {
+        if (event.type !== 'tool_use' && event.type !== 'tool_result')
+            return;
+        if (!event.callId)
+            return;
+        if (event.type === 'tool_use') {
+            state.openToolCalls.set(event.callId, event.name);
+        }
+        else if (event.type === 'tool_result') {
+            state.openToolCalls.delete(event.callId);
+        }
+    }
+    *reconcileOpenAppServerToolCalls(state, turnId) {
+        if (state.openToolCalls.size === 0)
+            return;
+        const callIds = [...state.openToolCalls.keys()];
+        logger.warn(`[CodexRunner] Turn completed with ${callIds.length} open tool call(s): ` +
+            `thread=${state.threadId} turn=${turnId || state.turnId || 'unknown'} calls=${callIds.join(',')}`);
+        for (const [callId, name] of state.openToolCalls) {
+            yield {
+                type: 'tool_result',
+                name,
+                result: '',
+                isError: true,
+                error: 'Codex app-server ended the turn without an item/completed notification',
+                callId,
+            };
+        }
+        state.openToolCalls.clear();
+    }
     *mapAppServerItemStarted(item, state) {
         if (!item)
             return;
@@ -2458,6 +2650,7 @@ export class CodexRunner {
             costUsd: this.pickNumber(turn.costUsd, turn.totalCostUsd, turn.total_cost_usd),
             sessionTitle: typeof turn.sessionTitle === 'string' ? turn.sessionTitle : typeof turn.session_title === 'string' ? turn.session_title : undefined,
             numTurns: this.pickNumber(turn.numTurns, turn.num_turns),
+            model: state.model,
             tokenUsage,
             contextUsage,
         };
@@ -2567,13 +2760,14 @@ export class CodexRunner {
             return undefined;
         return '临时文件必须使用环境变量 `$TMPDIR`。它指向当前 EvolCore 会话的受管临时工作区；不要直接使用 `/tmp`，也不要使用其他会话的临时目录。';
     }
-    buildEvolcoreShellEnvironmentConfig(sessionId) {
+    buildEvolcoreShellEnvironmentConfig(sessionId, delegationCarrier) {
         const managedTempDir = this.ensureSessionTempDir(sessionId);
         return {
             shell_environment_policy: {
                 set: {
                     EVOLCORE_SESSION_ID: sessionId,
                     EVOLCORE_HOME: resolveRoot(),
+                    ...(delegationCarrier ? { [AGENT_DELEGATION_TOKEN_ENV]: delegationCarrier } : {}),
                     ...(managedTempDir ? { TMPDIR: managedTempDir } : {}),
                 },
             },
@@ -2592,6 +2786,7 @@ export class CodexRunner {
         this.threadExternalToolFingerprints.clear();
         this.threadExternalToolBoundaries.clear();
         this.trackedApprovalItems.clear();
+        this.threadDelegationCarriers.clear();
         this.pendingInterrupts.clear();
         this.permissionContexts.clear();
         this.chatModes.clear();

package/dist/agents/runner-types.js

@@ -69,7 +69,7 @@ export function isOneMillionContextModel(model) {
 export function realContextWindowForModel(model) {
     return isOneMillionContextModel(model) ? 1000000 : 200000;
 }
-/** autoCompact trigger threshold: 180000 for all models (conservative for cache limits). */
+/** autoCompact trigger threshold: 350000 for all models. */
 export function autoCompactWindowForModel(_model) {
-    return 180000;
+    return 350000;
 }

package/dist/aun/aid/agentmd.js

@@ -2,6 +2,85 @@ import fs from 'fs';
 import path from 'path';
 import { getAidStore, loadAid, SLOT } from './store.js';
 import { agentMdPath, aidLocalDir, resolveRoot } from '../../paths.js';
+const displayNameCache = new Map();
+const displayNamePending = new Map();
+const displayNameRevision = new Map();
+function normalizeAid(aid) {
+    const value = String(aid || '').trim();
+    return value.startsWith('@') ? value.slice(1) : value;
+}
+/** Extract the display name from an agent.md YAML frontmatter block. */
+export function parseAgentDisplayName(content) {
+    const frontmatter = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/)?.[1];
+    if (!frontmatter)
+        return undefined;
+    const name = frontmatter.match(/^name:\s*["']?(.+?)["']?\s*$/m)?.[1]?.trim();
+    return name || undefined;
+}
+function readLocalAgentDisplayName(aid) {
+    try {
+        return parseAgentDisplayName(fs.readFileSync(agentMdPath(aid), 'utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Resolve an agent.md display name without blocking on the network.
+ * Local content is returned immediately; a missing value starts one shared
+ * background refresh and remains undefined until a later lookup.
+ */
+export function resolveAgentDisplayName(aid) {
+    const normalizedAid = normalizeAid(aid);
+    if (!normalizedAid)
+        return undefined;
+    const cached = displayNameCache.get(normalizedAid);
+    if (cached)
+        return cached;
+    const localName = readLocalAgentDisplayName(normalizedAid);
+    if (localName) {
+        displayNameCache.set(normalizedAid, localName);
+        return localName;
+    }
+    void refreshAgentDisplayName(normalizedAid);
+    return undefined;
+}
+/** Fetch agent.md once and update the shared display-name cache. */
+export function refreshAgentDisplayName(aid) {
+    const normalizedAid = normalizeAid(aid);
+    if (!normalizedAid)
+        return Promise.resolve(undefined);
+    const existing = displayNamePending.get(normalizedAid);
+    if (existing)
+        return existing;
+    const revision = displayNameRevision.get(normalizedAid) ?? 0;
+    let pending;
+    pending = agentmdGet(normalizedAid)
+        .then(content => {
+        const name = typeof content === 'string' ? parseAgentDisplayName(content) : undefined;
+        if ((displayNameRevision.get(normalizedAid) ?? 0) !== revision)
+            return undefined;
+        if (name)
+            displayNameCache.set(normalizedAid, name);
+        return name;
+    })
+        .catch(() => undefined)
+        .finally(() => {
+        if (displayNamePending.get(normalizedAid) === pending) {
+            displayNamePending.delete(normalizedAid);
+        }
+    });
+    displayNamePending.set(normalizedAid, pending);
+    return pending;
+}
+export function invalidateAgentDisplayName(aid) {
+    const normalizedAid = normalizeAid(aid);
+    if (!normalizedAid)
+        return;
+    displayNameCache.delete(normalizedAid);
+    displayNamePending.delete(normalizedAid);
+    displayNameRevision.set(normalizedAid, (displayNameRevision.get(normalizedAid) ?? 0) + 1);
+}
 export function buildInitialAgentMd(opts) {
     const agentName = opts.aid.split('.')[0];
     const agentType = opts.type || 'ai';

package/dist/aun/aid/encryption-seed-policy.js

@@ -0,0 +1,29 @@
+export const AUN_KEYSTORE_ENCRYPTION_SEED = 'evol';
+export class AunEncryptionSeedPolicyError extends Error {
+    code = 'CUSTOM_AUN_ENCRYPTION_SEED_FORBIDDEN';
+    constructor(sources) {
+        super(`检测到自定义 AUN encryptionSeed（来源：${sources.join('、')}）。` +
+            'AUN encryptionSeed 由 EvolCore 内置管理，不允许用户自行设置。' +
+            '请停止操作并联系管理人员处理后再启动 EvolCore。');
+        this.name = 'AunEncryptionSeedPolicyError';
+    }
+}
+/**
+ * Reject values that would make an existing AUN keystore incompatible with
+ * EvolCore's fixed application seed. Explicit legacy copies of the fixed value
+ * remain readable so users can remove the obsolete setting without migration.
+ */
+export function assertAunEncryptionSeedPolicy(configuredValue, environmentValue) {
+    const customSources = [];
+    if (configuredValue !== undefined
+        && configuredValue !== null
+        && configuredValue !== AUN_KEYSTORE_ENCRYPTION_SEED) {
+        customSources.push('daemon.json aun.encryptionSeed');
+    }
+    if (environmentValue !== undefined
+        && environmentValue !== AUN_KEYSTORE_ENCRYPTION_SEED) {
+        customSources.push('环境变量 AUN_ENCRYPTION_SEED');
+    }
+    if (customSources.length > 0)
+        throw new AunEncryptionSeedPolicyError(customSources);
+}

package/dist/aun/aid/index.js

@@ -1,4 +1,4 @@
 export { isValidAid, aidList, aidListVerified, aidCreate, aidShow, aidDelete, aidLookup, verifySignAbility, probePkiRecoverability, appendAidLifecycle, readAidLifecycle } from './identity.js';
-export { buildInitialAgentMd, agentmdGet, agentmdPut, agentmdSync, stripAgentMdSignature, updateAgentMdFrontmatterAvatar, updateAgentMdFrontmatterName } from './agentmd.js';
+export { buildInitialAgentMd, agentmdGet, agentmdPut, agentmdSync, invalidateAgentDisplayName, parseAgentDisplayName, refreshAgentDisplayName, resolveAgentDisplayName, stripAgentMdSignature, updateAgentMdFrontmatterAvatar, updateAgentMdFrontmatterName, } from './agentmd.js';
 export { MIN_AUN_CORE_SDK, AUN_CORE_SDK_PKG, isAunSdkVersionOk, resolveAunCoreSdkPkg, ensureAunSdk, isAunSdkReady, downloadCaRoot, suppressSdkLogs, } from './client.js';
 export { getAidStore, loadClient, loadAid, AidLoadError, SLOT } from './store.js';

package/dist/aun/aid/store.js

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { AUN_KEYSTORE_ENCRYPTION_SEED } from './encryption-seed-policy.js';
 /**
  * Slot 命名约定（基于 fastaun 0.4.3 隔离键语义）。
  *
@@ -39,16 +40,12 @@ export class AidLoadError extends Error {
  */
 export async function getAidStore(opts) {
     const { aunPath: defaultAunPath } = await import('../../paths.js');
-    const { loadDaemonConfig } = await import('../../config-store.js');
     const { AIDStore } = await import('@agentunion/fastaun');
     const aunPath = opts.aunPath ?? defaultAunPath();
-    const encryptionSeed = loadDaemonConfig().aun?.encryptionSeed
-        ?? process.env.AUN_ENCRYPTION_SEED
-        ?? 'evol';
     const caCertPath = path.join(aunPath, 'CA', 'root', 'root.crt');
     const storeOpts = {
         aunPath,
-        encryptionSeed,
+        encryptionSeed: AUN_KEYSTORE_ENCRYPTION_SEED,
         slotId: opts.slotId,
         debug: opts.debug ?? false,
     };

package/dist/aun/outbox.js

@@ -158,3 +158,11 @@ export function hasPending(aid) {
         return false;
     }
 }
+/**
+ * 当前 outbox 中待发送条目数。用于诊断发送管线堵塞：depth 持续增长说明
+ * message.send 出队速度跟不上入队速度（网关慢 / 链路抖动 / 卡片洪泛），
+ * 是命令「回复慢/无回复」的先行指标。
+ */
+export function pendingCount(aid) {
+    return load(aid).length;
+}