evolcore 0.0.23 → 0.0.24

package/dist/index.js

@@ -100,6 +100,7 @@ import { MAIN_PACKAGE_NAME } from './product.js';
 import fs from 'fs';
 import crypto from 'crypto';
 import { fileURLToPath } from 'url';
+import * as platform from './utils/cross-platform.js';
 const controlMenuDeduper = new MenuRequestDeduper();
 /** 出站 payload 摘要（用于 channel-out.log） */
 function summarizeOutboundPayload(payload) {
@@ -134,6 +135,7 @@ function summarizeOutboundPayload(payload) {
             break;
         case 'status.started':
         case 'status.progress':
+        case 'status.notice':
         case 'status.requires_action':
         case 'status.queued':
         case 'status.completed':
@@ -326,11 +328,21 @@ function seedUpgradeCheckTrigger(manager, owner) {
     const cliPath = path.join(packageRoot, 'dist', 'cli', 'index.js');
     const packageJsonPath = path.join(packageRoot, 'package.json');
     const devMode = fs.existsSync(path.join(packageRoot, 'src', 'index.ts'));
+    // Resolve the launch argv at generation time: in a checkout this points the
+    // monitor at src/ through tsx, so a `npm run build` that wipes dist/ cannot
+    // take the watchdog down with it.
+    const monitorEntry = platform.resolveCliEntry(packageRoot);
+    const stageParent = path.join(resolvePaths().root, 'data', 'monitor-stage');
     fs.writeFileSync(scriptPath, `#!/usr/bin/env node
-const { existsSync, readFileSync } = require('node:fs');
+const fs = require('node:fs');
+const path = require('node:path');
+const { existsSync, readFileSync } = fs;
 const { spawn } = require('node:child_process');
 
-const CLI_PATH = ${JSON.stringify(cliPath)};
+const CLI_PATH = ${JSON.stringify(monitorEntry.entry)};
+const CLI_ARGS = ${JSON.stringify(monitorEntry.args)};
+const PACKAGE_ROOT = ${JSON.stringify(packageRoot)};
+const STAGE_PARENT = ${JSON.stringify(stageParent)};
 const PACKAGE_JSON = ${JSON.stringify(packageJsonPath)};
 const PACKAGE_NAME = ${JSON.stringify(MAIN_PACKAGE_NAME)};
 const DEV_MODE = ${devMode ? 'true' : 'false'};
@@ -405,14 +417,60 @@ async function main() {
     return;
   }
 
+  // Installed mode: copy the monitor out of the package before it upgrades that
+  // same package. Mirrors prepareMonitorStage(); kept inline because this file
+  // is generated standalone CJS. Any failure degrades to launching in place —
+  // losing upgrade isolation beats losing the upgrade.
+  let launchArgs = CLI_ARGS;
+  const launchEnv = { ...process.env };
+  if (!DEV_MODE && STAGE_PARENT) {
+    try {
+      const stageDir = path.join(STAGE_PARENT, 'upgrade-' + process.pid + '-' + Date.now());
+      fs.mkdirSync(stageDir, { recursive: true });
+      fs.cpSync(path.join(PACKAGE_ROOT, 'dist'), path.join(stageDir, 'dist'), { recursive: true });
+      if (existsSync(PACKAGE_JSON)) fs.copyFileSync(PACKAGE_JSON, path.join(stageDir, 'package.json'));
+      const modulesSource = path.join(PACKAGE_ROOT, 'node_modules');
+      if (existsSync(modulesSource)) {
+        const staged = path.join(stageDir, 'node_modules');
+        try {
+          // junction works unelevated on Windows; dir symlink elsewhere.
+          fs.symlinkSync(modulesSource, staged, process.platform === 'win32' ? 'junction' : 'dir');
+          fs.readdirSync(staged);
+        } catch (linkError) {
+          fs.rmSync(staged, { recursive: true, force: true });
+          fs.cpSync(modulesSource, staged, { recursive: true });
+        }
+      }
+      const stagedEntry = path.join(stageDir, 'dist', 'cli', 'index.js');
+      if (existsSync(stagedEntry)) {
+        launchArgs = [stagedEntry];
+        launchEnv.EVOLCORE_TARGET_PACKAGE_ROOT = PACKAGE_ROOT;
+        launchEnv.EVOLCORE_MONITOR_STAGE = stageDir;
+      }
+    } catch (stageError) {
+      // Fall through with the in-place entry.
+    }
+  }
+
   try {
-    const child = spawn(process.execPath, [CLI_PATH, 'restart-monitor'], {
+    const child = spawn(process.execPath, [...launchArgs, 'restart-monitor'], {
       detached: true,
       stdio: 'ignore',
       windowsHide: process.platform === 'win32',
-      env: { ...process.env },
+      env: launchEnv,
     });
     child.unref();
+    const pid = child.pid;
+    // The daemon is still running here — the monitor is what stops it. So a
+    // monitor that dies on load costs the upgrade, not the service; still,
+    // report it accurately instead of claiming success.
+    await new Promise(resolve => setTimeout(resolve, 3000));
+    let alive = false;
+    try { process.kill(pid, 0); alive = true; } catch (e) { alive = false; }
+    if (!alive) {
+      emit('error', 'restart-monitor exited during startup; upgrade to ' + remoteVersion + ' not applied');
+      return;
+    }
     emit('success', 'evolcore upgrade available: ' + localVersion + ' -> ' + remoteVersion + '; restart-monitor started');
   } catch (error) {
     emit('error', 'failed to start restart-monitor: ' + (error && error.message ? error.message : String(error)));
@@ -1066,7 +1124,7 @@ async function main() {
     agentLoader.register(new GeminiAgentPlugin());
     agentLoader.register(new EcagentAgentPlugin());
     const creationErrors = [];
-    const agentInstances = agentLoader.createAll(agentRegistry, {
+    const agentInstances = await agentLoader.createAll(agentRegistry, {
         onSessionIdUpdate: async (sessionId, agentSessionId, context) => {
             return await sessionManager.updateAgentSessionIdBySessionId(sessionId, agentSessionId, context?.turn);
         },
@@ -1493,8 +1551,9 @@ async function main() {
         }
         if (definition.execution.effort && !actor.daemonPrivileged) {
             const baseagent = definition.execution.baseagent
-                ?? agentRegistry.get(definition.agentAid)?.baseagent
-                ?? 'claude';
+                ?? agentRegistry.get(definition.agentAid)?.baseagent;
+            if (!baseagent)
+                throw new Error('cannot determine Trigger baseagent');
             const effortDecision = validateRuntimeStringFieldOverride({
                 selfAid: definition.agentAid,
                 role: actor.role,
@@ -2154,6 +2213,7 @@ async function main() {
             const pendingRouteContext = restartDelivery.delivery ? { delivery: restartDelivery.delivery } : {};
             const replyContext = {
                 ...(pendingRouteContext ?? {}),
+                ...(pending.threadId ? { threadId: pending.threadId } : {}),
                 ...(pending.rootId ? { replyToMessageId: pending.rootId, replyInThread: !!pending.threadId } : {}),
             };
             const owningAgent = agentRegistry.resolveByChannel(adapter.channelKey);
@@ -2165,10 +2225,23 @@ async function main() {
                 ...(restartDelivery.delivery ? { delivery: restartDelivery.delivery } : {}),
                 replyContext: Object.keys(replyContext).length > 0 ? replyContext : undefined,
             });
+            // restart-monitor 会在回滚/升级时写入 outcome：必须如实告诉发起方这次跑的是
+            // 哪个版本，否则 agent 会以为自己的改动或升级已经生效。
+            const restartNotice = pending.outcome === 'rolled-back'
+                ? {
+                    text: `⚠️ 服务已重启，但运行的是上一个版本。${pending.outcomeReason ? `原因：${pending.outcomeReason}。` : ''}本次改动未生效，请检查后重试。`,
+                    subtype: 'restarted-rolled-back',
+                }
+                : pending.outcome === 'upgraded'
+                    ? {
+                        text: `✅ 服务重启成功！${pending.outcomeReason ? `${pending.outcomeReason}` : ''}`,
+                        subtype: 'restarted-upgraded',
+                    }
+                    : { text: '✅ 服务重启成功！', subtype: 'restarted' };
             await sendSystemPayload(adapter, envelope, {
                 kind: 'system.notice',
-                text: '✅ 服务重启成功！',
-                subtype: 'restarted',
+                text: restartNotice.text,
+                subtype: restartNotice.subtype,
             });
             pendingRestartNoticeSent = true;
             fs.rmSync(pendingFile, { force: true });
@@ -2658,9 +2731,18 @@ async function main() {
                 continue;
             }
             const evolName = owningAgent.aid;
-            const baseagentName = session.baseagent || primaryBaseagent;
-            const agent = agentMap.get(`${evolName}::${baseagentName}`) || agentMap.get(primaryRunnerKey);
+            const baseagentName = typeof session.baseagent === 'string' ? session.baseagent.trim() : '';
+            if (!baseagentName) {
+                logger.error(`[Resume] session ${session.id}: missing baseagent binding, refusing implicit runner fallback`);
+                sessionManager.clearProcessing(session.id);
+                continue;
+            }
+            // Recovery must resume on the exact Agent × baseagent runner recorded by
+            // the Session. Never fall back to the primary runner: doing so can bind
+            // an in-flight session to a different backend.
+            const agent = agentMap.get(`${evolName}::${baseagentName}`);
             if (!agent) {
+                logger.error(`[Resume] session ${session.id}: runner unavailable for ${evolName}::${baseagentName}; refusing fallback`);
                 sessionManager.clearProcessing(session.id);
                 continue;
             }
@@ -2727,11 +2809,12 @@ async function main() {
                 return owner?.aid === aid;
             });
             const welcome = aunInstance?.channel;
-            const ownerAid = getFirstStaticAgentOwner(aid);
             const owningAgent = agentRegistry.get(aid);
-            const sessions = aunInstance && ownerAid && owningAgent
+            const firstOwnerAid = getFirstStaticAgentOwner(aid);
+            const sessions = aunInstance && firstOwnerAid && owningAgent
                 ? {
-                    ensurePostBootstrapMainSession: async () => {
+                    ensurePostBootstrapMainSession: async (owner) => {
+                        const ownerAid = owner || firstOwnerAid;
                         const channel = aunInstance.adapter.channelName;
                         const active = await sessionManager.getActiveSession(channel, ownerAid);
                         const ensured = await sessionManager.ensureNewMainSessionForOperation({
@@ -2739,7 +2822,7 @@ async function main() {
                             channelId: ownerAid,
                             projectPath: active?.projectPath || owningAgent.projectPath || defaultProjectPath,
                             baseagent: owningAgent.baseagent || active?.baseagent || primaryBaseagent,
-                            operationId: postBootstrapWelcomeOperationId(aid),
+                            operationId: postBootstrapWelcomeOperationId(aid, ownerAid),
                             identityMetadata: {
                                 ...(active?.metadata ?? {}),
                                 channelKey: aunInstance.adapter.channelKey,
@@ -2851,15 +2934,18 @@ async function main() {
             for (const runner of new Set(agentMap.values())) {
                 if (typeof runner?.evaluatePreToolUse !== 'function')
                     continue;
-                const result = await runner.evaluatePreToolUse(params.threadId, params.toolName, params.toolInput, params.signal, params.callId);
+                const result = await runner.evaluatePreToolUse(params.threadId, params.toolName, params.toolInput, params.signal, params.callId, params.sessionToken);
                 if (result.applicable)
                     return result;
             }
+            // A credential that no runner issued is forged or belongs to a thread
+            // whose rollout is gone. Never allow it; uncredentialed calls were
+            // already allowed by the IPC layer before reaching this executor.
             return {
                 ok: false,
                 applicable: true,
                 decision: 'deny',
-                reason: 'No active EvolCore Codex runner accepted this managed hook request',
+                reason: 'No active EvolCore Codex runner accepted this managed hook credential',
             };
         });
         const resolveManagedHandoffScope = async (params, operation) => {
@@ -3192,7 +3278,7 @@ async function main() {
                 const creationErrors = [];
                 const staged = candidate.config.enabled === false
                     ? []
-                    : agentLoader.createForAgent(candidate, {
+                    : await agentLoader.createForAgent(candidate, {
                         onSessionIdUpdate: async (sessionId, agentSessionId, context) => {
                             return await sessionManager.updateAgentSessionIdBySessionId(sessionId, agentSessionId, context?.turn);
                         },
@@ -3292,7 +3378,7 @@ async function main() {
                     throw new Error(agentRuntimeError);
                 }
                 const creationErrors = [];
-                const newAgentInstances = agentLoader.createForAgent(agent, {
+                const newAgentInstances = await agentLoader.createForAgent(agent, {
                     onSessionIdUpdate: async (sessionId, agentSessionId, context) => {
                         return await sessionManager.updateAgentSessionIdBySessionId(sessionId, agentSessionId, context?.turn);
                     },
@@ -3483,7 +3569,7 @@ async function main() {
             hotLoad: coreHotLoadAgent,
             resync: coreResyncAgents,
             create: async (options) => {
-                const { agentCreateNonInteractive } = await import('./cli/agent.js');
+                const { agentCreateNonInteractive } = await import('./cli/agent-create.js');
                 return await agentCreateNonInteractive(options, { hotLoadAgent: coreHotLoadAgent });
             },
             aunAids: () => channelInstances.flatMap((inst) => {
@@ -3732,12 +3818,20 @@ async function main() {
                 const aid = argv[2] && !argv[2].startsWith('--') ? argv[2] : undefined;
                 if (!aid)
                     return fail('INVALID_ARGS', 'ec agent new requires an AID');
-                const { agentCreateNonInteractive, resolveAgentCreatePlan, validateAgentCreatePlan } = await import('./cli/agent.js');
+                const { agentCreateNonInteractive, resolveAgentCreatePlan, validateAgentCreatePlan, parseAgentOwnerArgs } = await import('./cli/agent-create.js');
+                let ownerOptions;
+                try {
+                    ownerOptions = parseAgentOwnerArgs(argv);
+                }
+                catch (error) {
+                    return fail('INVALID_ARGS', error instanceof Error ? error.message : String(error));
+                }
                 const plan = resolveAgentCreatePlan({
                     aid,
                     project: value('--project'),
                     baseagent: value('--baseagent'),
-                    owner: value('--owner'),
+                    ...ownerOptions,
+                    handoff: value('--handoff'),
                     name: value('--name'),
                     description: value('--description'),
                     force: argv.includes('--force'),
@@ -3745,23 +3839,75 @@ async function main() {
                 const validationError = validateAgentCreatePlan(plan);
                 if (validationError)
                     return fail('INVALID_ARGS', validationError);
+                if (argv.includes('--handoff')) {
+                    if (!delegation.grant.messageId)
+                        return fail('INVALID_ARGS', '--handoff requires an originating message');
+                    if (!plan.handoff?.trim())
+                        return fail('INVALID_ARGS', '--handoff requires non-empty context');
+                    if ((plan.owners?.[0] ?? plan.owner) !== taskAid) {
+                        return fail('INVALID_ARGS', '--handoff requires the creating Agent to be the first Owner');
+                    }
+                    if (plan.configExists)
+                        return fail('INVALID_ARGS', '--handoff requires a new Agent');
+                }
                 if (argv.includes('--dry-run'))
                     return { ok: true, result: { ok: true, dryRun: true, plan } };
+                let handoffId;
+                if (plan.handoff) {
+                    try {
+                        const created = await handoffRuntime.createOutbound({
+                            selfAid: taskAid,
+                            to: aid,
+                            originSessionId: sessionId,
+                            originMessageId: delegation.grant.messageId,
+                            payload: { type: 'text', text: plan.handoff },
+                            encrypt: true,
+                            targetChatType: 'private',
+                            explicitReturnPolicy: 'required',
+                            contextOnly: true,
+                            originAuthorization: {
+                                actorId: delegation.grant.actorId,
+                                channelKey: delegation.grant.channel,
+                                channelType: delegation.grant.channelType,
+                                chatType: delegation.grant.chatType,
+                                peerKey: delegation.grant.peerKey,
+                            },
+                            causation: responseEngine.getTaskRuntimeContext(sessionId)?.causation,
+                        });
+                        handoffId = created.handoff?.handoff_id;
+                        if (!handoffId)
+                            return fail('INVALID_ARGS', '--handoff requires a different target session');
+                    }
+                    catch (error) {
+                        return fail('HANDOFF_PREPARE_FAILED', error instanceof Error ? error.message : String(error));
+                    }
+                }
                 const createOptions = {
                     aid: plan.aid,
                     project: plan.project,
                     baseagent: plan.baseagent,
                     owner: plan.owner,
+                    owners: plan.owners,
                     name: plan.name,
                     description: plan.description,
                     force: argv.includes('--force'),
                 };
-                const result = agentApplicationService
-                    ? await agentApplicationService.create(createOptions)
-                    : await agentCreateNonInteractive(createOptions);
-                return !result.ok
-                    ? fail(result.code ?? 'INTERNAL', result.error)
-                    : { ok: true, result: { ...result, configPath: '[redacted]' } };
+                try {
+                    const result = agentApplicationService
+                        ? await agentApplicationService.create(createOptions)
+                        : await agentCreateNonInteractive(createOptions);
+                    if (!result.ok) {
+                        if (handoffId)
+                            handoffRuntime.store.discard(taskAid, handoffId, 'operation_failed');
+                        return fail(result.code ?? 'INTERNAL', result.error);
+                    }
+                    return { ok: true, result: { ...result, configPath: '[redacted]', ...(handoffId ? { handoff_id: handoffId } : {}) } };
+                }
+                catch (error) {
+                    if (handoffId)
+                        handoffRuntime.store.discard(taskAid, handoffId, 'operation_failed');
+                    return fail('INTERNAL', error instanceof Error ? error.message : String(error));
+                }
             }
             if (operation === 'agent.delete') {
                 const result = agentApplicationService

package/dist/ipc.js

@@ -830,12 +830,21 @@ export class IpcServer {
                     || typeof cmd.toolName !== 'string' || !cmd.toolName) {
                     return { ok: false, applicable: true, decision: 'deny', reason: 'invalid Codex hook request' };
                 }
+                // Unmanaged Codex processes carry no credential and are allowed
+                // without consulting any runner; see bin/codex-managed-hook.mjs.
+                const sessionToken = typeof cmd.sessionToken === 'string' && cmd.sessionToken
+                    ? cmd.sessionToken
+                    : undefined;
+                if (!sessionToken) {
+                    return { ok: true, applicable: true, decision: 'allow' };
+                }
                 try {
                     return await this.codexPreToolUseExecutor({
                         threadId: cmd.threadId,
                         toolName: cmd.toolName,
                         toolInput: cmd.toolInput,
                         callId: typeof cmd.callId === 'string' ? cmd.callId : undefined,
+                        sessionToken,
                         signal: requestSignal,
                     });
                 }
@@ -1534,12 +1543,26 @@ export class IpcServer {
             && crypto.timingSafeEqual(provided, this.controlToken);
     }
 }
-/**
- * Query the running EvolCore daemon via Unix socket.
- * Returns null if the service is not running or the socket is unreachable.
- */
+export class IpcTransportError extends Error {
+    code;
+    endpoint;
+    constructor(code, endpoint) {
+        const hint = code === 'EPERM' || code === 'EACCES'
+            ? '权限被拒绝；Windows 下请检查 daemon 与 CLI 是否使用相同用户和提升权限级别。'
+            : code === 'ETIMEDOUT'
+                ? '等待 daemon 响应超时；请求可能已执行，请先检查状态再重试。'
+                : code === 'ENOENT' || code === 'ECONNREFUSED'
+                    ? 'daemon 未运行或 IPC 端点不存在，请先执行 ec start，再重试。'
+                    : '请检查 daemon 进程及 IPC 端点状态。';
+        super(`daemon IPC 失败 (${code}): ${endpoint}。${hint}`);
+        this.code = code;
+        this.endpoint = endpoint;
+        this.name = 'IpcTransportError';
+    }
+}
+/** Query the daemon; opt in to transport errors instead of the legacy null result. */
 /** Pass `null` as timeoutMs to wait without a client-side deadline. */
-export function ipcQuery(socketPath, cmd, timeoutMs = 3000) {
+export async function ipcQuery(socketPath, cmd, timeoutMs = 3000, options = {}) {
     const endpoint = normalizeIpcEndpoint(socketPath);
     let socketCandidates = [endpoint];
     if (isNamedPipe(endpoint)) {
@@ -1547,22 +1570,35 @@ export function ipcQuery(socketPath, cmd, timeoutMs = 3000) {
         if (endpoint === paths.socket)
             socketCandidates = getWindowsInstanceSocketPathCandidates(paths.root);
     }
-    if (socketCandidates.length <= 1)
-        return ipcQueryOnce(endpoint, cmd, timeoutMs);
-    return (async () => {
-        const startedAt = Date.now();
-        for (const candidate of socketCandidates) {
-            const remainingTimeout = timeoutMs === null
-                ? null
-                : Math.max(0, timeoutMs - (Date.now() - startedAt));
-            if (remainingTimeout === 0)
-                return null;
+    const startedAt = Date.now();
+    let failure;
+    for (const candidate of socketCandidates) {
+        const remainingTimeout = timeoutMs === null
+            ? null
+            : Math.max(0, timeoutMs - (Date.now() - startedAt));
+        if (remainingTimeout === 0) {
+            failure ??= new IpcTransportError('ETIMEDOUT', candidate);
+            break;
+        }
+        try {
             const response = await ipcQueryOnce(candidate, cmd, remainingTimeout);
             if (response !== null)
                 return response;
         }
-        return null;
-    })();
+        catch (error) {
+            if (!(error instanceof IpcTransportError))
+                throw error;
+            // A missing legacy pipe must not hide a permission failure on the canonical pipe.
+            if (!failure || ['ENOENT', 'ECONNREFUSED'].includes(failure.code))
+                failure = error;
+            // Only connection failures are safe to retry against a legacy endpoint.
+            if (!['ENOENT', 'ECONNREFUSED', 'EPERM', 'EACCES'].includes(error.code))
+                break;
+        }
+    }
+    if (options.throwOnError && failure)
+        throw failure;
+    return null;
 }
 function ipcQueryOnce(socketPath, cmd, timeoutMs = 3000) {
     let authenticatedCmd = cmd;
@@ -1587,7 +1623,7 @@ function ipcQueryOnce(socketPath, cmd, timeoutMs = 3000) {
             ? { daemonRuntimeEpoch: process.env[DAEMON_RUNTIME_EPOCH_ENV] }
             : {}),
     };
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
         const startedAtMono = performance.now();
         const queryId = nextIpcQueryId(request);
         const commandType = ipcLogToken(request.type);
@@ -1606,7 +1642,7 @@ function ipcQueryOnce(socketPath, cmd, timeoutMs = 3000) {
                 settled = true;
                 logPhase('timeout', ` timeout_ms=${timeoutMs}`);
                 conn.destroy();
-                resolve(null);
+                reject(new IpcTransportError('ETIMEDOUT', socketPath));
             }, timeoutMs);
         conn.on('connect', () => {
             if (settled)
@@ -1632,7 +1668,10 @@ function ipcQueryOnce(socketPath, cmd, timeoutMs = 3000) {
                     parse = 'invalid_json';
                 }
                 logPhase('response', ` bytes=${idx + 1} parse=${parse}`);
-                resolve(response);
+                if (parse === 'invalid_json')
+                    reject(new IpcTransportError('EPROTO', socketPath));
+                else
+                    resolve(response);
                 conn.destroy();
             }
         });
@@ -1643,7 +1682,15 @@ function ipcQueryOnce(socketPath, cmd, timeoutMs = 3000) {
             if (timer)
                 clearTimeout(timer);
             logPhase('error', ` code=${error.code ?? 'unknown'}`);
-            resolve(null);
+            reject(new IpcTransportError(error.code ?? 'UNKNOWN', socketPath));
+        });
+        conn.on('close', () => {
+            if (settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            reject(new IpcTransportError('ECONNRESET', socketPath));
         });
     });
 }

package/dist/paths.js

@@ -129,11 +129,22 @@ export function agentHandoffDir(aid) {
     return path.join(agentDataDir(aid), 'handoff');
 }
 export function agentOutboxPath(aid) {
-    return path.join(agentDataDir(aid), 'outbox.jsonl');
+    return path.join(resolvePaths().outboxDir, encodeURIComponent(aid), 'outbox.jsonl');
 }
 export function agentActivityOutboxPath(aid) {
+    return path.join(resolvePaths().outboxDir, encodeURIComponent(aid), 'activity-outbox.jsonl');
+}
+/** Pre-v4 per-Agent outbox paths retained only for compatibility import. */
+export function legacyAgentOutboxPath(aid) {
+    return path.join(agentDataDir(aid), 'outbox.jsonl');
+}
+export function legacyAgentActivityOutboxPath(aid) {
     return path.join(agentDataDir(aid), 'activity-outbox.jsonl');
 }
+/** Earliest global outbox layout: data/outbox/<aid>.jsonl. */
+export function legacyFlatOutboxPath(aid) {
+    return path.join(resolvePaths().outboxDir, `${aid}.jsonl`);
+}
 /** Directory-safe channel instance key used by connector runtime state. */
 function encodePathKey(value) {
     return encodeURIComponent(value);
@@ -283,6 +294,17 @@ function migrateFromAun() {
     const markerPath = path.join(newRoot, MIGRATION_MARKER);
     if (fs.existsSync(markerPath))
         return;
+    // Test workers use isolated temporary homes.  Copying the developer's
+    // machine-wide ~/.aun tree into every fresh fixture is both unnecessary and
+    // can make process-boundary tests exceed their timeout.  Production roots
+    // retain the normal one-time migration behavior.
+    if (process.env.EVOLCORE_TEST === '1') {
+        try {
+            fs.writeFileSync(markerPath, new Date().toISOString(), 'utf-8');
+        }
+        catch { }
+        return;
+    }
     const oldRoot = path.join(os.homedir(), '.aun');
     if (!fs.existsSync(oldRoot) || oldRoot === newRoot) {
         try {

package/dist/stats/billing.js

@@ -1,11 +1,13 @@
 /**
- * billing.ts — 读 model-prices.jsonl，按 billing_fn 调对应算法函数计算费用。
+ * billing.ts — 读 model-prices.jsonl，按模型参数中的 billing_fn 计算费用。
  * 费用查询时实时计算，不存入 DB（价格可能变动）。
  */
 import fs from 'fs';
 import path from 'path';
 import { getPackageRoot } from '../paths.js';
-// 价格表缓存（进程内，5 分钟 TTL）
+// 模型参数缓存（进程内，5 分钟 TTL）
+let _parameterCache = null;
+let _parameterCacheTs = 0;
 let _priceCache = null;
 let _priceCacheTs = 0;
 const PRICE_CACHE_TTL = 5 * 60 * 1000;
@@ -44,6 +46,14 @@ function _loadJsonlMerged(evolcoreHome, filename) {
     }
     return results;
 }
+function loadModelParameters(evolcoreHome) {
+    if (_parameterCache && Date.now() - _parameterCacheTs < PRICE_CACHE_TTL)
+        return _parameterCache;
+    const params = _loadJsonlMerged(evolcoreHome, 'model-prices.jsonl');
+    _parameterCache = params;
+    _parameterCacheTs = Date.now();
+    return params;
+}
 let _aliasCache = null;
 let _aliasCacheTs = 0;
 function loadAliases(evolcoreHome) {
@@ -64,7 +74,8 @@ function loadPrices(evolcoreHome) {
     const now = Date.now();
     if (_priceCache && now - _priceCacheTs < PRICE_CACHE_TTL)
         return _priceCache;
-    _priceCache = _loadJsonlMerged(evolcoreHome, 'model-prices.jsonl');
+    _priceCache = loadModelParameters(evolcoreHome).filter((record) => (typeof record.billing_fn === 'string'
+        && (record.currency === 'USD' || record.currency === 'CNY')));
     _priceCacheTs = now;
     return _priceCache;
 }
@@ -140,13 +151,16 @@ export function calcCost(evolcoreHome, event) {
         return {};
     return fn(event, priceRow);
 }
+// ── Model Specs ──────────────────────────────────────────────────────────────
 let _specCache = null;
 let _specCacheTs = 0;
 function loadSpecs(evolcoreHome) {
     const now = Date.now();
     if (_specCache && now - _specCacheTs < PRICE_CACHE_TTL)
         return _specCache;
-    _specCache = _loadJsonlMerged(evolcoreHome, 'model-specs.jsonl');
+    _specCache = loadModelParameters(evolcoreHome).filter((record) => (typeof record.context_window === 'number'
+        && typeof record.max_input_tokens === 'number'
+        && typeof record.max_output_tokens === 'number'));
     _specCacheTs = now;
     return _specCache;
 }

package/dist/utils/atomic-write.js

@@ -69,8 +69,32 @@ export function atomicWrite(filePath, content) {
         }
     }
     // The final rename atomically replaces the old target without an absent-path
-    // window.
-    fs.renameSync(tmp, filePath);
+    // window. Windows H-class projections can keep the destination pathname
+    // open while a sandbox is starting; replacing that directory entry then
+    // fails with EPERM. In that narrow case, preserve the target inode and write
+    // in place. The hot backup above still provides the previous full version.
+    try {
+        fs.renameSync(tmp, filePath);
+    }
+    catch (error) {
+        const code = error.code;
+        if (process.platform !== 'win32' || code !== 'EPERM')
+            throw error;
+        const detachedHot = `${hot}.${process.pid}.fallback.tmp`;
+        try {
+            // refreshHotBackup may have used a hard link. Detach that backup before
+            // the in-place write, otherwise updating the live inode would update the
+            // hot backup as well.
+            fs.copyFileSync(filePath, detachedHot);
+            fs.rmSync(hot, { force: true });
+            fs.renameSync(detachedHot, hot);
+            stableWrite(filePath, content);
+        }
+        finally {
+            fs.rmSync(detachedHot, { force: true });
+            fs.rmSync(tmp, { force: true });
+        }
+    }
 }
 export function atomicWriteJson(filePath, value) {
     atomicWrite(filePath, JSON.stringify(value, null, 2) + '\n');