evolcore 0.0.32 → 0.0.34

package/dist/trigger/authorization.js

@@ -8,6 +8,7 @@ import { validateModelSelectionForRole } from '../core/model/model-permission.js
 import { isValidAunDeliveryForChannel } from '../core/message/outbound.js';
 import { tryParseChannelKey } from '../core/channel-loader.js';
 import { constrainRuntimePermissionMode, validateRuntimeStringFieldOverride, } from '../core/role/runtime-policy.js';
+import { resolveThreadRouteTarget } from '../core/thread/thread-route.js';
 export function originFromActorSession(session, authenticatedPeerId, authenticatedChannelKey, authenticatedChatType) {
     const peerId = authenticatedPeerId || session.metadata?.peerId;
     if (!peerId)
@@ -15,16 +16,21 @@ export function originFromActorSession(session, authenticatedPeerId, authenticat
     const sessionChannelKey = session.metadata?.channelKey || session.channel;
     const channelKey = authenticatedChannelKey || sessionChannelKey;
     const sameConversation = channelKey === sessionChannelKey;
+    if (authenticatedChatType && (authenticatedChatType === 'group') !== (session.chatType === 'group')) {
+        return undefined;
+    }
     const isGroup = authenticatedChatType === 'group' || session.chatType === 'group';
+    const channelId = isGroup ? session.channelId : peerId;
+    const sessionKind = sameConversation && session.threadId ? 'thread' : 'main';
     return {
         channelKey,
         channelType: session.channelType || tryParseChannelKey(channelKey)?.type || channelKey,
-        channelId: peerId,
-        session: sameConversation && !isGroup && session.threadId ? 'thread' : 'main',
-        threadId: sameConversation && !isGroup ? (session.threadId || undefined) : undefined,
+        channelId,
+        session: sessionKind,
+        threadId: sessionKind === 'thread' ? session.threadId : undefined,
         peerId,
-        sessionKey: sameConversation && !isGroup ? session.sessionKey : undefined,
-        delivery: { chatType: 'private' },
+        sessionKey: sameConversation ? session.sessionKey : undefined,
+        delivery: isGroup ? { chatType: 'group', groupId: channelId } : { chatType: 'private' },
     };
 }
 export function daemonPrivilegedTriggerReason(definition) {
@@ -76,6 +82,36 @@ export function validateTriggerFeedbackChannels(definition, getTriggerChannel) {
 export function hasDaemonTriggerAuthority(subject) {
     return subject.isDaemonOwner || subject.processRole === 'daemon-service' || subject.dataScope === 'daemon';
 }
+function triggerOriginChatType(origin) {
+    return origin.delivery?.chatType ?? 'private';
+}
+function feedbackTargetMatchesOrigin(target, origin) {
+    return target.channelKey === origin.channelKey
+        && target.channelId === origin.channelId
+        && target.session === origin.session
+        && (target.threadId ?? '') === (origin.threadId ?? '')
+        && (target.chatType === undefined || target.chatType === triggerOriginChatType(origin));
+}
+function feedbackTargetIsSamePeerThread(definition, target, origin) {
+    if (!target || !origin || target.session !== 'thread' || !target.threadId)
+        return false;
+    if (target.channelKey !== origin.channelKey || target.channelId !== origin.channelId)
+        return false;
+    const originChatType = triggerOriginChatType(origin);
+    if (target.chatType !== originChatType)
+        return false;
+    return !!resolveThreadRouteTarget(definition.agentAid, target.threadId, target.chatType === 'group' ? 'group' : 'msg', target.channelId);
+}
+function feedbackTargetAllowedForNonManagement(definition, origin) {
+    const target = definition.feedback.target;
+    if (!target || !origin)
+        return false;
+    if (feedbackTargetMatchesOrigin(target, origin))
+        return true;
+    if (target.chatType === 'group')
+        return false;
+    return feedbackTargetIsSamePeerThread(definition, target, origin);
+}
 export function validateTriggerDefinitionForActor(definition, actor, dependencies) {
     if (definition.execution.permissionMode === 'fullaccess') {
         if (!actor.daemonOwner && !actor.fullAccess) {
@@ -127,14 +163,8 @@ export function validateTriggerDefinitionForActor(definition, actor, dependencie
         throw new Error('event-session feedback requires owner/admin');
     }
     if (!actor.management && definition.feedback.strategy === 'target') {
-        const target = definition.feedback.target;
-        const origin = actor.origin;
-        if (!target || !origin
-            || target.channelKey !== origin.channelKey
-            || target.channelId !== origin.channelId
-            || target.session !== origin.session
-            || (target.threadId ?? '') !== (origin.threadId ?? '')) {
-            throw new Error('non-management trigger target must be the creator private conversation');
+        if (!feedbackTargetAllowedForNonManagement(definition, actor.origin)) {
+            throw new Error('non-management trigger target must be the creator conversation or an existing same-peer private thread');
         }
     }
 }
@@ -187,13 +217,15 @@ export function authorizeTriggerExecution(definition, dependencies) {
     const channelType = origin.channelType || tryParseChannelKey(origin.channelKey)?.type;
     if (!channelType)
         return { allowed: false, reason: 'trigger origin channel type is missing' };
+    const chatType = triggerOriginChatType(origin);
+    const conversationId = chatType === 'group' ? origin.channelId : origin.peerId;
     const roleDetail = resolvePeerRoleDetail({
         selfAid: definition.agentAid,
         channelKey: origin.channelKey,
         channelType,
-        chatType: 'private',
+        chatType,
         actorId: origin.peerId,
-        conversationId: origin.peerId,
+        conversationId,
     });
     const role = roleDetail.effectiveRole;
     if (!checkRoleAccess(role, definition.agentAid)) {
@@ -205,8 +237,8 @@ export function authorizeTriggerExecution(definition, dependencies) {
         channel: origin.channelKey,
         channelType,
         channelId: origin.channelId,
-        chatType: 'private',
-        conversationId: origin.peerId,
+        chatType,
+        conversationId,
         roleDetail,
         identity: roleToSessionIdentity(role),
         processOwners: dependencies.getDaemonOwners(),
@@ -236,13 +268,8 @@ export function authorizeTriggerExecution(definition, dependencies) {
         return { allowed: false, reason: 'event-session feedback requires current owner/admin role' };
     }
     if (definition.feedback.strategy === 'target' && !isManagementRole(role)) {
-        const target = definition.feedback.target;
-        if (!target
-            || target.channelKey !== origin.channelKey
-            || target.channelId !== origin.channelId
-            || target.session !== origin.session
-            || (target.threadId ?? '') !== (origin.threadId ?? '')) {
-            return { allowed: false, reason: `cross-conversation target requires current owner/admin role (role=${role ?? 'none'})` };
+        if (!feedbackTargetAllowedForNonManagement(definition, origin)) {
+            return { allowed: false, reason: `cross-conversation target requires current owner/admin role or an existing same-peer private thread (role=${role ?? 'none'})` };
         }
     }
     const permissionDecision = constrainRuntimePermissionMode({
@@ -314,13 +341,15 @@ export async function authenticatedTriggerActor(dependencies, agentAid, actorSes
     if (validation.grant.actorId !== actorOrigin.peerId) {
         throw new Error('trigger delegation actor does not match session peer');
     }
+    const actorChatType = triggerOriginChatType(actorOrigin);
+    const actorConversationId = actorChatType === 'group' ? actorOrigin.channelId : actorOrigin.peerId;
     const roleDetail = resolvePeerRoleDetail({
         selfAid: agentAid,
         channelKey: validation.grant.channel,
         channelType: validation.grant.channelType,
-        chatType: 'private',
+        chatType: actorChatType,
         actorId: validation.grant.actorId,
-        conversationId: validation.grant.actorId,
+        conversationId: actorConversationId,
     });
     const currentRole = roleDetail.effectiveRole;
     const subject = buildAuthSubject({
@@ -329,8 +358,8 @@ export async function authenticatedTriggerActor(dependencies, agentAid, actorSes
         channel: validation.grant.channel,
         channelType: validation.grant.channelType,
         channelId: actorOrigin.channelId,
-        chatType: 'private',
-        conversationId: validation.grant.actorId,
+        chatType: actorChatType,
+        conversationId: actorConversationId,
         roleDetail,
         identity: roleToSessionIdentity(currentRole),
         processOwners: dependencies.getDaemonOwners(),

package/dist/trigger/feedback.js

@@ -272,10 +272,16 @@ export class TriggerFeedbackDispatcher {
                     originChannelKey: eventSession ? target.channelKey : input.trigger.origin?.channelKey,
                     originChannelType: eventSession ? channelType : input.trigger.origin?.channelType
                         ?? (input.trigger.origin?.channelKey ? channelTypeFromKey(input.trigger.origin.channelKey) : undefined),
-                    ...(eventSession ? { originChatType: messageChatType, originConversationId: target.channelId } : {}),
+                    originChatType: eventSession ? messageChatType : input.trigger.origin?.delivery?.chatType,
+                    originConversationId: eventSession
+                        ? target.channelId
+                        : input.trigger.origin?.delivery?.chatType === 'group'
+                            ? input.trigger.origin.channelId
+                            : input.trigger.origin?.peerId,
                     originControl: !eventSession && input.trigger.origin?.channelKey === 'daemon',
                     noopSentinel: input.trigger.execution.noopSentinel,
                     authorizedBy: input.trigger.authorizedBy,
+                    labels: input.trigger.labels,
                 },
             };
             outcome = this.waitForTriggerOutcome(input.runId, input.attemptId, delivery.signal);
@@ -297,7 +303,12 @@ export class TriggerFeedbackDispatcher {
                 });
                 await binding.adapter.send(envelope, { kind: 'status.error',
                     metadata: { errorType: 'orphaned_target_session', message: text } });
-                await binding.adapter.send(envelope, { kind: 'result.error', reason: 'orphaned_target_session', text });
+                await binding.adapter.send(envelope, {
+                    kind: 'result.error',
+                    subtype: 'session_unavailable',
+                    reason: 'orphaned_target_session',
+                    text,
+                });
             };
             const inspect = async () => {
                 if (!this.deps.inspectTargetExecution || disposed || delivery.signal.aborted)

package/dist/trigger/parser.js

@@ -11,7 +11,7 @@ const TRIGGER_UPDATE_FLAGS = new Set([
 ]);
 const TRIGGER_CREATE_FLAGS = new Set([
     'once', 'delay', 'at', 'cron', 'every', 'event', 'event-filter', 'tz',
-    'exec', 'prompt', 'name', 'agent',
+    'exec', 'prompt', 'name', 'description', 'agent', 'label',
     'script-path', 'script-runtime', 'script-args', 'script-timeout', 'execution-timeout',
     'feedback', 'target-channel', 'target-channel-id', 'target-chat-type', 'target-session', 'target-thread-id',
     'trigger-thread', 'baseagent',
@@ -68,6 +68,60 @@ export function parseDuration(s) {
     const multiplier = unit === 'd' ? 86_400_000 : unit === 'h' ? 3_600_000 : unit === 'm' ? 60_000 : 1_000;
     return amount * multiplier;
 }
+/**
+ * T10: 从原始 args 里提取 `--label key=value`（支持多次出现，值内可用逗号分隔多对）。
+ * 约定：labels 若存在则必须含 `kind`（渲染模板路由 key）。
+ */
+export function extractLabels(args) {
+    const tokens = [];
+    if (Array.isArray(args)) {
+        for (let i = 0; i < args.length; i++) {
+            const a = args[i];
+            if (a === '--label') {
+                const next = args[i + 1];
+                if (next === undefined || next.startsWith('--'))
+                    return { error: '--label 不能为空（格式：--label key=value）' };
+                tokens.push(next);
+                i += 1;
+            }
+            else if (a.startsWith('--label=')) {
+                tokens.push(a.slice('--label='.length));
+            }
+        }
+    }
+    else {
+        const re = /--label(?:=(\S+)|(?:\s+(?!--)(\S+)))?/g;
+        let m;
+        while ((m = re.exec(args)) !== null) {
+            const v = m[1] ?? m[2];
+            if (v === undefined)
+                return { error: '--label 不能为空（格式：--label key=value）' };
+            tokens.push(v.replace(/^["']|["']$/g, ''));
+        }
+    }
+    if (tokens.length === 0)
+        return { labels: {} };
+    const labels = {};
+    for (const token of tokens) {
+        for (const pair of token.split(',')) {
+            const trimmed = pair.trim();
+            if (!trimmed)
+                continue;
+            const eq = trimmed.indexOf('=');
+            if (eq <= 0)
+                return { error: `--label 格式无效: "${trimmed}"（应为 key=value）` };
+            const key = trimmed.slice(0, eq).trim();
+            const value = trimmed.slice(eq + 1);
+            if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+                return { error: `--label key 名无效: "${key}"（只允许字母、数字、下划线，且不以数字开头）` };
+            }
+            labels[key] = value;
+        }
+    }
+    if (!('kind' in labels))
+        return { error: '--label 必须包含 kind（如 --label kind=default）' };
+    return { labels };
+}
 export function parseIsoDate(s) {
     const d = new Date(s);
     return isNaN(d.getTime()) ? null : d.getTime();
@@ -390,6 +444,9 @@ function commonParsed(flags, opts = {}) {
             return { ok: false, error: '--script-args 必须是合法的 JSON' };
         }
     }
+    const description = optionalFlagString(flags, 'description');
+    if ('error' in description)
+        return { ok: false, error: description.error };
     const prompt = flags.get('prompt');
     if (prompt === true)
         return { ok: false, error: '--prompt 不能为空；复杂内容建议改用 --prompt-file <path>' };
@@ -471,6 +528,8 @@ function commonParsed(flags, opts = {}) {
             targetThreadId: targetThreadId,
             agentId: flags.has('agent') ? flags.get('agent') : undefined,
             name: flags.has('name') ? flags.get('name') : undefined,
+            // create 语义：空字符串等同于「未提供」，不写该字段（与 update 的清除语义不同）。
+            description: description.value || undefined,
             prompt: prompt,
             scriptPath: scriptPath,
             scriptRuntime: scriptRuntime,
@@ -496,6 +555,9 @@ export function parseTriggerSet(args) {
     if (!parsed.ok)
         return { ok: false, error: withPromptFileHint(parsed.error, args) };
     const value = parsed.value;
+    const labelsResult = extractLabels(args);
+    if ('error' in labelsResult)
+        return { ok: false, error: labelsResult.error };
     return {
         ok: true,
         value: {
@@ -512,6 +574,7 @@ export function parseTriggerSet(args) {
             targetThreadId: value.targetThreadId,
             agentId: value.agentId,
             name: value.name,
+            description: value.description,
             prompt: value.prompt,
             scriptPath: value.scriptPath,
             scriptRuntime: value.scriptRuntime,
@@ -525,6 +588,7 @@ export function parseTriggerSet(args) {
             model: value.model,
             effort: value.effort,
             permissionMode: value.permissionMode,
+            ...(Object.keys(labelsResult.labels).length > 0 ? { labels: labelsResult.labels } : {}),
         },
     };
 }
@@ -538,6 +602,9 @@ export function parseTriggerSetArgv(args, opts = {}) {
     if (!parsed.ok)
         return { ok: false, error: withPromptFileHint(parsed.error, args, opts) };
     const value = parsed.value;
+    const labelsResult = extractLabels(args);
+    if ('error' in labelsResult)
+        return { ok: false, error: labelsResult.error };
     return {
         ok: true,
         value: {
@@ -554,6 +621,7 @@ export function parseTriggerSetArgv(args, opts = {}) {
             targetThreadId: value.targetThreadId,
             agentId: value.agentId,
             name: value.name,
+            description: value.description,
             prompt: value.prompt,
             scriptPath: value.scriptPath,
             scriptRuntime: value.scriptRuntime,
@@ -567,6 +635,7 @@ export function parseTriggerSetArgv(args, opts = {}) {
             model: value.model,
             effort: value.effort,
             permissionMode: value.permissionMode,
+            ...(Object.keys(labelsResult.labels).length > 0 ? { labels: labelsResult.labels } : {}),
         },
     };
 }

package/dist/trigger/system-definitions.js

@@ -121,7 +121,7 @@ export function seedTaskRecoveryTrigger(manager, owner) {
     fs.rmSync(manager.activePath(definition.id), { force: true });
 }
 const SESSION_IDLE_CHECK_PROMPT = `本会话已闲置一段时间。请依据你的职责执行一次例行巡检：
-1. 判断群内是否存在成员有未完成的工作却停滞（如长时间无进展、被点名未回应、承诺后失联）。有，则向该成员催促一次并说明停滞事项，随后即止；无，则不做任何动作。大家都在正常工作或无待办时保持沉默。
+1. 检查当前会话中未完成却停滞的事项。私聊检查自己承诺或正在推进的任务；群聊还需检查成员长时间无进展、被点名未回应、承诺后失联等情况。有，则在既有授权和职责内推进一次，或向相关成员催促一次并说明停滞事项，随后即止；无，则不做任何动作。不要自行新增任务，正常推进或无待办时保持沉默。
 2. 巡检优先基于已有上下文判断，确需补充背景再查询历史，并遵守会话自身的发送规范。
 3. 判定无需任何对外动作时，本轮只输出 [[NOOP]]，不发送任何消息、不发布巡检结论。注意：最终对外输出必须是且仅是 [[NOOP]] 这一行——不要在输出它之前先发送任何说明文字或巡检判定，判定过程仅在内部完成。
 （本指令为通用模板，可按具体职责增删检查项。）`;
@@ -133,7 +133,7 @@ export function seedSessionIdleCheckTrigger(manager, owner) {
         agentAid: owner.aid,
         enabled: true,
         name: '__session-idle-check',
-        description: 'System trigger: inspect configured idle group sessions.',
+        description: 'System trigger: inspect configured idle private and group sessions.',
         createdAt: now,
         updatedAt: now,
         origin: {
@@ -147,7 +147,7 @@ export function seedSessionIdleCheckTrigger(manager, owner) {
         source: {
             type: 'event',
             eventPattern: 'session:idle',
-            filter: { match: { chatType: 'group' } },
+            filter: { match: { chatType: { $in: ['private', 'group'] } } },
         },
         execution: {
             type: 'target_session',

package/dist/trigger/validation.js

@@ -252,6 +252,20 @@ function normalizeV3Phase2(raw, opts) {
         reliability: normalizeReliability(raw.reliability),
         limits: normalizeLimits(raw.limits),
     };
+    // T10: labels 字典原样保留，只做类型校验（如果存在必须是 Record<string, string>）
+    const rawLabels = raw.labels;
+    if (rawLabels !== undefined && rawLabels !== null) {
+        if (typeof rawLabels !== 'object' || Array.isArray(rawLabels)) {
+            throw new Error('labels must be a plain object');
+        }
+        const labels = {};
+        for (const [k, v] of Object.entries(rawLabels)) {
+            if (typeof v !== 'string')
+                throw new Error(`labels.${k} must be a string`);
+            labels[k] = v;
+        }
+        definition.labels = labels;
+    }
     validateTriggerSemantics(definition);
     return definition;
 }

package/dist/utils/cross-platform.js

@@ -666,6 +666,13 @@ export async function waitForProcessExit(pid, timeoutMs = 10_000, intervalMs = 2
  * Returns list of matching PIDs.
  */
 export function findProcesses(pattern) {
+    return findProcessesWithCommandLine(pattern).map(match => match.pid);
+}
+/**
+ * Like findProcesses, but keeps the command line returned by the Windows CIM
+ * snapshot so callers do not need a second PowerShell launch per candidate.
+ */
+export function findProcessesWithCommandLine(pattern) {
     try {
         if (isWindows) {
             // WMI LIKE is wildcard matching, not JavaScript regex matching. Query a
@@ -696,13 +703,15 @@ export function findProcesses(pattern) {
                     const normalized = commandLine.replace(/\\/g, '/');
                     return matcherCandidates.some(matcher => matcher.test(commandLine) || matcher.test(normalized));
                 })
-                    .map(row => row.ProcessId);
+                    .map(row => ({ pid: row.ProcessId, commandLine: row.CommandLine || '' }));
             }
             return [];
         }
         else {
             const output = execFileSync('pgrep', ['-f', pattern], { encoding: 'utf-8' }).trim();
-            return output ? output.split('\n').map(Number).filter(pid => pid !== process.pid) : [];
+            return output
+                ? output.split('\n').map(Number).filter(pid => pid !== process.pid).map(pid => ({ pid }))
+                : [];
         }
     }
     catch {

package/dist/utils/error-dict.json

@@ -85,11 +85,25 @@
       "message": "❌ 当前模型不受支持，请正确配置模型后重试"
     },
     {
-      "id": "api-error-403",
-      "match": "api error: 403",
-      "action": "retry",
+      "id": "claude-client-upgrade-403-cn",
+      "match": "api error: 403 请升级claude code 客户端到最新版",
+      "action": "stop",
+      "type": "api_error",
+      "message": "⚠️ Claude Code 客户端版本过旧，请升级到最新版后重试"
+    },
+    {
+      "id": "insufficient-credit-403-cn",
+      "match": "api error: 403 预扣后为-",
+      "action": "stop",
       "type": "api_error",
-      "message": "⚠️ API 访问受限，请稍后重试"
+      "message": "⚠️ 积分余额不足，请充值积分或升级套餐后重试"
+    },
+    {
+      "id": "team-context-limit-403-cn",
+      "match": "api error: 403 请求上下文约",
+      "action": "stop",
+      "type": "context_too_long",
+      "message": "⚠️ 请求已超过团队上下文上限，请使用 /compact 压缩上下文后重试，或联系管理员调整上下文配额"
     },
     {
       "id": "api-error-429",

package/dist/utils/error-utils.js

@@ -91,6 +91,117 @@ export var ErrorType;
     ErrorType["CLAUDE_CODE_STARTUP_FAILED"] = "claude_code_startup_failed";
     ErrorType["UNKNOWN"] = "unknown";
 })(ErrorType || (ErrorType = {}));
+export function getErrorRawText(error, seen = new Set()) {
+    if (typeof error === 'string') {
+        const text = error.trim();
+        return text || undefined;
+    }
+    if (error === null || error === undefined)
+        return undefined;
+    if (typeof error === 'object') {
+        const record = error;
+        if (seen.has(error))
+            return undefined;
+        seen.add(error);
+        if ('raw' in record) {
+            const raw = record.raw;
+            if (typeof raw === 'string' && raw.trim())
+                return raw.trim();
+        }
+        const causeText = getErrorRawText(record.cause, seen);
+        if (causeText)
+            return causeText;
+        for (const key of ['message', 'error', 'reason']) {
+            const value = record[key];
+            if (typeof value === 'string' && value.trim())
+                return value.trim();
+            if (value && typeof value === 'object') {
+                const nestedText = getErrorRawText(value, seen);
+                if (nestedText)
+                    return nestedText;
+            }
+        }
+        const code = record.code;
+        if (typeof code === 'string' && code.trim())
+            return code.trim();
+        return undefined;
+    }
+    const text = String(error).trim();
+    return text || undefined;
+}
+export function normalizeCoreErrorSubtype(error, reportedSubtype, terminalReason) {
+    const reported = reportedSubtype?.trim().toLowerCase();
+    if (error instanceof OrphanedTargetSessionError)
+        return ErrorType.SESSION_UNAVAILABLE;
+    if (error instanceof ExecutionTimeoutError)
+        return ErrorType.SDK_TIMEOUT;
+    if (terminalReason === 'prompt_too_long' || terminalReason === 'context_compact_failed') {
+        return ErrorType.CONTEXT_TOO_LONG;
+    }
+    if (terminalReason === 'max_output_tokens')
+        return ErrorType.MAX_OUTPUT_TOKENS;
+    if (terminalReason === 'model_error')
+        return ErrorType.MODEL_UNAVAILABLE;
+    if (terminalReason === 'permission_denied')
+        return 'permission_error';
+    if (terminalReason === 'timeout' || terminalReason === 'total_execution_timeout')
+        return ErrorType.SDK_TIMEOUT;
+    if (reported === 'protocol_incomplete')
+        return 'protocol_incomplete';
+    if (reported === 'permission_denied' || reported?.startsWith('permission_'))
+        return 'permission_error';
+    const classified = classifyError(typeof error === 'string' ? new Error(error) : error);
+    if (classified !== ErrorType.UNKNOWN)
+        return classified;
+    if (reported && Object.values(ErrorType).includes(reported))
+        return reported;
+    switch (reported) {
+        case 'error_api':
+        case 'api':
+        case 'infrastructure':
+            return ErrorType.API_ERROR;
+        case 'error_model':
+        case 'model_error':
+            return ErrorType.MODEL_UNAVAILABLE;
+        case 'error_tool_use':
+        case 'tool_error':
+            return ErrorType.STREAM_ERROR;
+    }
+    if (terminalReason === 'rapid_refill_breaker')
+        return ErrorType.API_ERROR;
+    if (terminalReason === 'tool_error')
+        return ErrorType.STREAM_ERROR;
+    if (reported)
+        return reported;
+    return ErrorType.UNKNOWN;
+}
+export function normalizeCoreErrorReason(reason) {
+    const normalized = reason?.trim().toLowerCase();
+    switch (normalized) {
+        case 'retry.exhausted':
+            return 'retry_exhausted';
+        case 'sdk_timeout':
+        case 'total_execution_timeout':
+            return 'timeout';
+        case 'aborted_streaming':
+        case 'aborted_tools':
+        case 'stop':
+            return 'cancelled';
+        case 'protocol_incomplete':
+        case 'max_output_tokens':
+        case 'target_session_timeout':
+        case 'retry_exhausted':
+        case 'timeout':
+        case 'cancelled':
+        case 'permission_denied':
+        case 'input_already_submitted':
+        case 'fallback_exhausted':
+        case 'orphaned_target_session':
+            return normalized;
+        default:
+            return undefined;
+    }
+}
 /**
  * 错误来源前缀 — 区分基础设施异常 vs Agent 任务失败
  *
@@ -466,7 +577,7 @@ export function getErrorMessage(error, terminalReason, includeEmoji = true) {
         }
     }
     // 回退到原有的错误消息匹配逻辑
-    const msg = error?.message || String(error);
+    const msg = resolveErrorMessage(error);
     const warnPrefix = includeEmoji ? '⚠️ ' : '';
     const errPrefix = includeEmoji ? '❌ ' : '';
     if (/invalid (?:jsonl )?session file/i.test(msg)) {
@@ -512,5 +623,36 @@ export function getErrorMessage(error, terminalReason, includeEmoji = true) {
     if (msg.includes('timeout')) {
         return `${warnPrefix}请求超时，请重试`;
     }
+    if (msg)
+        return `${errPrefix}暂无法判定错误原因：${msg}`;
     return `${errPrefix}处理消息时出错，请稍后重试`;
 }
+export function getToolResultErrorText(event) {
+    const text = event.error || event.reason
+        || (event.name === 'Shell'
+            ? typeof event.exitCode === 'number' && Number.isInteger(event.exitCode)
+                ? 'exitCode: ' + event.exitCode
+                : '执行失败'
+            : typeof event.result === 'string' ? event.result : JSON.stringify(event.result))
+        || '执行失败';
+    return text.replace(/<tool_use_error>(.*?)<\/tool_use_error>/gs, '$1');
+}
+function resolveErrorMessage(error) {
+    if (typeof error === 'string')
+        return error.trim();
+    if (error === null || error === undefined)
+        return '';
+    if (typeof error === 'object') {
+        const message = 'message' in error ? String(error.message ?? '').trim() : '';
+        if (message)
+            return message;
+        const code = 'code' in error ? String(error.code ?? '').trim() : '';
+        if (code)
+            return code;
+        if ('message' in error)
+            return '';
+        const stringified = String(error).trim();
+        return stringified === '[object Object]' || stringified === 'Error' ? '' : stringified;
+    }
+    return String(error).trim();
+}

package/dist/utils/instance-registry.js

@@ -11,8 +11,8 @@
 import fs from 'fs';
 import path from 'path';
 import { spawnSync } from 'child_process';
-import { getPackageRoot, resolvePaths } from '../paths.js';
-import { isProcessRunning, killProcess, isWindows, findProcesses } from './cross-platform.js';
+import { getPackageRoot, resolvePaths, isDevMode } from '../paths.js';
+import { isProcessRunning, killProcess, isWindows, findProcessesWithCommandLine } from './cross-platform.js';
 import { getProcessStartTime, startTimeMatches } from './process-introspect.js';
 import { isConfirmedLeakedTestDaemon, runtimeHomeFromEnv } from './restart-safety.js';
 import { decodeWindowsOutput } from './windows-output.js';
@@ -55,6 +55,7 @@ export function writeMain(launchedBy) {
         startedAt,
         startedAtIso: new Date(startedAt).toISOString(),
         launchedBy,
+        runMode: isDevMode() ? 'dev' : 'install',
     };
     const filePath = path.join(dir, mainFileName(process.pid));
     writeAtomic(filePath, JSON.stringify(record, null, 2));
@@ -376,10 +377,10 @@ export function isEvolCoreMainCommand(cmdline, packageRoot = getPackageRoot()) {
  *
  * 不会主动 kill——清理由调用方决定。
  */
-export function findOrphanProcesses() {
-    // 1. 已登记 PID（自己 HOME 下的 main + 自己进程）
+export function findOrphanProcesses(status = scanInstances()) {
+    // 1. 已登记 PID（自己 HOME 下的 main + 自己进程）。调用方刚扫过登记簿时可直接传入，
+    //    Windows 上每次 scanInstances 都要为活实例跑一遍 CIM 查询。
     const known = new Set([process.pid]);
-    const status = scanInstances();
     for (const m of status.mains) {
         if (m.alive)
             known.add(m.record.pid);
@@ -393,14 +394,18 @@ export function findOrphanProcesses() {
     // regex contains escaped separators and is applied after command lines have
     // been fetched; embedding it in the CIM pre-filter can silently miss a
     // backslash-delimited `dist\\index.js` command on some PowerShell builds.
-    const candidates = findProcesses('index\\.js');
+    // `index.js` 会命中所有 Node 服务（各会话拉起的 MCP server 常有十几个），
+    // 所以先用快照里的命令行过滤，只对真正的 EvolCore 入口做后续探测。
+    const candidates = findProcessesWithCommandLine('index\\.js');
     const orphans = [];
-    for (const pid of candidates) {
+    for (const { pid, commandLine } of candidates) {
         if (known.has(pid))
             continue;
+        if (commandLine !== undefined && !isEvolCoreMainCommand(commandLine))
+            continue;
         if (!isProcessRunning(pid))
             continue;
-        const cmdline = readCmdline(pid);
+        const cmdline = commandLine || readCmdline(pid);
         // 二次验证：入口必须是当前 EvolCore 包的 dist/index.js。
         if (!isEvolCoreMainCommand(cmdline))
             continue;