evolcore 0.0.3 → 0.0.5

package/dist/core/session/session-manager.js

@@ -1,7 +1,7 @@
 import { ensureDir } from '../../utils/atomic-write.js';
 import { logger } from '../../utils/logger.js';
 import { encodePath } from '../../utils/cross-platform.js';
-import { chatDirPath, generateSessionId, formatTimestamp, atomicWriteJson, appendJsonl, readJsonFile, readLastJsonlLine, readAllJsonlLines, scanChatDirs, scanMetaFiles, ensureChatDir, readThreadIndex, writeThreadIndex, } from './session-fs-store.js';
+import { chatDirPath, generateSessionId, formatTimestamp, atomicWriteJson, atomicWriteText, appendJsonl, readJsonFile, readLastJsonlLine, readAllJsonlLines, scanChatDirs, scanMetaFiles, ensureChatDir, readThreadIndex, writeThreadIndex, } from './session-fs-store.js';
 import { sessionToFile, fileToSession } from './session-mapper.js';
 import { formatSessionKey, DEFAULT_THREAD_ID } from './session-key.js';
 import { tryParseChannelKey } from '../channel-loader.js';
@@ -9,6 +9,22 @@ import { isSystemControlChannel } from '../system-channels.js';
 import path from 'path';
 import fs from 'fs';
 import os from 'os';
+function newSessionStableMetadata(chatType, ...sources) {
+    const keys = chatType === 'group'
+        ? ['channelKey', 'groupId', 'groupName', 'dispatchMode']
+        : ['channelKey', 'peerId', 'peerName', 'peerType'];
+    const metadata = {};
+    for (const source of sources) {
+        if (!source)
+            continue;
+        for (const key of keys) {
+            const value = source[key];
+            if (value !== undefined && value !== null && value !== '')
+                metadata[key] = value;
+        }
+    }
+    return metadata;
+}
 /** 判定用户是否为指定渠道的 admin */
 /** 判定用户是否为指定渠道的 member */
 export class SessionManager {
@@ -23,6 +39,7 @@ export class SessionManager {
         this.eventBus = eventBus;
         this.identityResolver = identityResolver;
         this.migrateChannelKeyFormat();
+        this.migrateUnknownAunDirs();
         this.migrateWecomChannelDirs();
     }
     setIdentityResolver(resolver) {
@@ -1098,18 +1115,20 @@ export class SessionManager {
             }
         }
     }
-    async createNewSession(channel, channelId, projectPath, name, baseagent) {
+    async createNewSession(channel, channelId, projectPath, name, baseagent, identityMetadata) {
         const inheritedChatType = this.getActiveChatType(channel, channelId);
         // Derive selfAID and channelType from existing sessions
         const existingDir = this.findExistingChatDir(channel, channelId);
         const identity = this.deriveChannelIdentity(channel, channelId);
         let channelType = identity.channelType;
         let selfAID = identity.selfAID;
+        let activeMetadata;
         if (existingDir) {
             const active = readJsonFile(path.join(existingDir, 'active.json'));
             if (active) {
                 channelType = active.channelType || channel;
                 selfAID = active.selfAID || '';
+                activeMetadata = active.metadata;
                 // 兼容旧字段名
                 const activeBaseagent = active.baseagent || active.agentType;
                 if (!baseagent && activeBaseagent)
@@ -1130,7 +1149,7 @@ export class SessionManager {
             baseagent,
             sessionKey: formatSessionKey(channelType, channelId, DEFAULT_THREAD_ID),
             chatType: inheritedChatType,
-            metadata: {},
+            metadata: newSessionStableMetadata(inheritedChatType, activeMetadata, identityMetadata),
             name: name || '默认会话',
             createdAt: Date.now(),
             updatedAt: Date.now(),
@@ -1258,7 +1277,7 @@ export class SessionManager {
      * 为超时后的独立话题创建新会话。保留聊天路由和稳定 metadata，
      * 但不继承任何底层 agent session 或临时任务状态。
      */
-    async createRenewedSession(sourceSession) {
+    async createRenewedSession(sourceSession, context) {
         const metadata = { ...(sourceSession.metadata || {}) };
         delete metadata.agentSessions;
         delete metadata.resumeAt;
@@ -1289,7 +1308,11 @@ export class SessionManager {
             projectPath: session.projectPath,
             name: session.name,
             chatType: session.chatType,
+            cause: 'renew',
+            sourceSessionId: sourceSession.id,
+            renewSource: context?.source,
             timestamp: Date.now(),
+            causation: context?.causation,
         });
         return session;
     }
@@ -1640,4 +1663,209 @@ export class SessionManager {
             logger.info(`[SessionManager] Migrated ${migrated} WeCom session director${migrated === 1 ? 'y' : 'ies'} to channelKey isolation`);
         }
     }
+    /**
+     * Recover legacy AUN chats written beneath `_unknown` before selfAID was
+     * persisted. A channel key or persisted selfAID is required to make the
+     * migration unambiguous; all other directories remain untouched.
+     */
+    migrateUnknownAunDirs() {
+        const legacyDirs = scanChatDirs(this.sessionsDir)
+            .filter(entry => entry.channelType === 'aun' && entry.selfAID === '_unknown');
+        let migrated = 0;
+        for (const entry of legacyDirs) {
+            const selfAIDs = this.findAunSelfAIDCandidates(entry.dirPath);
+            if (selfAIDs.size !== 1) {
+                if (selfAIDs.size > 1) {
+                    logger.error(`[SessionManager] Cannot auto-migrate mixed unknown AUN session directory: ${entry.dirPath}`);
+                }
+                continue;
+            }
+            const selfAID = [...selfAIDs][0];
+            const target = chatDirPath(this.sessionsDir, 'aun', entry.channelId, selfAID);
+            try {
+                this.mergeUnknownAunDirectory(entry.dirPath, target, selfAID);
+                migrated++;
+            }
+            catch (error) {
+                logger.error(`[SessionManager] Failed to migrate unknown AUN session directory ${entry.dirPath}: ${String(error)}`);
+            }
+        }
+        if (migrated > 0) {
+            logger.info(`[SessionManager] Migrated ${migrated} unknown AUN session director${migrated === 1 ? 'y' : 'ies'} to selfAID isolation`);
+        }
+    }
+    findAunSelfAIDCandidates(chatDir) {
+        const candidates = new Set();
+        const visitRecord = (record) => {
+            if (!record || typeof record !== 'object')
+                return;
+            const session = record;
+            const direct = typeof session.selfAID === 'string' ? session.selfAID.trim() : '';
+            if (direct && direct !== '_unknown')
+                candidates.add(direct);
+            const channel = typeof session.channel === 'string' ? tryParseChannelKey(session.channel) : null;
+            if (channel?.type === 'aun' && channel.selfAID !== '_unknown')
+                candidates.add(channel.selfAID);
+        };
+        const visitJsonl = (filePath) => {
+            for (const record of readAllJsonlLines(filePath))
+                visitRecord(record);
+        };
+        visitRecord(readJsonFile(path.join(chatDir, 'active.json')));
+        for (const metaFile of scanMetaFiles(chatDir))
+            visitJsonl(path.join(chatDir, metaFile));
+        const threadDir = path.join(chatDir, '_threads');
+        for (const metaFile of scanMetaFiles(threadDir))
+            visitJsonl(path.join(threadDir, metaFile));
+        return candidates;
+    }
+    mergeUnknownAunDirectory(sourceDir, targetDir, selfAID) {
+        if (sourceDir === targetDir)
+            return;
+        fs.mkdirSync(targetDir, { recursive: true });
+        this.mergeUnknownAunDirectoryContents(sourceDir, targetDir, selfAID);
+        fs.rmdirSync(sourceDir);
+    }
+    mergeUnknownAunDirectoryContents(sourceDir, targetDir, selfAID) {
+        for (const entry of fs.readdirSync(sourceDir, { withFileTypes: true })) {
+            const sourcePath = path.join(sourceDir, entry.name);
+            const targetPath = path.join(targetDir, entry.name);
+            if (entry.isDirectory()) {
+                fs.mkdirSync(targetPath, { recursive: true });
+                this.mergeUnknownAunDirectoryContents(sourcePath, targetPath, selfAID);
+                fs.rmdirSync(sourcePath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (entry.name === 'active.json') {
+                this.mergeUnknownAunActiveFile(sourcePath, targetPath, selfAID);
+            }
+            else if (entry.name.endsWith('.jsonl')) {
+                this.mergeUnknownAunJsonlFile(sourcePath, targetPath, selfAID);
+            }
+            else if (entry.name.endsWith('.json')) {
+                this.mergeUnknownAunJsonFile(sourcePath, targetPath);
+            }
+            else if (!fs.existsSync(targetPath)) {
+                fs.renameSync(sourcePath, targetPath);
+            }
+            else if (fs.readFileSync(sourcePath).equals(fs.readFileSync(targetPath))) {
+                fs.unlinkSync(sourcePath);
+            }
+            else {
+                fs.renameSync(sourcePath, this.uniqueLegacyFilePath(targetPath));
+            }
+        }
+    }
+    mergeUnknownAunActiveFile(sourcePath, targetPath, selfAID) {
+        const source = this.normalizeAunSessionRecord(readJsonFile(sourcePath), selfAID);
+        const target = this.normalizeAunSessionRecord(readJsonFile(targetPath), selfAID);
+        const sourceUpdatedAt = typeof source?.updatedAt === 'number' ? source.updatedAt : 0;
+        const targetUpdatedAt = typeof target?.updatedAt === 'number' ? target.updatedAt : 0;
+        const selected = target && targetUpdatedAt >= sourceUpdatedAt ? target : source;
+        if (selected)
+            atomicWriteJson(targetPath, selected);
+        fs.unlinkSync(sourcePath);
+    }
+    mergeUnknownAunJsonlFile(sourcePath, targetPath, selfAID) {
+        const records = [
+            ...this.readNormalizedAunJsonl(sourcePath, selfAID),
+            ...this.readNormalizedAunJsonl(targetPath, selfAID),
+        ];
+        const seen = new Set();
+        const unique = records.filter(record => {
+            if (seen.has(record.key))
+                return false;
+            seen.add(record.key);
+            return true;
+        });
+        unique.sort((left, right) => left.timestamp - right.timestamp || left.order - right.order);
+        atomicWriteText(targetPath, unique.map(record => record.line).join('\n') + (unique.length ? '\n' : ''));
+        fs.unlinkSync(sourcePath);
+    }
+    readNormalizedAunJsonl(filePath, selfAID) {
+        let content;
+        try {
+            content = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+        return content.split('\n').flatMap((rawLine, order) => {
+            const line = rawLine.trim();
+            if (!line)
+                return [];
+            try {
+                const record = this.normalizeAunSessionRecord(JSON.parse(line), selfAID);
+                const normalizedLine = JSON.stringify(record);
+                return [{
+                        key: this.stableJson(record),
+                        line: normalizedLine,
+                        timestamp: this.recordTimestamp(record),
+                        order,
+                    }];
+            }
+            catch {
+                return [{ key: `raw:${line}`, line, timestamp: Number.MAX_SAFE_INTEGER, order }];
+            }
+        });
+    }
+    normalizeAunSessionRecord(record, selfAID) {
+        if (!record || typeof record !== 'object' || Array.isArray(record))
+            return record;
+        const result = { ...record };
+        const isSessionRecord = 'channel' in result || 'channelType' in result || 'sessionKey' in result || 'selfAID' in result;
+        if (!isSessionRecord)
+            return result;
+        if (!result.selfAID || result.selfAID === '_unknown')
+            result.selfAID = selfAID;
+        return result;
+    }
+    stableJson(value) {
+        if (Array.isArray(value))
+            return `[${value.map(item => this.stableJson(item)).join(',')}]`;
+        if (value && typeof value === 'object') {
+            return `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${this.stableJson(value[key])}`).join(',')}}`;
+        }
+        return JSON.stringify(value);
+    }
+    recordTimestamp(record) {
+        if (!record || typeof record !== 'object')
+            return Number.MAX_SAFE_INTEGER;
+        const value = record;
+        for (const key of ['ts', 'at', 'updatedAt', 'createdAt']) {
+            if (typeof value[key] === 'number' && Number.isFinite(value[key]))
+                return value[key];
+        }
+        return Number.MAX_SAFE_INTEGER;
+    }
+    mergeUnknownAunJsonFile(sourcePath, targetPath) {
+        if (!fs.existsSync(targetPath)) {
+            fs.renameSync(sourcePath, targetPath);
+            return;
+        }
+        const source = readJsonFile(sourcePath);
+        const target = readJsonFile(targetPath);
+        if (source && target && !Array.isArray(source) && !Array.isArray(target)) {
+            atomicWriteJson(targetPath, { ...source, ...target });
+            fs.unlinkSync(sourcePath);
+            return;
+        }
+        if (fs.readFileSync(sourcePath).equals(fs.readFileSync(targetPath))) {
+            fs.unlinkSync(sourcePath);
+            return;
+        }
+        fs.renameSync(sourcePath, this.uniqueLegacyFilePath(targetPath));
+    }
+    uniqueLegacyFilePath(targetPath) {
+        let index = 1;
+        let candidate = `${targetPath}.legacy-unknown`;
+        while (fs.existsSync(candidate)) {
+            candidate = `${targetPath}.legacy-unknown-${index++}`;
+        }
+        return candidate;
+    }
 }

package/dist/core/session/session-mapper.js

@@ -3,6 +3,8 @@ import { formatSessionKey, DEFAULT_THREAD_ID } from './session-key.js';
 export function sessionToFile(session) {
     const metadata = {};
     if (session.metadata) {
+        if (session.metadata.channelKey)
+            metadata.channelKey = session.metadata.channelKey;
         if (session.metadata.peerId)
             metadata.peerId = session.metadata.peerId;
         if (session.metadata.peerName)

package/dist/core/session/session-renew.js

@@ -3,8 +3,11 @@ import { formatPeerKey } from '../relation/peer-identity.js';
 import { logger } from '../../utils/logger.js';
 import { isTransientProtocolMessage, messageLogPath } from '../message/message-log.js';
 import { readAllJsonlLines } from './session-fs-store.js';
+import { ResponseModeRegistry } from '../../response-system/registry.js';
+import { registerBuiltinModes } from '../../response-system/modes/index.js';
+import { resolveEffectiveResponseModeConfig } from '../../response-system/config-resolver.js';
+import { normalizeBaseagent } from '../../agents/baseagent.js';
 const DEFAULT_AFTER_HOURS = 24;
-const DEFAULT_EFFORT = 'low';
 const DEFAULT_FALLBACK = 'continue';
 const MAX_CONTEXT_MESSAGES = 40;
 const MAX_CONTEXT_CHARS = 16_000;
@@ -12,7 +15,7 @@ const MAX_MESSAGE_CHARS = 2_000;
 const MODEL_TIMEOUT_MS = 10_000;
 const RECENT_DECISION_TTL_MS = 30_000;
 const NEW_CONFIDENCE_THRESHOLD = 0.85;
-const JUDGE_BASEAGENT = 'claude';
+const AUXILIARY_EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
 const EXPLICIT_NEW_RE = /^(?:新话题|换个话题|重新开始|新开会话|新会话)[：:，,；;。！!\n]/;
 const EXPLICIT_CONTINUE_RE = /^(?:继续上次|延续上次|继续|接着)[：:，,；;。！!\n]/;
 const NON_CONVERSATION_TYPES = new Set([
@@ -43,41 +46,6 @@ export function selectSessionRenewContext(entries) {
     const selected = [entries[0], ...entries.slice(-(MAX_CONTEXT_MESSAGES - 1))];
     return trimContextByChars(selected);
 }
-export function selectLatestHaikuModel(models) {
-    let selected;
-    for (const rawModel of models) {
-        const id = rawModel.trim();
-        if (!id)
-            continue;
-        const leaf = id.toLowerCase().split('/').at(-1) ?? '';
-        const tokens = leaf.split('-');
-        const haikuIndex = tokens.indexOf('haiku');
-        if (haikuIndex < 0)
-            continue;
-        const versionTokens = haikuIndex <= 1
-            ? tokens.slice(haikuIndex + 1)
-            : tokens.slice(1, haikuIndex);
-        const versions = versionTokens
-            .filter(token => /^\d{1,2}$/.test(token))
-            .map(Number);
-        const dates = tokens
-            .filter(token => /^\d{8}$/.test(token))
-            .map(Number);
-        const candidate = {
-            id,
-            major: versions[0] ?? 0,
-            minor: versions[1] ?? 0,
-            date: dates.length > 0 ? Math.max(...dates) : 0,
-        };
-        if (!selected
-            || candidate.major > selected.major
-            || (candidate.major === selected.major && candidate.minor > selected.minor)
-            || (candidate.major === selected.major && candidate.minor === selected.minor && candidate.date > selected.date)) {
-            selected = candidate;
-        }
-    }
-    return selected?.id;
-}
 function trimContextByChars(entries) {
     if (entries.length === 0)
         return [];
@@ -100,17 +68,27 @@ export class SessionRenewService {
     locks = new Map();
     recentDecisions = new Map();
     now;
-    configResolver;
+    effectiveConfigResolver;
+    eventBus;
+    responseModeRegistry = new ResponseModeRegistry();
     constructor(sessionManager, inferenceProviderResolver, options = {}) {
         this.sessionManager = sessionManager;
         this.inferenceProviderResolver = inferenceProviderResolver;
         this.now = options.now ?? (() => Date.now());
-        this.configResolver = options.resolveConfig;
+        this.effectiveConfigResolver = options.resolveEffectiveConfig;
+        this.eventBus = options.eventBus;
+        registerBuiltinModes(this.responseModeRegistry);
     }
     async resolve(request) {
-        const config = this.resolveConfig(request);
+        const effectiveConfig = this.resolveEffectiveConfig(request);
+        const config = effectiveConfig?.session_renew;
         if (!config || config.enabled !== true)
             return { session: request.session, renewed: false };
+        // Thread / processing sessions are already an explicit routing decision.
+        // Do not let a cached or active main session replace them before resolveLocked().
+        if (request.session.threadId || request.session.processingState) {
+            return { session: request.session, renewed: false };
+        }
         const routeKey = this.routeKey(request);
         return await this.withLock(routeKey, async () => {
             const cached = this.recentDecisions.get(routeKey);
@@ -133,12 +111,11 @@ export class SessionRenewService {
                 active.identity = request.session.identity;
                 return { session: active, renewed: true, decision: 'new', source: 'fallback' };
             }
-            return await this.resolveLocked(routeKey, request, config);
+            return await this.resolveLocked(routeKey, request, config, effectiveConfig);
         });
     }
-    async resolveLocked(routeKey, request, config) {
-        if (request.session.threadId || request.session.processingState)
-            return { session: request.session, renewed: false };
+    async resolveLocked(routeKey, request, config, effectiveConfig) {
+        const evaluationStartedAt = Date.now();
         const afterHours = validPositiveNumber(config.after_hours) ?? DEFAULT_AFTER_HOURS;
         const entries = this.readConversationEntries(request.session);
         const last = entries[entries.length - 1];
@@ -146,7 +123,7 @@ export class SessionRenewService {
             if (request.isNewSession)
                 return { session: request.session, renewed: false };
             const idleMs = this.now() - request.session.updatedAt;
-            return await this.finishDecision(routeKey, request, 'new', 'missing_history', idleMs);
+            return await this.finishDecision(routeKey, request, 'new', 'missing_history', idleMs, evaluationStartedAt);
         }
         const idleMs = this.now() - last.ts;
         if (idleMs <= afterHours * 60 * 60 * 1000)
@@ -162,13 +139,22 @@ export class SessionRenewService {
             source = 'reply';
         }
         else {
-            let judgeModel;
+            const auxiliary = this.resolveAuxiliaryConfig(effectiveConfig, request.session.baseagent);
+            let judgeMetadata = {
+                responseMode: auxiliary.responseMode,
+                baseagent: request.session.baseagent,
+                model: auxiliary.model,
+                effort: auxiliary.effort,
+            };
             try {
-                const provider = this.inferenceProviderResolver.getTextInferenceProvider(request.channelName, JUDGE_BASEAGENT, request.selfAid);
+                if (!auxiliary.model)
+                    throw new SessionRenewJudgeError('auxiliary_model_missing');
+                if (auxiliary.invalidEffort)
+                    throw new SessionRenewJudgeError('auxiliary_effort_invalid');
+                const provider = this.inferenceProviderResolver.getTextInferenceProvider(request.channelName, request.session.baseagent, request.selfAid);
                 if (!provider)
-                    throw new Error(`text inference provider unavailable: ${JUDGE_BASEAGENT}`);
-                const judged = await this.judgeWithModel(request, config, entries, idleMs, provider);
-                judgeModel = judged.model;
+                    throw new SessionRenewJudgeError('provider_unavailable');
+                const judged = await this.judgeWithModel(request, entries, idleMs, provider, auxiliary);
                 decision = judged.decision === 'new' && judged.confidence < NEW_CONFIDENCE_THRESHOLD
                     ? 'continue'
                     : judged.decision;
@@ -177,15 +163,19 @@ export class SessionRenewService {
             catch (error) {
                 decision = config.fallback_action ?? DEFAULT_FALLBACK;
                 source = 'fallback';
+                judgeMetadata = { ...judgeMetadata, fallbackReason: sessionRenewFallbackReason(error) };
                 logger.warn(`[SessionRenew] judge failed, using fallback=${decision}: ${error instanceof Error ? error.message : String(error)}`);
             }
-            return await this.finishDecision(routeKey, request, decision, source, idleMs, judgeModel);
+            return await this.finishDecision(routeKey, request, decision, source, idleMs, evaluationStartedAt, judgeMetadata);
         }
-        return await this.finishDecision(routeKey, request, decision, source, idleMs);
+        return await this.finishDecision(routeKey, request, decision, source, idleMs, evaluationStartedAt);
     }
-    async finishDecision(routeKey, request, decision, source, idleMs, judgeModel) {
+    async finishDecision(routeKey, request, decision, source, idleMs, evaluationStartedAt, judge) {
         const selected = decision === 'new'
-            ? await this.sessionManager.createRenewedSession(request.session)
+            ? await this.sessionManager.createRenewedSession(request.session, {
+                source,
+                causation: request.causation,
+            })
             : request.session;
         selected.identity = request.session.identity;
         this.recentDecisions.set(routeKey, {
@@ -195,12 +185,39 @@ export class SessionRenewService {
             source,
             expiresAt: this.now() + RECENT_DECISION_TTL_MS,
         });
-        logger.info(`[SessionRenew] session=${request.session.id} selected=${selected.id} decision=${decision} source=${source} idleHours=${(idleMs / 3_600_000).toFixed(2)} baseagent=${judgeModel ? JUDGE_BASEAGENT : 'none'} model=${judgeModel || 'none'}`);
+        logger.info(`[SessionRenew] session=${request.session.id} selected=${selected.id} decision=${decision} source=${source}`
+            + ` idleHours=${(idleMs / 3_600_000).toFixed(2)}`
+            + ` responseMode=${judge?.responseMode ?? 'none'}`
+            + ` baseagent=${judge?.baseagent ?? 'none'}`
+            + ` model=${judge?.model ?? 'none'}`
+            + ` effort=${judge?.effort ?? 'provider-default'}`
+            + ` fallbackReason=${judge?.fallbackReason ?? 'none'}`);
+        this.eventBus?.publish({
+            type: 'session:renew-evaluated',
+            candidateSessionId: request.session.id,
+            selectedSessionId: selected.id,
+            renewed: decision === 'new',
+            decision,
+            source,
+            channel: request.session.channel,
+            channelName: request.channelName,
+            channelId: request.channelId,
+            selfAid: request.selfAid,
+            idleHours: Number((idleMs / 3_600_000).toFixed(2)),
+            responseMode: judge?.responseMode,
+            baseagent: judge?.baseagent,
+            model: judge?.model,
+            effort: judge?.effort,
+            fallbackReason: judge?.fallbackReason,
+            durationMs: Math.max(0, Date.now() - evaluationStartedAt),
+            timestamp: this.now(),
+            causation: request.causation,
+        });
         return { session: selected, renewed: decision === 'new', decision, source };
     }
-    resolveConfig(request) {
-        if (this.configResolver)
-            return this.configResolver(request);
+    resolveEffectiveConfig(request) {
+        if (this.effectiveConfigResolver)
+            return this.effectiveConfigResolver(request);
         if (!request.selfAid)
             return undefined;
         const peerKeyId = request.chatType === 'group'
@@ -210,7 +227,30 @@ export class SessionRenewService {
         return resolveEffective({
             self: request.selfAid,
             peerKey,
-        }, { cache: true }).session_renew;
+        }, { cache: true, expand: true });
+    }
+    resolveAuxiliaryConfig(config, baseagent) {
+        const resolved = resolveEffectiveResponseModeConfig(this.responseModeRegistry, config);
+        const rawModel = resolved.modeConfig.auxiliaryModel;
+        const canonicalBaseagent = normalizeBaseagent(baseagent).canonical;
+        const selectedModel = typeof rawModel === 'string'
+            ? rawModel
+            : rawModel && typeof rawModel === 'object' && !Array.isArray(rawModel)
+                ? rawModel[canonicalBaseagent]
+                : undefined;
+        const model = typeof selectedModel === 'string' && selectedModel.trim()
+            ? selectedModel.trim()
+            : undefined;
+        const rawEffort = resolved.modeConfig.auxiliaryEffort;
+        const effort = typeof rawEffort === 'string' && AUXILIARY_EFFORTS.has(rawEffort)
+            ? rawEffort
+            : undefined;
+        return {
+            responseMode: resolved.mode.id,
+            model,
+            effort,
+            invalidEffort: rawEffort !== undefined && effort === undefined,
+        };
     }
     readConversationEntries(session) {
         const entries = readAllJsonlLines(messageLogPath(this.sessionManager.getChatDir(session)));
@@ -218,7 +258,7 @@ export class SessionRenewService {
             .filter(entry => isSessionRenewConversationEntry(entry, session.id))
             .sort((left, right) => left.ts - right.ts);
     }
-    async judgeWithModel(request, config, entries, idleMs, provider) {
+    async judgeWithModel(request, entries, idleMs, provider, auxiliary) {
         const context = selectSessionRenewContext(entries).map(entry => ({
             dir: entry.dir,
             content: entry.content.slice(0, MAX_MESSAGE_CHARS),
@@ -243,20 +283,14 @@ export class SessionRenewService {
         let timer;
         try {
             const operation = (async () => {
-                if (!provider.listModels)
-                    throw new Error('Claude text inference provider does not expose a model list');
-                const models = await provider.listModels(controller.signal);
-                const model = selectLatestHaikuModel(models);
-                if (!model)
-                    throw new Error('Claude model list contains no Haiku model');
                 const text = await provider.completeText({
-                    model,
-                    effort: config.effort || DEFAULT_EFFORT,
+                    model: auxiliary.model,
+                    ...(auxiliary.effort ? { effort: auxiliary.effort } : {}),
                     system: systemPrompt,
                     input: prompt,
                     signal: controller.signal,
                 });
-                return { model, text };
+                return { model: auxiliary.model, text };
             })();
             const timeout = new Promise((_resolve, reject) => {
                 timer = setTimeout(() => {
@@ -292,6 +326,28 @@ export class SessionRenewService {
         }
     }
 }
+class SessionRenewJudgeError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'SessionRenewJudgeError';
+    }
+}
+function sessionRenewFallbackReason(error) {
+    if (error instanceof SessionRenewJudgeError)
+        return error.code;
+    const message = error instanceof Error ? error.message : String(error);
+    if (/timed out|abort/i.test(message))
+        return 'timeout';
+    if (/HTTP \d+/i.test(message))
+        return 'http_error';
+    if (/no JSON|invalid decision|invalid confidence/i.test(message))
+        return 'invalid_response';
+    if (/no text|empty/i.test(message))
+        return 'empty_response';
+    return 'inference_error';
+}
 function validPositiveNumber(value) {
     return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : undefined;
 }

package/dist/core/session/session-turn-coordinator.js

@@ -101,7 +101,11 @@ export class SessionTurnCoordinator {
                 turnId: active.turnId,
                 taskId: active.taskId,
                 generation: active.generation,
-                status: reason === 'stop' || reason === 'explicit_cancel' ? 'cancelled' : 'superseded',
+                status: reason === 'daemon_restart'
+                    ? 'interrupted'
+                    : reason === 'stop' || reason === 'explicit_cancel'
+                        ? 'cancelled'
+                        : 'superseded',
                 reason,
                 finishedAt: Date.now(),
             },

package/dist/eck/kit-renderer.js

@@ -3,6 +3,7 @@ import path from 'path';
 import { isEckSnapshotsEnabled } from '../config-store.js';
 import { eckDebugDir } from '../paths.js';
 import { logger } from '../utils/logger.js';
+import { clearRoleStoreCache } from '../config/role-store.js';
 import { loadManifest, loadManifestMeta, invalidateManifestCache, evaluateWhen, renderTemplate, renderLoopSection, resolvePathWithDiag, loadSectionFiles, loadChildTemplate, buildPathMappings, shortenPath, } from './manifest-engine.js';
 const DEFAULT_MANIFEST_FILE = 'eck_manifest.json';
 // ── Caches ──
@@ -19,9 +20,18 @@ export function loadKitManifest() {
     const sections = loadManifest(DEFAULT_MANIFEST_FILE);
     logger.info(`[KitRenderer] Loaded manifest: ${sections.length} sections`);
 }
+/**
+ * kits 统一失效入口：`kits/` 下的任何东西改了，都从这里一次清干净。
+ *
+ * 必须连带清 role-store 快照：它的签名含角色模板 mtime，而模板内容走 FileCache
+ * 的 on-reload（平时不查盘）。若"模板改盘 → 失效前发生一次鉴权读取"，快照就会以
+ * **新 mtime + 旧内容** 落盘；此后签名不再变化，光清 FileCache 也换不掉它——
+ * 授权数据会永久停在旧版本。
+ */
 export function invalidateKitCache() {
     invalidateManifestCache();
     _sessionPathCache.clear();
+    clearRoleStoreCache();
 }
 export function invalidateSessionCache(sessionId) {
     _sessionPathCache.delete(sessionId);
@@ -203,7 +213,7 @@ const PARAM_DESCRIPTIONS = {
     sameEgressIp: '对端与本端共享同一出口 IP',
     groupId: '群组 ID（群聊时）',
     groupRulesPath: '群规则本地物化文件（relations/<peerKey>/rules.md）',
-    groupRulesStatus: '群规则同步状态（synced/cached/missing/forbidden/invalid_metadata/file_mismatch/too_large/unreadable/error）',
+    groupRulesStatus: '群规则状态（ignored/synced/cached/missing/forbidden/invalid_metadata/file_mismatch/too_large/unreadable/error）',
     groupRulesError: '群规则同步错误',
     chatType: '聊天类型（private=私聊 / group=群聊 / null=本地开发）',
     channel: '渠道类型（aun/feishu/wechat/dingtalk/qqbot/wecom）',
@@ -226,6 +236,7 @@ const PARAM_DESCRIPTIONS = {
     osInfo: '操作系统及版本（如 Windows 11 Pro (win32 10.0.26200)）',
     threadId: '话题 ID（多话题路由时）',
     chatMode: '会话模式（interactive=同步交互 / proactive=主动推送）',
+    isTriggerTask: '当前任务是否来源于 Trigger（true/false）',
     proactivePreTool1stMsgChk: 'proactive 前置工具首消息检查（true/false）',
     proactiveToolUseReminder: 'proactive 工具调用提醒（true/false）',
     proactiveFirstSendRequired: '当前消息是否要求首次非发送工具前先发送表态',