evolcore 0.0.33 → 0.0.35-test.0

package/dist/ipc.js

@@ -23,6 +23,7 @@ import { remoteAccessService } from './core/auth/remote-access-store.js';
 import { setModelCatalogDaemonOwner } from './core/model/model-catalog.js';
 import { RUNTIME_ENVIRONMENT_NAMES, setRuntimeEnvironmentOverride } from './config/runtime-env.js';
 import { MAIN_CLI_BIN } from './product.js';
+import { delegationDiagnosticMessage, withDelegationDiagnosticContext, } from './core/auth/delegation-diagnostics.js';
 const isWindows = process.platform === 'win32';
 const isNamedPipe = (p) => isWindows && p.toLowerCase().startsWith('\\\\.\\pipe\\');
 const CPU_SAMPLE_INTERVAL_MS = 1000;
@@ -79,7 +80,7 @@ const LOCAL_CONTROL_COMMANDS = new Set([
 ]);
 const MEMORY_COMMAND_ENDPOINTS = new Set([
     'memory.note', 'memory.note.update', 'memory.note.drop', 'memory.note.list',
-    'memory.create', 'memory.update', 'memory.archive', 'memory.demote', 'memory.consolidate', 'memory.feedback',
+    'memory.create', 'memory.update', 'memory.archive', 'memory.demote', 'memory.consolidate',
 ]);
 const DELEGATED_ARGV_ENDPOINTS = new Set([
     'agent.op', 'config.op', 'contact.op', 'aid.op', 'group.op', 'msg.op', 'fs.op',
@@ -194,6 +195,7 @@ export class IpcServer {
     debugTaskRuntimeContextProvider;
     debugIssueTokenExecutor;
     taskRuntimeContextAuthorizer;
+    systemSessionCommandGate;
     codexPreToolUseExecutor;
     aunMsgSender;
     diagExecutor;
@@ -218,6 +220,7 @@ export class IpcServer {
     wechatContactBindExecutor;
     controlToken;
     daemonRuntimeEpoch;
+    delegationFailureRecorder;
     remoteAccessService = remoteAccessService;
     /** Current daemon owner used to bind locally issued ECWeb pairing codes. */
     remoteAccessOwnerProvider;
@@ -288,6 +291,9 @@ export class IpcServer {
     setDaemonRuntimeEpoch(epoch) {
         this.daemonRuntimeEpoch = epoch;
     }
+    setDelegationFailureRecorder(recorder) {
+        this.delegationFailureRecorder = recorder;
+    }
     /** Inject menu.* executor (ECWeb Control proxies menu requests through this) */
     setMenuExecutor(executor) {
         this.menuExecutor = executor;
@@ -492,6 +498,9 @@ export class IpcServer {
     setTaskRuntimeContextAuthorizer(authorizer) {
         this.taskRuntimeContextAuthorizer = authorizer;
     }
+    setSystemSessionCommandGate(gate) {
+        this.systemSessionCommandGate = gate;
+    }
     setCodexPreToolUseExecutor(executor) {
         this.codexPreToolUseExecutor = executor;
     }
@@ -951,6 +960,27 @@ export class IpcServer {
         }
     }
     async handleCommand(cmd, requestSignal, receivedAtMono = performance.now()) {
+        return withDelegationDiagnosticContext({
+            sessionId: typeof cmd.sessionId === 'string' ? cmd.sessionId : undefined,
+            requestId: nextIpcQueryId(cmd),
+            correlationId: typeof cmd.correlationId === 'string' ? ipcLogToken(cmd.correlationId) : undefined,
+            operation: ipcLogToken(cmd.type),
+        }, () => this.dispatchCommand(cmd, requestSignal, receivedAtMono));
+    }
+    diagnosticRejection(cause, cmd) {
+        const failure = this.delegationFailureRecorder?.(cause, typeof (cmd.sessionId ?? cmd.originSessionId ?? cmd.actorSessionId) === 'string'
+            ? cmd.sessionId ?? cmd.originSessionId ?? cmd.actorSessionId : undefined, typeof cmd.delegationToken === 'string' ? cmd.delegationToken : undefined, typeof cmd.delegationCommandHash === 'string' ? cmd.delegationCommandHash : undefined);
+        const diagnosticCause = failure?.diagnosticCause ?? cause;
+        return {
+            ok: false,
+            code: diagnosticCause === 'missing_token' ? 'DELEGATION_REQUIRED'
+                : diagnosticCause === 'daemon_restarted' ? 'DAEMON_RESTARTED' : 'INVALID_DELEGATION',
+            error: failure?.reason ?? delegationDiagnosticMessage(diagnosticCause),
+            diagnosticCause,
+            ...(failure?.diagnosticEventId ? { diagnosticEventId: failure.diagnosticEventId } : {}),
+        };
+    }
+    async dispatchCommand(cmd, requestSignal, receivedAtMono = performance.now()) {
         if (requiresLocalControlToken(cmd) && !this.hasValidControlToken(cmd.controlToken)) {
             return { ok: false, code: 'INVALID_CONTROL_TOKEN', error: 'valid local control token is required' };
         }
@@ -959,11 +989,7 @@ export class IpcServer {
             && cmd.daemonRuntimeEpoch !== undefined
             && cmd.daemonRuntimeEpoch !== this.daemonRuntimeEpoch) {
             logger.warn(`[IPC] stale delegation rejected: session=${ipcLogToken(cmd.sessionId ?? cmd.originSessionId ?? cmd.actorSessionId)} type=${ipcLogToken(cmd.type)} cause=daemon_runtime_epoch_mismatch`);
-            return {
-                ok: false,
-                code: 'DAEMON_RESTARTED',
-                error: 'The task delegation token belongs to a previous daemon runtime; start a new task authorization and do not retry this command in the current task',
-            };
+            return this.diagnosticRejection('daemon_restarted', cmd);
         }
         if (typeof cmd.delegationToken === 'string'
             && (DELEGATED_ARGV_ENDPOINTS.has(cmd.type) || (cmd.type === 'aun-msg-send' && cmd.argv !== undefined))) {
@@ -976,9 +1002,26 @@ export class IpcServer {
                 ...cmd.argv,
             ]);
             if (!expectedHash || cmd.delegationCommandHash !== expectedHash) {
-                return { ok: false, code: 'INVALID_DELEGATION', error: 'Command hash does not match the submitted argv' };
+                return this.diagnosticRejection('command_hash_mismatch', cmd);
             }
         }
+        // 系统会话统一闸门：带系统会话 delegation 的请求只看模块 checkCommand，拒绝即返回
+        if (this.systemSessionCommandGate
+            && typeof cmd.delegationToken === 'string' && cmd.delegationToken
+            && typeof cmd.sessionId === 'string' && cmd.sessionId) {
+            const argv = Array.isArray(cmd.argv) && cmd.argv.every((value) => typeof value === 'string')
+                ? cmd.argv
+                : undefined;
+            const gate = await this.systemSessionCommandGate({
+                sessionId: cmd.sessionId,
+                delegationToken: cmd.delegationToken,
+                ...(typeof cmd.delegationCommandHash === 'string' ? { delegationCommandHash: cmd.delegationCommandHash } : {}),
+                type: cmd.type,
+                ...(argv ? { argv } : {}),
+            });
+            if (gate && !gate.allow)
+                return { ok: false, code: 'NOT_ALLOWED', policyCode: gate.code, error: gate.reason };
+        }
         if (cmd.argv !== undefined && ['handoff-status', 'handoff-list', 'handoff-trace'].includes(cmd.type)) {
             try {
                 const { parseList, parseTrace } = await import('./cli/handoff-command.js');
@@ -1911,37 +1954,6 @@ export class IpcServer {
                     return { ok: false, error: e?.message || String(e) };
                 }
             }
-            case 'memory.feedback': {
-                const { sessionId, text } = cmd;
-                if (!sessionId)
-                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing sessionId' };
-                if (typeof text !== 'string' || !text.trim()) {
-                    return { ok: false, code: 'INVALID_REQUEST', error: 'missing feedback text' };
-                }
-                try {
-                    const taskCtx = await this.resolveMemoryTaskCtx(sessionId, cmd.debug === true);
-                    if (!taskCtx)
-                        return { ok: false, code: 'SESSION_NOT_FOUND', error: `未找到会话 ${sessionId} 的运行时上下文` };
-                    // 只有整理会话可以记录反馈
-                    if (taskCtx.sessionType !== 'memory') {
-                        return { ok: false, code: 'NOT_MEMORY_SESSION', error: '`ec memory feedback` 只能在整理会话内调用' };
-                    }
-                    const batchDir = taskCtx.consolidationBatchDir;
-                    if (!batchDir) {
-                        return { ok: false, code: 'BATCH_DIR_NOT_FOUND', error: '整理会话缺少 consolidationBatchDir' };
-                    }
-                    const { appendOpsRecord } = await import('./core/memory/consolidation-ops-records.js');
-                    appendOpsRecord(batchDir, {
-                        ts: new Date().toISOString(),
-                        op: 'feedback-set',
-                        text,
-                    });
-                    return { ok: true };
-                }
-                catch (e) {
-                    return { ok: false, error: e?.message || String(e) };
-                }
-            }
             case 'config.op': {
                 if (!this.configOperationExecutor)
                     return { ok: false, code: 'NOT_CONFIGURED', error: 'config.op not configured' };
@@ -2422,8 +2434,7 @@ export class IpcServer {
             const { rebuildIndex } = await import('./core/memory/index-manager.js');
             const mc = this.agentRegistry?.get(taskCtx.selfAid ?? '')?.config?.memory;
             const maxBytes = mc?.indexMaxBytes ?? 5 * 1024;
-            const buildResult = await rebuildIndex(dirs.consolidatedDir, path.join(dirs.memoryDir, 'MEMORY.md'), scope, path.join(dirs.memoryDir, 'archive', 'invalid'), undefined, // 验签门控尚未开启，不传 verifyFn
-            maxBytes);
+            const buildResult = await rebuildIndex(dirs.consolidatedDir, path.join(dirs.memoryDir, 'MEMORY.md'), scope, maxBytes);
             // 索引重建后顺手检查这一层有没有超期记忆 —— 有则建触发器拉一个独立的遗忘会话。
             await this.maybeTriggerForget(taskCtx, scope, dirs.consolidatedDir, mc, buildResult.verifiedFiles);
         }

package/dist/paths.js

@@ -442,3 +442,73 @@ export function getPackageRoot() {
     // the correct OS-native path, regardless of Git Bash or MSYS2 environment.
     return path.resolve(import.meta.dirname, '..');
 }
+// ── FileIntegrityStore 路径 ──
+export function integrityDir() {
+    return path.join(resolveRoot(), 'data', 'integrity');
+}
+export function integrityDbPath() {
+    return path.join(integrityDir(), 'file-integrity.db');
+}
+export function integritySnapshotDir() {
+    return path.join(integrityDir(), 'snapshots');
+}
+/**
+ * 判断当前是否为开发仓运行模式。
+ * 与 ec start 显示的安装类型保持口径一致：包路径包含 node_modules 则为安装模式，否则为开发仓。
+ * 调用方据此决定是否跳过 FileIntegrityStore 的 verify 调用。
+ *
+ * 唯一覆盖来源是 `ec start --as-mode` 写下的一次性文件（见 asModeOverridePath），
+ * 由 daemon 启动时读取并立即删除。**不读环境变量**——环境变量会被 restart 之类的
+ * 路径静默继承，导致模式在操作者不知情的情况下改变。
+ */
+export function isDevMode() {
+    if (!_asModeResolved) {
+        _asModeResolved = true;
+        _asModeOverride = consumeAsModeOverride();
+    }
+    if (_asModeOverride)
+        return _asModeOverride === 'dev';
+    return !getPackageRoot().includes('node_modules');
+}
+/**
+ * `ec start --as-mode <mode>` 的一次性覆盖文件。
+ *
+ * 走文件而不是环境变量：环境变量会被 `ec restart`（全量继承 process.env）
+ * 静默带进新 daemon，操作者不重启终端就撤不掉。文件由 CLI 在启动前写入，
+ * daemon 首次调用 isDevMode() 时读走并删除，只影响这一次启动。
+ */
+export function asModeOverridePath() {
+    return path.join(resolveRoot(), 'data', 'daemon', 'as-mode.override');
+}
+/**
+ * 本次进程的覆盖值。**必须缓存**：文件读一次就删，若每次都去读，
+ * 第二次调用起就会悄悄退回按包路径判断——模式在进程运行中途改变是最坏的情况。
+ */
+let _asModeResolved = false;
+let _asModeOverride = null;
+/** 仅供测试：清掉缓存，让下一次 isDevMode() 重新读覆盖文件。 */
+export function _resetAsModeCache() {
+    _asModeResolved = false;
+    _asModeOverride = null;
+}
+/**
+ * 读出并删除覆盖文件（一次性）。返回 null 表示没有覆盖。
+ * 只应由 daemon 启动流程（或 isDevMode 的首次求值）调用一次。
+ */
+export function consumeAsModeOverride() {
+    const file = asModeOverridePath();
+    if (!fs.existsSync(file))
+        return null;
+    let value = null;
+    try {
+        value = fs.readFileSync(file, 'utf-8').trim();
+    }
+    catch {
+        value = null;
+    }
+    try {
+        fs.rmSync(file, { force: true });
+    }
+    catch { /* ignore */ }
+    return value === 'dev' || value === 'install' ? value : null;
+}

package/dist/stats/billing.js

@@ -180,24 +180,36 @@ function loadSpecs(evolcoreHome) {
     _specCacheTs = now;
     return _specCache;
 }
-/** 取模型在 ts 时刻的能力参数。找不到时返回默认值。
- *  带窗口后缀的 ID 复用基础模型的参数行，但窗口由后缀决定（网关的权威声明）。 */
-export function resolveModelSpec(evolcoreHome, model, ts) {
+export function findModelSpec(evolcoreHome, model, ts = Date.now()) {
     const specs = loadSpecs(evolcoreHome);
-    const t = ts ?? Date.now();
     const suffixWindow = parseModelId(model).contextWindow;
     for (const key of modelLookupKeys(evolcoreHome, model)) {
-        const candidates = specs.filter(s => s.model === key && s.effective_from <= t);
+        const candidates = specs.filter(spec => spec.model === key && spec.effective_from <= ts);
         if (!candidates.length)
             continue;
-        const row = candidates.reduce((a, b) => a.effective_from >= b.effective_from ? a : b);
+        const row = candidates.reduce((a, b) => a.effective_from > b.effective_from ? a : b);
         if (suffixWindow === undefined || suffixWindow === row.context_window)
             return row;
         // 后缀声明的窗口覆盖基础行，输入上限按原行的预留比例等比缩放。
         const ratio = row.context_window > 0 ? row.max_input_tokens / row.context_window : 0.9;
         return { ...row, model, context_window: suffixWindow, max_input_tokens: Math.floor(suffixWindow * ratio) };
     }
+    return undefined;
+}
+/** 取模型在 ts 时刻的能力参数。找不到时返回 fallback 或默认值。
+ *  带窗口后缀的 ID 复用基础模型的参数行，但窗口由后缀决定（网关的权威声明）。 */
+export function resolveModelSpec(evolcoreHome, model, ts, fallback) {
+    const spec = findModelSpec(evolcoreHome, model, ts);
+    if (spec)
+        return spec;
+    const suffixWindow = parseModelId(model).contextWindow;
     // 默认值
-    const contextWindow = suffixWindow ?? 200000;
-    return { model, effective_from: 0, context_window: contextWindow, max_input_tokens: Math.floor(contextWindow * 0.9), max_output_tokens: 8192 };
+    const contextWindow = suffixWindow ?? fallback?.context_window ?? 200000;
+    return {
+        model,
+        effective_from: 0,
+        context_window: contextWindow,
+        max_input_tokens: Math.floor(contextWindow * 0.9),
+        max_output_tokens: fallback?.max_output_tokens ?? 8192,
+    };
 }

package/dist/trigger/feedback.js

@@ -303,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', 'label',
+    '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',
@@ -444,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>' };
@@ -525,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,
@@ -569,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,
@@ -615,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,

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/utils/cross-platform.js

@@ -344,9 +344,9 @@ export async function launchMonitorAndConfirm(args, env, isAliveInRegistry, hasO
  * in a checkout: `npm install -g` swaps the whole package directory, and the
  * monitor has ~170 lazy `await import()` sites, so a module it has not loaded
  * yet would come from the new version while the rest is still the old one.
- * Staging `dist/` elsewhere keeps its module graph on one consistent version.
+ * Staging `dist/` and `bin/` keeps the package-owned code on one version.
  *
- * Only `dist/` and `package.json` are copied (a few MB). `node_modules` is
+ * Only `dist/`, `bin/` and `package.json` are copied (a few MB). `node_modules` is
  * linked, because copying it is hundreds of MB. The link degrades in steps so
  * that no platform is left without a path forward:
  *
@@ -379,6 +379,9 @@ export function prepareMonitorStage(packageRoot, stageParent) {
     try {
         fs.mkdirSync(stageDir, { recursive: true });
         fs.cpSync(distSource, path.join(stageDir, 'dist'), { recursive: true });
+        const binSource = path.join(packageRoot, 'bin');
+        if (fs.existsSync(binSource))
+            fs.cpSync(binSource, path.join(stageDir, 'bin'), { recursive: true });
         const pkgJson = path.join(packageRoot, 'package.json');
         if (fs.existsSync(pkgJson))
             fs.copyFileSync(pkgJson, path.join(stageDir, 'package.json'));
@@ -388,7 +391,7 @@ export function prepareMonitorStage(packageRoot, stageParent) {
             fs.rmSync(stageDir, { recursive: true, force: true });
         }
         catch { }
-        return { stageDir: null, linkMode: 'none', note: `复制 dist/ 失败：${error.message}` };
+        return { stageDir: null, linkMode: 'none', note: `复制 monitor 运行文件失败：${error.message}` };
     }
     if (!fs.existsSync(modulesSource)) {
         // Dependencies hoisted elsewhere; nothing to link, node resolves upward.
@@ -666,6 +669,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 +706,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 任务失败
  *
@@ -516,6 +627,16 @@ export function getErrorMessage(error, terminalReason, includeEmoji = true) {
         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();

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;