evolcore 0.0.2 → 0.0.4

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: '当前消息是否要求首次非发送工具前先发送表态',

package/dist/eck/message-renderer.js

@@ -51,6 +51,59 @@ function renderOneItem(item, sessionVars, sessionCache, contentSentinel) {
     const isOwnerHint = item.kind === 'owner-hint';
     const isHandoff = item.kind === 'handoff';
     const handoffPreviousSentinel = `\x00ECMSG-HANDOFF-PREV-${randomUUID()}\x00`;
+    const requiredReplacements = (item.handoff?.requiredEntries ?? []).map(entry => ({
+        entry,
+        sentinel: `\x00ECMSG-HANDOFF-REQ-${randomUUID()}\x00`,
+    }));
+    const contextReplacements = (item.handoff?.contextEntries ?? []).map(entry => ({
+        entry,
+        sentinel: `\x00ECMSG-HANDOFF-CTX-${randomUUID()}\x00`,
+    }));
+    const originReplacements = (item.handoff?.originEntries ?? []).map(entry => ({
+        entry,
+        previousSentinel: `\x00ECMSG-HANDOFF-ORIGIN-PREV-${randomUUID()}\x00`,
+        responseSentinel: `\x00ECMSG-HANDOFF-ORIGIN-RESP-${randomUUID()}\x00`,
+    }));
+    const fallbackRequiredEntries = item.handoff?.returnPolicy === 'required'
+        && item.handoff.handoffId
+        && item.handoff.previousContent !== undefined
+        && requiredReplacements.length === 0
+        ? [{
+                entry: {
+                    handoffId: item.handoff.handoffId,
+                    previousContent: item.handoff.previousContent,
+                    previousMessageId: item.handoff.previousMessageId,
+                },
+                sentinel: `\x00ECMSG-HANDOFF-REQ-${randomUUID()}\x00`,
+            }]
+        : [];
+    const fallbackContextEntries = item.handoff?.returnPolicy === 'none'
+        && item.handoff.previousContent !== undefined
+        && contextReplacements.length === 0
+        ? [{
+                entry: {
+                    previousContent: item.handoff.previousContent,
+                    previousMessageId: item.handoff.previousMessageId,
+                },
+                sentinel: `\x00ECMSG-HANDOFF-CTX-${randomUUID()}\x00`,
+            }]
+        : [];
+    const allRequiredReplacements = [...requiredReplacements, ...fallbackRequiredEntries];
+    const allContextReplacements = [...contextReplacements, ...fallbackContextEntries];
+    const fallbackOriginEntries = item.handoff?.kind === 'response_to_origin'
+        && item.handoff.previousContent !== undefined
+        && originReplacements.length === 0
+        ? [{
+                entry: {
+                    previousContent: item.handoff.previousContent,
+                    responseContent: item.content,
+                    previousMessageId: item.handoff.previousMessageId,
+                },
+                previousSentinel: handoffPreviousSentinel,
+                responseSentinel: contentSentinel,
+            }]
+        : [];
+    const allOriginReplacements = [...originReplacements, ...fallbackOriginEntries];
     // item-level vars: session vars overlaid with this message's own sender/timestamp.
     const itemVars = {
         ...sessionVars,
@@ -91,6 +144,20 @@ function renderOneItem(item, sessionVars, sessionCache, contentSentinel) {
         handoffPreviousMessageId: item.handoff?.previousMessageId ?? undefined,
         handoffPreviousContent: item.handoff ? handoffPreviousSentinel : undefined,
         handoffReturnPolicy: item.handoff?.returnPolicy,
+        handoffRequiredEntries: allRequiredReplacements.map(({ entry, sentinel }) => ({
+            handoffId: entry.handoffId,
+            previousContent: sentinel,
+            previousMessageId: entry.previousMessageId ?? undefined,
+        })),
+        handoffContextEntries: allContextReplacements.map(({ entry, sentinel }) => ({
+            previousContent: sentinel,
+            previousMessageId: entry.previousMessageId ?? undefined,
+        })),
+        handoffOriginEntries: allOriginReplacements.map(({ entry, previousSentinel, responseSentinel }) => ({
+            previousContent: previousSentinel,
+            responseContent: responseSentinel,
+            previousMessageId: entry.previousMessageId ?? undefined,
+        })),
         // content held as a per-call random sentinel, swapped back post-render.
         // Using a UUID means no real message can collide with it.
         content: contentSentinel,
@@ -109,9 +176,20 @@ function renderOneItem(item, sessionVars, sessionCache, contentSentinel) {
                 ? renderTemplate(rawContent, itemVars, /* stripBlankLines */ false)
                 : rawContent;
             // swap the sentinel back to the real message text (literal replace, no parsing).
-            const withContent = rendered
+            let withContent = rendered
                 .split(contentSentinel).join(item.content)
                 .split(handoffPreviousSentinel).join(item.handoff?.previousContent ?? '');
+            for (const { entry, sentinel } of allRequiredReplacements) {
+                withContent = withContent.split(sentinel).join(entry.previousContent);
+            }
+            for (const { entry, sentinel } of allContextReplacements) {
+                withContent = withContent.split(sentinel).join(entry.previousContent);
+            }
+            for (const { entry, previousSentinel, responseSentinel } of allOriginReplacements) {
+                withContent = withContent
+                    .split(previousSentinel).join(entry.previousContent)
+                    .split(responseSentinel).join(entry.responseContent);
+            }
             if (withContent.trim())
                 out.push(withContent.replace(/\s+$/, ''));
         }