evolcore 0.0.28 → 0.0.29

package/dist/paths.js

@@ -26,11 +26,11 @@ export function resolvePaths() {
     const agentsDir = path.join(root, 'agents');
     return {
         root,
-        // Session storage is partitioned by owning Agent. Keep the historical
-        // location separately so the explicit data migration can inventory it.
+        // Session storage is partitioned by owning Agent.
         sessionsDir: agentsDir,
-        legacySessionsDir: path.join(root, 'data', 'sessions'),
         instanceDir: path.join(root, 'data', 'instance'),
+        // Historical outbox root. Runtime writes use agentOutboxPath() below;
+        // this directory is retained only for explicit data migration.
         outboxDir: path.join(root, 'data', 'outbox'),
         dataDir: path.join(root, 'data'),
         claudeModelCache: path.join(root, 'data', 'claude-model-cache.json'),
@@ -89,7 +89,13 @@ export function agentContactConfig(aid) {
     return path.join(agentDir(aid), 'contact.json');
 }
 export function agentContactOperations(aid) {
-    return path.join(agentDir(aid), 'contact-operations.jsonl');
+    return path.join(agentDataDir(aid), 'contact', 'operations.jsonl');
+}
+export function agentContactDataDir(aid) {
+    return path.join(agentDataDir(aid), 'contact');
+}
+export function agentContactAuditPath(aid) {
+    return path.join(agentContactDataDir(aid), 'audit.jsonl');
 }
 export function agentPersonalDir(aid) {
     return path.join(agentDir(aid), 'personal');
@@ -132,28 +138,44 @@ export function agentSessionsDir(aid) {
 export function agentDataDir(aid) {
     return path.join(agentDir(aid), 'data');
 }
+export function agentTaskActivityDir(aid) {
+    return path.join(agentDataDir(aid), 'task-activity');
+}
 export function agentDataCacheDir(aid) {
     return path.join(agentDataDir(aid), 'cache');
 }
 export function agentHandoffDir(aid) {
     return path.join(agentDataDir(aid), 'handoff');
 }
+export function agentCodexTokensDir(aid) {
+    return path.join(agentDataDir(aid), 'codex-tokens');
+}
+export function agentCodexTokenPath(aid, threadId) {
+    return path.join(agentCodexTokensDir(aid), `${encodeURIComponent(threadId)}.json`);
+}
 export function agentGroupInviteReviewsPath(aid) {
     return path.join(agentDataDir(aid), 'aun', 'group-invite-reviews.json');
 }
 export function agentOutboxPath(aid) {
-    return path.join(resolvePaths().outboxDir, encodeURIComponent(aid), 'outbox.jsonl');
+    return path.join(agentDataDir(aid), 'outbox', 'delivery.jsonl');
 }
 export function agentActivityOutboxPath(aid) {
-    return path.join(resolvePaths().outboxDir, encodeURIComponent(aid), 'activity-outbox.jsonl');
+    return path.join(agentDataDir(aid), 'outbox', 'activity.jsonl');
 }
-/** Pre-v4 per-Agent outbox paths retained only for compatibility import. */
+/** Historical per-Agent outbox paths used only by the explicit migration. */
 export function legacyAgentOutboxPath(aid) {
     return path.join(agentDataDir(aid), 'outbox.jsonl');
 }
 export function legacyAgentActivityOutboxPath(aid) {
     return path.join(agentDataDir(aid), 'activity-outbox.jsonl');
 }
+/** Historical shared per-Agent outbox directory layout. */
+export function legacySharedOutboxPath(aid) {
+    return path.join(resolvePaths().outboxDir, encodeURIComponent(aid), 'outbox.jsonl');
+}
+export function legacySharedActivityOutboxPath(aid) {
+    return path.join(resolvePaths().outboxDir, encodeURIComponent(aid), 'activity-outbox.jsonl');
+}
 /** Earliest global outbox layout: data/outbox/<aid>.jsonl. */
 export function legacyFlatOutboxPath(aid) {
     return path.join(resolvePaths().outboxDir, `${aid}.jsonl`);
@@ -261,7 +283,7 @@ export function getWindowsInstanceSocketPathCandidates(root) {
     }
     return candidates;
 }
-function resolveInstanceSocketPath(root) {
+export function resolveInstanceSocketPath(root) {
     if (isWindows)
         return getWindowsInstanceSocketPathCandidates(root)[0];
     const filesystemPath = path.join(root, 'data', 'instance', INSTANCE_SOCKET_FILENAME);
@@ -291,7 +313,6 @@ export function ensureDataDirs() {
     fs.mkdirSync(p.agentsDir, { recursive: true });
     fs.mkdirSync(p.sessionsDir, { recursive: true });
     fs.mkdirSync(p.instanceDir, { recursive: true });
-    fs.mkdirSync(p.outboxDir, { recursive: true });
     fs.mkdirSync(p.eckDir, { recursive: true });
     fs.mkdirSync(aidsDir(), { recursive: true });
     migrateLegacyAgentJsonlLogs(p.agentsDir, p.logs);

package/dist/response-system/engines/v1/proactive-flow.js

@@ -9,7 +9,10 @@
  * 依赖全部由调用点显式传入。
  */
 const STATE_KEY = 'proactive';
-const TOOL_REPORT_INTERVAL = 10;
+const SNAPSHOT_KEY = 'proactive:continuation';
+const OWNER_KEY = 'proactive:owner';
+const SNAPSHOT_MAX_AGE_MS = 30 * 60 * 1_000;
+const TOOL_REPORT_INTERVAL = 20;
 const SEND_RECEIPT_RE = /["']?(?:message[_ -]?id|handoff[_ -]?id)["']?\s*[:=]\s*["']?([A-Za-z0-9][A-Za-z0-9._:-]*)/gi;
 const HANDOFF_TEXT_RECEIPT_RE = /\bhandoff\s+(h-[A-Za-z0-9._-]+)/i;
 const RETURN_CONTENT_RE = /["']?(?:return[_ -]?content|returnContent)["']?\s*[:=]\s*["']?([^}\n,]*)/i;
@@ -161,6 +164,79 @@ function buildState(message, cfg) {
         toolReportPending: false,
     };
 }
+function normalizedThread(threadId) {
+    return threadId && threadId !== 'main' ? threadId : '';
+}
+function isResumableTerminal(terminal) {
+    return terminal?.status === 'interrupted' && terminal.reason === 'daemon_restart'
+        || terminal?.status === 'cancelled' && (terminal.reason === 'stop' || terminal.reason === 'explicit_cancel');
+}
+function canRestoreSnapshot(ctx, state, snapshot) {
+    const previous = ctx.previousTurnState;
+    const terminal = previous?.lastTerminal;
+    const continuation = ctx.continuation;
+    if (!continuation || !previous || previous.active || !isResumableTerminal(terminal))
+        return false;
+    if (!snapshot.agentSessionId || !snapshot.baseagent)
+        return false;
+    const age = Date.now() - snapshot.finishedAt;
+    if (!Number.isFinite(age) || age < 0 || age > SNAPSHOT_MAX_AGE_MS
+        || !Number.isSafeInteger(snapshot.toolCount) || snapshot.toolCount < 0
+        || typeof snapshot.firstToolDone !== 'boolean' || typeof snapshot.toolReportPending !== 'boolean'
+        || snapshot.sessionId !== ctx.session.id || snapshot.selfAid !== ctx.session.selfAID
+        || snapshot.channel !== ctx.session.channel || snapshot.channelId !== ctx.session.channelId
+        || snapshot.chatType !== ctx.message.chatType || snapshot.chatType !== ctx.session.chatType
+        || snapshot.threadId !== normalizedThread(ctx.session.threadId)
+        || snapshot.threadId !== normalizedThread(continuation.threadId)
+        || snapshot.baseagent !== ctx.session.baseagent || snapshot.agentSessionId !== ctx.session.agentSessionId
+        || snapshot.firstSendRequired !== state.firstSendRequired
+        || snapshot.toolReportRequired !== state.toolReportRequired
+        || snapshot.toolReportInterval !== state.toolReportInterval
+        || snapshot.turnId !== terminal.turnId || snapshot.taskId !== terminal.taskId
+        || snapshot.generation !== terminal.generation || snapshot.finishedAt !== terminal.finishedAt)
+        return false;
+    if (state.chatType === 'group' && continuation.groupId !== snapshot.channelId)
+        return false;
+    if (continuation.kind === 'taskRecovery') {
+        return continuation.taskId === snapshot.taskId && continuation.generation === previous.generation;
+    }
+    return continuation.kind === 'restartResume'
+        && terminal.status === 'interrupted' && terminal.reason === 'daemon_restart';
+}
+function saveContinuation(ctx) {
+    const state = ctx.state.get(STATE_KEY);
+    if (!state || !ctx.sessionState || ctx.sessionState.get(OWNER_KEY) !== state)
+        return;
+    ctx.sessionState.delete(OWNER_KEY);
+    const terminal = ctx.terminal;
+    if (!terminal || terminal.turnId !== ctx.turn.turnId || terminal.taskId !== ctx.turn.taskId
+        || terminal.generation !== ctx.turn.generation)
+        return;
+    ctx.sessionState.delete(SNAPSHOT_KEY);
+    if (!isResumableTerminal(terminal))
+        return;
+    const snapshot = {
+        sessionId: ctx.session.id,
+        selfAid: ctx.session.selfAID,
+        channel: ctx.session.channel,
+        channelId: ctx.session.channelId,
+        chatType: state.chatType,
+        threadId: normalizedThread(ctx.session.threadId),
+        baseagent: ctx.session.baseagent,
+        agentSessionId: ctx.session.agentSessionId,
+        turnId: terminal.turnId,
+        taskId: terminal.taskId,
+        generation: terminal.generation,
+        finishedAt: terminal.finishedAt,
+        firstToolDone: state.firstToolDone,
+        toolCount: state.toolCount,
+        toolReportPending: state.toolReportPending,
+        firstSendRequired: state.firstSendRequired,
+        toolReportRequired: state.toolReportRequired,
+        toolReportInterval: state.toolReportInterval,
+    };
+    ctx.sessionState.set(SNAPSHOT_KEY, snapshot);
+}
 export const proactiveFlow = {
     chatMode: 'proactive',
     // ─── 入站决策：构造 runtimeState ───
@@ -187,7 +263,15 @@ export const proactiveFlow = {
     // ─── beforeProcess：把 runtimeState 落入 ctx.state，供后续钩子共享 ───
     beforeProcess(ctx) {
         const state = buildState(ctx.message, ctx.modeConfig ?? {});
+        const snapshot = ctx.sessionState?.get(SNAPSHOT_KEY);
+        ctx.sessionState?.delete(SNAPSHOT_KEY);
+        if (snapshot && canRestoreSnapshot(ctx, state, snapshot)) {
+            state.firstToolDone = snapshot.firstToolDone;
+            state.toolCount = snapshot.toolCount;
+            state.toolReportPending = state.toolReportRequired && snapshot.toolReportPending;
+        }
         ctx.state.set(STATE_KEY, state);
+        ctx.sessionState?.set(OWNER_KEY, state);
     },
     // ─── configureRun：policyHook 只判定，不推进状态 ───
     configureRun(ctx) {
@@ -240,29 +324,43 @@ export const proactiveFlow = {
         const isAllowedTool = ctx.isSendCommand(ctx.toolName, ctx.toolInput);
         if (!state.toolUseReminder)
             return;
-        // 队列未读变化提醒
-        const queueLen = ctx.getQueueLength();
-        if (queueLen !== state.lastQueueReminderLen) {
-            state.lastQueueReminderLen = queueLen;
-            if (queueLen > 0) {
-                const queueMsg = queueLen >= 5
-                    ? `⚠️ 有 ${queueLen} 条消息未读，请尽快完成当前任务，或使用 ec ctl queue 读取后同步处理。`
-                    : `⚠️ 有 ${queueLen} 条消息未读，可使用 ec ctl queue 读取。`;
-                ctx.recordReminder?.({ kind: 'queue_unread', text: queueMsg, queueLength: queueLen });
-                ctx.injectToModel(queueMsg);
-            }
-        }
         // 工具计数（排除表态命令白名单）
         if (state.toolReportRequired && !isAllowedTool)
             state.toolCount++;
+        // 队列未读变化提醒：首次达到 3 条立即提醒，后续复用工具汇报的计数间隔，
+        // 避免连续工具调用时每次队列数量变化都重复注入。
+        const queueLen = ctx.getQueueLength();
+        const queueChanged = queueLen !== state.lastQueueReminderLen;
+        const toolReportDue = state.toolReportRequired
+            && !isAllowedTool
+            && state.toolCount > 0
+            && state.toolCount % state.toolReportInterval === 0;
+        let queueReminder;
+        const queueReminderDue = state.lastQueueReminderLen === 0
+            ? queueLen >= 3
+            : toolReportDue;
+        if (queueLen === 0) {
+            state.lastQueueReminderLen = 0;
+        }
+        else if (queueChanged && queueReminderDue) {
+            state.lastQueueReminderLen = queueLen;
+            queueReminder = queueLen >= 5
+                ? `⚠️ 有 ${queueLen} 条消息未读，请尽快完成当前任务，或使用 ec ctl queue 读取后同步处理。`
+                : `⚠️ 有 ${queueLen} 条消息未读，可使用 ec ctl queue 读取。`;
+            ctx.recordReminder?.({ kind: 'queue_unread', text: queueReminder, queueLength: queueLen });
+        }
+        if (queueReminder && !toolReportDue) {
+            ctx.injectToModel(queueReminder);
+        }
         // 每 N 次工具调用警告
-        if (state.toolReportRequired && state.toolCount > 0 && state.toolCount % state.toolReportInterval === 0) {
+        // 只有计数推进到新阈值时才提醒；发送工具不能重新打开已解除的汇报门禁。
+        if (toolReportDue) {
             state.toolReportPending = true;
             const cmdHint = state.chatType === 'group' ? 'ec group send' : 'ec msg send';
             const target = state.chatType === 'group' ? '群里' : '对方';
             const reportMsg = `⚠️ 工具调用已达到 ${state.toolCount} 次，请立即用 ${cmdHint} 向${target}汇报当前情况和下一步意图。`;
             ctx.recordReminder?.({ kind: 'tool_report', text: reportMsg, toolCount: state.toolCount });
-            ctx.injectToModel(reportMsg);
+            ctx.injectToModel(queueReminder ? `${queueReminder}\n${reportMsg}` : reportMsg);
         }
     },
     // ─── onToolResult：成功发送回执后解除门禁 ───
@@ -291,6 +389,9 @@ export const proactiveFlow = {
             await ctx.updateSessionMeta({ lastProactiveFlag: true });
         }
     },
+    onTurnEnd(ctx) {
+        saveContinuation(ctx);
+    },
     // ─── afterProcess：Unknown skill 兜底 ───
     async afterProcess(ctx) {
         if (!ctx.streamResult.hasReceivedText && /^Unknown skill:\s+\S+/i.test(ctx.fullText.trim())) {

package/dist/response-system/modes/single-session/index.js

@@ -88,4 +88,7 @@ export class SingleSessionMode {
     afterProcess(ctx) {
         return this.flow().afterProcess?.(ctx);
     }
+    onTurnEnd(ctx) {
+        return this.flow().onTurnEnd?.(ctx);
+    }
 }

package/dist/trigger/feedback.js

@@ -274,6 +274,7 @@ export class TriggerFeedbackDispatcher {
                         ?? (input.trigger.origin?.channelKey ? channelTypeFromKey(input.trigger.origin.channelKey) : undefined),
                     ...(eventSession ? { originChatType: messageChatType, originConversationId: target.channelId } : {}),
                     originControl: !eventSession && input.trigger.origin?.channelKey === 'daemon',
+                    noopSentinel: input.trigger.execution.noopSentinel,
                     authorizedBy: input.trigger.authorizedBy,
                 },
             };

package/dist/trigger/manager.js

@@ -4,7 +4,6 @@ import { agentTriggersDir } from '../paths.js';
 import { assertExplicitAunDeliveryRoutes, definitionRevision, normalizeTriggerDefinition, resolveScriptPath, safeRelativePath, } from './validation.js';
 import { atomicWriteJson } from '../core/session/session-fs-store.js';
 import { TriggerHistoryStore } from './history.js';
-import { rewriteLegacyTriggerSessionPaths } from './legacy-session-history.js';
 export class TriggerDefinitionManager {
     agentAid;
     rootDir;
@@ -42,15 +41,6 @@ export class TriggerDefinitionManager {
             this.writeDefinition(definition);
             this.history.recordDefinition('trigger.updated', definition, { reason: 'legacy-aun-target-chat-type' });
         }
-        if (typeof definition.execution.prompt === 'string') {
-            const rewritten = rewriteLegacyTriggerSessionPaths(definition.execution.prompt, definition.agentAid);
-            if (rewritten !== definition.execution.prompt) {
-                definition.execution = { ...definition.execution, prompt: rewritten };
-                definition.updatedAt = Date.now();
-                this.writeDefinition(definition);
-                this.history.recordDefinition('trigger.updated', definition, { reason: 'legacy-session-history-paths' });
-            }
-        }
         return definition;
     }
     require(triggerId) {

package/dist/trigger/scheduler.js

@@ -193,6 +193,17 @@ export class TriggerRuntimeScheduler {
     history(triggerId, limit = 100) {
         return this.manager.history.events(triggerId, limit);
     }
+    recentRuns(triggerId, limit = 50) {
+        return this.audit.recent(triggerId, limit).map(run => ({
+            runId: run.runId,
+            status: run.status,
+            ...(run.reason ? { reason: run.reason } : {}),
+            startedAt: run.startedAt,
+            finishedAt: run.finishedAt,
+            durationMs: Math.max(0, run.finishedAt - run.startedAt),
+            ...(run.error?.code ? { errorCode: run.error.code } : {}),
+        }));
+    }
     scriptPreview(definition) {
         if (definition.execution.type !== 'script' || !definition.execution.script)
             return undefined;

package/dist/trigger/validation.js

@@ -452,12 +452,34 @@ function normalizeExecution(value, _opts) {
         permissionMode: normalizeTriggerPermissionMode(raw.permissionMode),
         onError: normalizeOnError(raw.onError),
         noopSentinel: optionalString(raw.noopSentinel) ?? DEFAULT_NOOP_SENTINEL,
+        memoryMode: normalizeMemoryMode(raw.memoryMode),
+        memoryScope: normalizeMemoryScope(raw.memoryScope),
+        consolidationBatchDir: optionalString(raw.consolidationBatchDir ?? raw.consolidationLogBase),
+        consolidationChatDir: optionalString(raw.consolidationChatDir),
+        consolidationMemoryDir: optionalString(raw.consolidationMemoryDir),
     };
     if (execution.type === 'script' && execution.permissionMode === 'fullaccess') {
         throw new Error('script Trigger already executes as the daemon OS user and cannot declare execution.permissionMode=fullaccess');
     }
     return execution;
 }
+const MEMORY_MODES = ['notes', 'generalize', 'promote', 'profile', 'forget'];
+function normalizeMemoryMode(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || !MEMORY_MODES.includes(value)) {
+        throw new Error(`execution.memoryMode must be one of ${MEMORY_MODES.join(', ')}`);
+    }
+    return value;
+}
+function normalizeMemoryScope(value) {
+    if (value === undefined)
+        return undefined;
+    if (value !== 'relation' && value !== 'agent' && value !== 'owner') {
+        throw new Error('execution.memoryScope must be relation, agent, or owner');
+    }
+    return value;
+}
 function normalizeExecutionBaseagent(value) {
     if (value === undefined)
         return undefined;

package/dist/utils/avatar-upload.js

@@ -5,8 +5,10 @@ import net from 'net';
 import { agentmdGet, agentmdPut, updateAgentMdFrontmatterAvatar } from '../aun/aid/agentmd.js';
 import { storageRm, storageUpload } from '../aun/storage/index.js';
 import { logger } from './logger.js';
+import sharp from 'sharp';
 import { validateImage } from './media-cache.js';
 const MAX_AVATAR_BYTES = 500 * 1024;
+export const MAX_AVATAR_SOURCE_BYTES = 10 * 1024 * 1024;
 const MIN_AVATAR_DIMENSION = 128;
 const MAX_AVATAR_DIMENSION = 2048;
 const MIN_AVATAR_RATIO = 0.8;
@@ -20,6 +22,29 @@ const MIME_EXT = {
     'image/jpeg': 'jpg',
     'image/webp': 'webp',
 };
+export async function normalizeAvatarImage(buffer) {
+    if (buffer.length > MAX_AVATAR_SOURCE_BYTES)
+        throw new Error('头像源文件超过 10 MiB 限制');
+    const input = sharp(buffer, { failOn: 'error', limitInputPixels: 80_000_000, animated: false });
+    const metadata = await input.metadata();
+    const sourceMimeType = metadata.format === 'jpeg' ? 'image/jpeg' : `image/${metadata.format ?? ''}`;
+    if (!['image/jpeg', 'image/png', 'image/webp'].includes(sourceMimeType)) {
+        throw new Error(`头像格式不支持：${sourceMimeType || 'unknown'}；请提供 PNG、JPEG 或 WebP 图片`);
+    }
+    if (!metadata.width || !metadata.height)
+        throw new Error('无法读取头像尺寸');
+    const sizes = [512, 384, 256, 192, 128];
+    const qualities = [82, 74, 66, 58, 50];
+    for (let i = 0; i < sizes.length; i++) {
+        const output = await sharp(buffer, { failOn: 'error', limitInputPixels: 80_000_000, animated: false })
+            .rotate().resize(sizes[i], sizes[i], { fit: 'contain', background: '#ffffff' })
+            .jpeg({ mozjpeg: true, quality: qualities[i] }).toBuffer();
+        if (output.length <= MAX_AVATAR_BYTES) {
+            return { buffer: output, mimeType: 'image/jpeg', width: sizes[i], height: sizes[i], sourceWidth: metadata.width, sourceHeight: metadata.height };
+        }
+    }
+    throw new Error('图片经过缩放和压缩后仍超过头像 500 KiB 上限');
+}
 function fail(error, code) {
     return { ok: false, error, code };
 }
@@ -50,12 +75,12 @@ function parseAvatarDataUrl(dataUrl) {
         return fail('avatar base64 编码无效', 'INVALID_ARGS');
     }
     const estimatedSize = estimateDecodedBytes(base64);
-    if (estimatedSize > MAX_AVATAR_BYTES) {
-        return fail(`头像大小超过 500KB 限制（当前: ${formatKb(estimatedSize)}）`, 'INVALID_ARGS');
+    if (estimatedSize > MAX_AVATAR_SOURCE_BYTES) {
+        return fail(`头像源文件超过 ${formatKb(MAX_AVATAR_SOURCE_BYTES)} 限制（当前: ${formatKb(estimatedSize)}）`, 'INVALID_ARGS');
     }
     const buffer = Buffer.from(base64, 'base64');
-    if (buffer.length > MAX_AVATAR_BYTES) {
-        return fail(`头像大小超过 500KB 限制（当前: ${formatKb(buffer.length)}）`, 'INVALID_ARGS');
+    if (buffer.length > MAX_AVATAR_SOURCE_BYTES) {
+        return fail(`头像源文件超过 ${formatKb(MAX_AVATAR_SOURCE_BYTES)} 限制（当前: ${formatKb(buffer.length)}）`, 'INVALID_ARGS');
     }
     return { mime: declaredMime, buffer };
 }
@@ -71,13 +96,16 @@ export async function uploadAvatar(aid, dataUrl, opts) {
     const parsed = parseAvatarDataUrl(dataUrl);
     if ('ok' in parsed)
         return parsed;
-    const validated = await validateAvatarBuffer(parsed.buffer);
-    if (!('dimensions' in validated))
-        return validated;
-    if (validated.mime !== parsed.mime) {
-        return fail(`头像格式验证失败：声明 ${parsed.mime}，实际 ${validated.mime}`, 'INVALID_ARGS');
+    const detected = await validateImage(parsed.buffer, {
+        maxSize: MAX_AVATAR_SOURCE_BYTES,
+        allowedMimes: ALLOWED_AVATAR_MIMES,
+    });
+    if (detected.mime === null)
+        return fail(`头像格式验证失败：${detected.reason}`, 'INVALID_ARGS');
+    if (detected.mime !== parsed.mime) {
+        return fail(`头像格式验证失败：声明 ${parsed.mime}，实际 ${detected.mime}`, 'INVALID_ARGS');
     }
-    return uploadValidatedAvatar(aid, parsed.buffer, validated.mime, validated.dimensions, opts);
+    return uploadAvatarBuffer(aid, parsed.buffer, opts);
 }
 function parseJpegDimensions(buffer) {
     let offset = 2;
@@ -258,9 +286,9 @@ async function downloadAvatarBuffer(sourceUrl) {
             return fail(`头像 URL 返回 HTTP ${response.status}`, 'UPLOAD_FAILED');
         }
         const length = Number(response.headers.get('content-length') || 0);
-        if (length > MAX_AVATAR_BYTES) {
+        if (length > MAX_AVATAR_SOURCE_BYTES) {
             clearTimeout(timeout);
-            return fail('头像大小超过 500KB 限制', 'INVALID_ARGS');
+            return fail('头像源文件超过 10 MiB 限制', 'INVALID_ARGS');
         }
         if (!response.body) {
             clearTimeout(timeout);
@@ -276,9 +304,9 @@ async function downloadAvatarBuffer(sourceUrl) {
                     break;
                 const chunk = Buffer.from(part.value);
                 total += chunk.length;
-                if (total > MAX_AVATAR_BYTES) {
+                if (total > MAX_AVATAR_SOURCE_BYTES) {
                     await reader.cancel();
-                    return fail('头像大小超过 500KB 限制', 'INVALID_ARGS');
+                    return fail('头像源文件超过 10 MiB 限制', 'INVALID_ARGS');
                 }
                 chunks.push(chunk);
             }
@@ -344,7 +372,7 @@ async function uploadValidatedAvatar(aid, buffer, mime, dimensions, opts) {
 }
 async function validateAvatarBuffer(buffer) {
     const validated = await validateImage(buffer, {
-        maxSize: MAX_AVATAR_BYTES,
+        maxSize: MAX_AVATAR_SOURCE_BYTES,
         allowedMimes: ALLOWED_AVATAR_MIMES,
     });
     if (validated.mime === null)
@@ -367,9 +395,22 @@ export async function uploadAvatarFile(aid, filePath, opts) {
 /** Upload already-read image bytes; callers can use this after secure fd validation. */
 export async function uploadAvatarBuffer(aid, buffer, opts) {
     const validated = await validateAvatarBuffer(buffer);
-    if (!('dimensions' in validated))
-        return validated;
-    return uploadValidatedAvatar(aid, buffer, validated.mime, validated.dimensions, opts);
+    if ('dimensions' in validated && buffer.length <= MAX_AVATAR_BYTES) {
+        return uploadValidatedAvatar(aid, buffer, validated.mime, validated.dimensions, opts);
+    }
+    try {
+        const normalized = await normalizeAvatarImage(buffer);
+        const uploaded = await uploadValidatedAvatar(aid, normalized.buffer, normalized.mimeType, { width: normalized.width, height: normalized.height }, opts);
+        return uploaded.ok ? {
+            ...uploaded,
+            normalized: true,
+            sourceWidth: normalized.sourceWidth,
+            sourceHeight: normalized.sourceHeight,
+        } : uploaded;
+    }
+    catch (error) {
+        return fail(`${'error' in validated && validated.error ? validated.error : '头像不符合规范'}；自动规范化失败: ${messageOf(error)}`, 'INVALID_ARGS');
+    }
 }
 /** Download an HTTPS image with redirect/SSRF/size guards, then upload it. */
 export async function uploadAvatarUrl(aid, url, opts) {

package/dist/utils/error-dict.json

@@ -109,19 +109,22 @@
       "id": "api-error-502",
       "match": "api error: 502",
       "action": "retry",
-      "type": "api_error"
+      "type": "api_error",
+      "message": "❌ API 网关异常，请稍后重试"
     },
     {
       "id": "api-error-503",
       "match": "api error: 503",
       "action": "retry",
-      "type": "api_error"
+      "type": "api_error",
+      "message": "❌ API 服务暂时不可用，请稍后重试"
     },
     {
       "id": "api-error-504",
       "match": "api error: 504",
       "action": "retry",
-      "type": "api_error"
+      "type": "api_error",
+      "message": "❌ API 请求超时，请稍后重试"
     },
     {
       "id": "not-valid-json",

package/dist/utils/error-utils.js

@@ -25,6 +25,7 @@ export function isExecutionFailure(error) {
     return error instanceof ExecutionTimeoutError || error instanceof OrphanedTargetSessionError;
 }
 export const CLAUDE_STARTUP_ARGUMENTS_TOO_LONG = 'claude_startup_arguments_too_long';
+export const CLAUDE_CODE_STARTUP_FAILED = 'claude_code_startup_failed';
 /** A completed provider response exhausted its output budget, rather than a transport failure. */
 export function isOutputTokenLimitError(error) {
     const record = error && typeof error === 'object' ? error : undefined;
@@ -58,6 +59,22 @@ export function createClaudeStartupArgumentsTooLongError(error) {
         wrapped.cause = error;
     return wrapped;
 }
+export function isClaudeCodeStartupProcessError(error) {
+    const record = error && typeof error === 'object' ? error : undefined;
+    const code = String(record?.code ?? '').toLowerCase();
+    const message = String(record?.message ?? error ?? '').toLowerCase();
+    return code === 'eftype'
+        || message.includes('spawn eftype')
+        || message.includes('not a valid application for this os platform');
+}
+export function createClaudeCodeStartupError(error) {
+    const wrapped = new Error(`${CLAUDE_CODE_STARTUP_FAILED}: Claude Code SDK 本地运行时启动失败，任务未执行`);
+    wrapped.name = 'ClaudeCodeStartupError';
+    wrapped.code = CLAUDE_CODE_STARTUP_FAILED;
+    if (error !== undefined)
+        wrapped.cause = error;
+    return wrapped;
+}
 export var ErrorType;
 (function (ErrorType) {
     ErrorType["SDK_TIMEOUT"] = "sdk_timeout";
@@ -71,6 +88,7 @@ export var ErrorType;
     ErrorType["SESSION_UNAVAILABLE"] = "session_unavailable";
     ErrorType["SANDBOX_INITIALIZATION_FAILED"] = "sandbox_initialization_failed";
     ErrorType["CLAUDE_STARTUP_ARGUMENTS_TOO_LONG"] = "claude_startup_arguments_too_long";
+    ErrorType["CLAUDE_CODE_STARTUP_FAILED"] = "claude_code_startup_failed";
     ErrorType["UNKNOWN"] = "unknown";
 })(ErrorType || (ErrorType = {}));
 /**
@@ -329,6 +347,9 @@ export function classifyError(error) {
     if (isClaudeStartupArgumentsTooLong(error)) {
         return ErrorType.CLAUDE_STARTUP_ARGUMENTS_TOO_LONG;
     }
+    if (error?.code === CLAUDE_CODE_STARTUP_FAILED) {
+        return ErrorType.CLAUDE_CODE_STARTUP_FAILED;
+    }
     // 字典优先 — 命中则直接返回
     const rule = matchErrorRule(msg);
     if (rule) {
@@ -410,6 +431,10 @@ export function getErrorMessage(error, terminalReason, includeEmoji = true) {
         const prefix = includeEmoji ? '⚠️ ' : '';
         return `${prefix}当前 Claude 启动参数过长，任务未执行`;
     }
+    if (error?.code === CLAUDE_CODE_STARTUP_FAILED) {
+        const prefix = includeEmoji ? '❌ ' : '';
+        return `${prefix}Claude Code SDK 本地运行时启动失败（${CLAUDE_CODE_STARTUP_FAILED}），当前任务未执行。请重新安装并对齐 Claude Code SDK 与 Windows 原生组件版本，然后重启 EvolCore 后重试`;
+    }
     // terminalReason 提供更精确的错误提示（SDK 0.2.100+）
     if (terminalReason) {
         const prefix = includeEmoji ? '❌ ' : '';
@@ -433,6 +458,8 @@ export function getErrorMessage(error, terminalReason, includeEmoji = true) {
                 return `${warnPrefix}执行沙箱启动失败（sandbox_initialization_failed），当前操作未执行；请检查文件系统挂载规则及 user namespace/seccomp 配置`;
             case 'claude_startup_arguments_too_long':
                 return `${warnPrefix}当前 Claude 启动参数过长，任务未执行`;
+            case 'claude_code_startup_failed':
+                return `${prefix}Claude Code SDK 本地运行时启动失败（${CLAUDE_CODE_STARTUP_FAILED}），当前任务未执行。请重新安装并对齐 Claude Code SDK 与 Windows 原生组件版本，然后重启 EvolCore 后重试`;
             case 'aborted_streaming':
             case 'aborted_tools':
                 return `${prefix}任务已中断`;