evolcore 0.0.33 → 0.0.34

package/dist/eck/manifest-engine.js

@@ -3,9 +3,10 @@
 // when 求值、模板渲染、路径解析、manifest 加载/缓存原语，避免两套实现漂移。
 import fs from 'fs';
 import path from 'path';
-import { kitsDir, resolveRoot, getPackageRoot } from '../paths.js';
+import { kitsDir, resolveRoot, getPackageRoot, isDevMode } from '../paths.js';
 import { logger } from '../utils/logger.js';
 import { fileCache } from '../core/daemon-file-cache.js';
+import { readVerifiedText, isShippedPath } from '../core/file-integrity/read.js';
 // ── 限额默认值 ──
 /** 单目录段默认最多文件数 */
 export const DIR_MAX_FILES = 20;
@@ -365,12 +366,31 @@ function sectionCacheOptions(resolvedPath, vars) {
     }
     return { policy: 'mtime', group: 'eck-runtime' };
 }
+/**
+ * 读取一个 kits 文档，安装模式下先过台账校验。
+ *
+ * 为什么校验包在 loader 里：这些内容走 FileCache 的 `on-reload` 策略，缓存命中时
+ * 不会碰磁盘，校验只有包在这里才与"实际注入的那份内容"对齐；被篡改且恢复不了时
+ * 返回 null，条目本身也不会写进缓存。开发模式下 kits 由 agent 直接改写，不校验。
+ */
+function loadKitsDoc(resolved, vars) {
+    const opts = sectionCacheOptions(resolved, vars);
+    if (!isShippedPath(resolved)) {
+        return fileCache.getText(resolved, opts);
+    }
+    const verify = !isDevMode();
+    return fileCache.get(resolved, () => {
+        const checked = readVerifiedText(resolved, { verify, tag: 'eck' });
+        // 校验不过就不进缓存：返回 null → fileCache 存 null，该段被丢弃
+        return checked ? checked.text : null;
+    }, opts);
+}
 /** 加载 loop 的 child 子模板文件内容（路径解析 + fileCache）。找不到返回 null。 */
 export function loadChildTemplate(childFile, vars) {
     const resolved = resolvePath(childFile, vars);
     if (!resolved)
         return null;
-    return fileCache.getText(resolved, sectionCacheOptions(resolved, vars));
+    return loadKitsDoc(resolved, vars);
 }
 /**
  * 返回 [filePath, rawContent][]。kits 文件跨 session 缓存到 reload；运行时文件
@@ -401,7 +421,7 @@ function loadFileSection(filePath, vars, sessionCache) {
     const resolved = resolvePath(filePath, vars);
     if (!resolved)
         return null;
-    const content = fileCache.getText(resolved, sectionCacheOptions(resolved, vars));
+    const content = loadKitsDoc(resolved, vars);
     return content === null ? null : [resolved, content];
 }
 /**
@@ -435,7 +455,7 @@ function readDirectoryFiles(dirPath, pattern, maxFiles, maxBytes, vars) {
             break;
         }
         const fp = path.join(dirPath, f);
-        const content = fileCache.getText(fp, sectionCacheOptions(fp, vars));
+        const content = loadKitsDoc(fp, vars);
         if (content === null)
             continue;
         // 字节限额（至少加载一个文件，避免单个超大文件导致空目录）

package/dist/index.js

@@ -1,7 +1,7 @@
 // 【重要】最先加载环境变量，确保后续模块初始化时可用
 import dotenv from 'dotenv';
 import path from 'path';
-import { ensureDataDirs, resolvePaths, eckDebugDir, daemonControlDir, daemonQueuePath, daemonMessageDedupPath } from './paths.js';
+import { ensureDataDirs, resolvePaths, eckDebugDir, daemonControlDir, daemonQueuePath, daemonMessageDedupPath, isDevMode } from './paths.js';
 // 立即加载 .env 文件（在其他模块导入之前）
 try {
     dotenv.config({ path: path.join(resolvePaths().root, '.env') });
@@ -57,6 +57,7 @@ import { StatsCollector } from './utils/stats.js';
 import { AidStatsCollector } from './utils/stats.js';
 import { initializeStatsPersistence } from './stats/writer.js';
 import { PermissionGateway } from './core/permission/approval-gateway.js';
+import { releaseSessionPathGrants } from './core/permission/session-path-grants.js';
 import { InteractionRouter } from './core/interaction-router.js';
 import { GroupInviteReviewService } from './aun/group/invite-service.js';
 import { AgentDelegationRegistry, } from './core/auth/agent-delegation.js';
@@ -138,8 +139,10 @@ async function main() {
     }
     // 立即登记自己（让其他并发启动者能看见我）
     const launchedBy = process.env.EVOLCORE_LAUNCHED_BY || 'start';
+    // 本次运行模式在这里定下（首次求值时会读走并删除 `ec start --as-mode` 的覆盖文件）
+    const devMode = isDevMode();
     writeMain(launchedBy);
-    logger.info(`✓ Instance record written: main-${process.pid}.json`);
+    logger.info(`✓ Instance record written: main-${process.pid}.json runMode=${devMode ? 'dev' : 'install'}`);
     // post-write 自检：写完 record 后再扫一次，发现并发对手时按 (startedAt, pid) 选赢家
     {
         const verdict = isMainWinner();
@@ -240,6 +243,12 @@ async function main() {
         if (event.nameChanged)
             agentRegistry?.invalidateAgentDisplayCache?.(event.aid);
     });
+    // 运行时路径授权以会话为归属：会话被删除后不再有身份去消费它，随之释放。
+    // 只挂 session:deleted——session:idle 只表示空闲，会话仍会继续服务。
+    eventBus.subscribe('session:deleted', (event) => {
+        if ('sessionId' in event && event.sessionId)
+            releaseSessionPathGrants(event.sessionId);
+    });
     // 统计收集器（近 1 小时滚动统计）
     const statsCollector = new StatsCollector(eventBus);
     // Per-AID 消息统计收集器（累计，供 watch aid 实时展示）

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

@@ -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",