evolcore 0.0.28 → 0.0.29

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

@@ -1,22 +1,21 @@
 import { formatTimestamp } from './session-fs-store.js';
 /** Default topic component used by the stable session routing key. */
 export const DEFAULT_THREAD_ID = 'main';
-/** Normalize the optional topic category. The public field is spelled `lable`. */
-export function normalizeTopicLable(value) {
+export function normalizeTopicLabel(value) {
     if (value === undefined || value === null)
         return undefined;
     if (typeof value !== 'string')
-        throw new Error('lable 必须是字符串或 null');
-    const lable = value.trim();
-    if (lable.length > 100 || /[\x00-\x1F\x7F]/.test(lable)) {
-        throw new Error('lable 最多 100 个字符，且不能包含控制字符');
+        throw new Error('label 必须是字符串或 null');
+    const label = value.trim();
+    if (label.length > 100 || /[\x00-\x1F\x7F]/.test(label)) {
+        throw new Error('label 最多 100 个字符，且不能包含控制字符');
     }
-    return lable || undefined;
+    return label || undefined;
 }
-/** The reserved category used to hide a topic from the default topic list. */
-export const ARCHIVED_TOPIC_LABLE = '归档';
-export function isArchivedTopicLable(lable) {
-    return lable === ARCHIVED_TOPIC_LABLE;
+export function normalizeTopicStatus(value) {
+    if (value === 'pending' || value === 'in_progress' || value === 'completed' || value === 'archived')
+        return value;
+    throw new Error('topicStatus 必须是 pending、in_progress、completed 或 archived');
 }
 /** Resolve the public archived query flag while keeping omitted values backward compatible. */
 export function resolveTopicArchiveFilter(value) {
@@ -28,13 +27,26 @@ export function resolveTopicArchiveFilter(value) {
         return 'all';
     throw new Error('archived 必须是布尔值或 "all"');
 }
-/** Ordinary messages may initialize a category; malformed metadata is ignored. */
-export function readTopicLable(payload) {
+export function readTopicLabel(payload) {
     if (!payload || typeof payload !== 'object')
         return undefined;
     const fields = payload;
     try {
-        return normalizeTopicLable(Object.hasOwn(fields, 'lable') ? fields.lable : fields.label);
+        const label = fields.label === undefined ? fields.lable : fields.label;
+        return label === '归档' && fields.label === undefined ? undefined : normalizeTopicLabel(label);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readTopicStatus(payload) {
+    if (!payload || typeof payload !== 'object')
+        return undefined;
+    try {
+        const fields = payload;
+        if (fields.topicStatus === undefined && fields.lable === '归档')
+            return 'archived';
+        return normalizeTopicStatus(fields.topicStatus);
     }
     catch {
         return undefined;
@@ -103,7 +115,8 @@ export function sessionToFile(session) {
         projectPath: session.projectPath,
         agentSessionId: session.agentSessionId ?? null,
         name: session.name ?? null,
-        ...(session.lable ? { lable: session.lable } : {}),
+        ...(session.label ? { label: session.label } : {}),
+        ...(session.threadId ? { topicStatus: session.topicStatus ?? 'pending' } : {}),
         activeTask: session.processingState ?? null,
         metadata,
         createdAt: session.createdAt,
@@ -153,7 +166,11 @@ export function fileToSession(file) {
         projectPath: file.projectPath,
         agentSessionId: file.agentSessionId ?? undefined,
         name: file.name ?? undefined,
-        ...(file.lable ? { lable: file.lable } : {}),
+        ...(file.threadId && (file.label || (file.lable && file.lable !== '归档'))
+            ? { label: file.label || file.lable } : {}),
+        ...(file.threadId ? { topicStatus: file.topicStatus
+                ? normalizeTopicStatus(file.topicStatus)
+                : file.lable === '归档' ? 'archived' : 'pending' } : {}),
         processingState: file.activeTask ?? undefined,
         metadata,
         createdAt: file.createdAt,

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

@@ -1,25 +1,26 @@
+import fs from 'fs';
+import path from 'path';
 import { resolveEffective } from '../../config/config-manager.js';
 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 { normalizeBaseagent } from '../../agents/baseagent.js';
+import { getPackageRoot } from '../../paths.js';
 const DEFAULT_AFTER_HOURS = 24;
 const DEFAULT_FALLBACK = 'continue';
-const MAX_CONTEXT_MESSAGES = 40;
+const DEFAULT_NEW_PROBABILITY_THRESHOLD = 0.85;
+const MAX_CONTEXT_MESSAGES = 30;
+const PRESERVED_HEAD_MESSAGES = 5;
+const PRESERVED_TAIL_MESSAGES = 25;
 const MAX_CONTEXT_CHARS = 16_000;
-const MAX_MESSAGE_CHARS = 2_000;
+const MAX_MESSAGE_CHARS = 800;
+const MAX_MESSAGE_HEAD_CHARS = 600;
+const MAX_MESSAGE_TAIL_CHARS = 200;
 const MODEL_TIMEOUT_MS = 10_000;
 const RECENT_DECISION_TTL_MS = 30_000;
 const FRESH_EMPTY_SESSION_TTL_MS = 30_000;
 const RENEWED_AT_METADATA_KEY = '__sessionRenewedAt';
 const CREATED_AT_METADATA_KEY = '__sessionCreatedAt';
-const NEW_CONFIDENCE_THRESHOLD = 0.85;
-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([
     'command',
     'thought',
@@ -28,13 +29,59 @@ const NON_CONVERSATION_TYPES = new Set([
     'tool_call',
     'tool_result',
 ]);
-export function classifyExplicitSessionRenewSignal(content) {
-    const normalized = content.trimStart();
-    if (EXPLICIT_NEW_RE.test(normalized))
-        return 'new';
-    if (EXPLICIT_CONTINUE_RE.test(normalized))
-        return 'continue';
-    return undefined;
+const SESSION_RENEW_TEMPLATE_PATH = path.join(getPackageRoot(), 'kits', 'templates', 'decision', 'session-renew.md');
+const DEFAULT_SESSION_RENEW_PROMPT = {
+    stateRules: [
+        '会话边界判定规则：',
+        '1. 如果当前消息的内容主题已经转向另一件事，应判定为新会话，即使没有使用会话命令词。',
+        '2. 如果当前消息表达暂停当前主题并转向另一件事，也应判定为新会话。',
+        '3. 如果当前消息仍围绕历史主题补充、追问、修改或执行，应判定为继续当前会话。',
+        '4. 如果信息不足、无法可靠判断主题关系，应保留不确定性，不要默认新建或继续。',
+        '5. 重点判断内容主题和上下文关系，不要只匹配“新开”“重新”“换个”“继续”等关键词。',
+    ].join('\n'),
+    questionInstructions: '判断当前消息相对于历史会话是否应该开启独立的新会话，重点依据内容主题和上下文关系。',
+    trueCriteria: '当前消息已经转向另一件具体事情，或表达了停止当前主题、之后开始另一件事的边界意图。',
+    falseCriteria: '当前消息仍然围绕历史主题补充、追问、修改或执行。',
+};
+let cachedSessionRenewPrompt;
+function parseSessionRenewPromptTemplate(source) {
+    const sections = new Map();
+    const matches = [...source.matchAll(/^##\s+(.+)\s*$/gmu)];
+    for (const [index, match] of matches.entries()) {
+        const name = match[1].trim();
+        const start = (match.index ?? 0) + match[0].length;
+        const end = matches[index + 1]?.index ?? source.length;
+        sections.set(name, source.slice(start, end).trim());
+    }
+    const prompt = {
+        stateRules: sections.get('State Rules'),
+        questionInstructions: sections.get('Question Instructions'),
+        trueCriteria: sections.get('True Criteria'),
+        falseCriteria: sections.get('False Criteria'),
+    };
+    return Object.values(prompt).every(value => value)
+        ? prompt
+        : undefined;
+}
+export function loadSessionRenewPrompt() {
+    if (cachedSessionRenewPrompt)
+        return cachedSessionRenewPrompt;
+    try {
+        const parsed = parseSessionRenewPromptTemplate(fs.readFileSync(SESSION_RENEW_TEMPLATE_PATH, 'utf8'));
+        if (parsed) {
+            cachedSessionRenewPrompt = parsed;
+            return parsed;
+        }
+        logger.warn(`[SessionRenewPrompt] Missing required sections: ${SESSION_RENEW_TEMPLATE_PATH}`);
+    }
+    catch (error) {
+        logger.warn(`[SessionRenewPrompt] Failed to load ${SESSION_RENEW_TEMPLATE_PATH}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    cachedSessionRenewPrompt = DEFAULT_SESSION_RENEW_PROMPT;
+    return DEFAULT_SESSION_RENEW_PROMPT;
+}
+export function resetSessionRenewPromptForTests() {
+    cachedSessionRenewPrompt = undefined;
 }
 export function isSessionRenewConversationEntry(entry, sessionId) {
     return entry.sessionId === sessionId
@@ -43,26 +90,52 @@ export function isSessionRenewConversationEntry(entry, sessionId) {
         && entry.content.trim().length > 0;
 }
 export function selectSessionRenewContext(entries) {
-    if (entries.length <= MAX_CONTEXT_MESSAGES)
-        return trimContextByChars(entries);
-    const selected = [entries[0], ...entries.slice(-(MAX_CONTEXT_MESSAGES - 1))];
-    return trimContextByChars(selected);
+    const selected = entries.length <= MAX_CONTEXT_MESSAGES
+        ? entries
+        : [
+            ...entries.slice(0, PRESERVED_HEAD_MESSAGES),
+            ...entries.slice(-PRESERVED_TAIL_MESSAGES),
+        ];
+    return selected.map(entry => ({
+        ...entry,
+        content: truncateSessionRenewMessage(entry.content),
+    }));
 }
-function trimContextByChars(entries) {
-    if (entries.length === 0)
-        return [];
-    const first = entries[0];
-    const tail = [];
-    let remaining = MAX_CONTEXT_CHARS - Math.min(first.content.length, MAX_MESSAGE_CHARS);
-    for (let index = entries.length - 1; index >= 1 && remaining > 0; index--) {
-        const entry = entries[index];
-        const length = Math.min(entry.content.length, MAX_MESSAGE_CHARS);
-        if (tail.length > 0 && length > remaining)
+function truncateSessionRenewMessage(content) {
+    if (content.length <= MAX_MESSAGE_CHARS)
+        return content;
+    const marker = '[中间内容已省略]';
+    const available = MAX_MESSAGE_CHARS - marker.length;
+    const headBudget = Math.min(MAX_MESSAGE_HEAD_CHARS, available);
+    const tailBudget = Math.min(MAX_MESSAGE_TAIL_CHARS, available - headBudget);
+    const head = takeParagraphBoundary(content, headBudget, false);
+    const tail = takeParagraphBoundary(content, tailBudget, true);
+    return `${head}${marker}${tail}`.slice(0, MAX_MESSAGE_CHARS);
+}
+function takeParagraphBoundary(content, budget, fromEnd) {
+    if (budget <= 0)
+        return '';
+    if (content.length <= budget)
+        return content;
+    const paragraphs = content.split(/\n\s*\n/u).filter(Boolean);
+    if (paragraphs.length <= 1) {
+        return fromEnd ? content.slice(-budget) : content.slice(0, budget);
+    }
+    const selected = [];
+    let used = 0;
+    const ordered = fromEnd ? [...paragraphs].reverse() : paragraphs;
+    for (const paragraph of ordered) {
+        const separatorLength = selected.length > 0 ? 2 : 0;
+        if (used + separatorLength + paragraph.length > budget)
             break;
-        tail.push(entry);
-        remaining -= length;
+        selected.push(paragraph);
+        used += separatorLength + paragraph.length;
     }
-    return [first, ...tail.reverse()];
+    if (selected.length === 0) {
+        return fromEnd ? content.slice(-budget) : content.slice(0, budget);
+    }
+    const result = fromEnd ? selected.reverse() : selected;
+    return result.join('\n\n');
 }
 export class SessionRenewService {
     sessionManager;
@@ -72,14 +145,12 @@ export class SessionRenewService {
     now;
     effectiveConfigResolver;
     eventBus;
-    responseModeRegistry = new ResponseModeRegistry();
     constructor(sessionManager, inferenceProviderResolver, options = {}) {
         this.sessionManager = sessionManager;
         this.inferenceProviderResolver = inferenceProviderResolver;
         this.now = options.now ?? (() => Date.now());
         this.effectiveConfigResolver = options.resolveEffectiveConfig;
         this.eventBus = options.eventBus;
-        registerBuiltinModes(this.responseModeRegistry);
     }
     async resolve(request) {
         const effectiveConfig = this.resolveEffectiveConfig(request);
@@ -107,6 +178,7 @@ export class SessionRenewService {
                         renewed: cached.decision === 'new',
                         decision: cached.decision,
                         source: cached.source,
+                        newProbability: cached.newProbability,
                     };
                 }
             }
@@ -144,47 +216,32 @@ export class SessionRenewService {
         const idleMs = this.now() - last.ts;
         if (idleMs <= afterHours * 60 * 60 * 1000)
             return { session: request.session, renewed: false };
-        let source;
-        let decision = classifyExplicitSessionRenewSignal(request.content);
-        if (decision) {
-            source = 'explicit';
-        }
-        else if (request.replyToMessageId
-            && entries.some(entry => entry.msgId === request.replyToMessageId)) {
-            decision = 'continue';
-            source = 'reply';
+        const threshold = validProbability(config.new_probability_threshold) ?? DEFAULT_NEW_PROBABILITY_THRESHOLD;
+        let decision;
+        let source = 'model';
+        let judgeMetadata = {
+            model: effectiveConfig.decision_model?.model,
+            threshold,
+        };
+        try {
+            const model = effectiveConfig.decision_model?.model?.trim();
+            if (!model)
+                throw new SessionRenewJudgeError('decision_model_missing');
+            const provider = this.inferenceProviderResolver.getDecisionInferenceProvider(request.selfAid);
+            if (!provider)
+                throw new SessionRenewJudgeError('provider_unavailable');
+            const judged = await this.judgeWithModel(request, entries, idleMs, provider, model);
+            const newProbability = judged.newProbability;
+            decision = newProbability >= threshold ? 'new' : 'continue';
+            judgeMetadata = { ...judgeMetadata, newProbability };
         }
-        else {
-            const auxiliary = this.resolveAuxiliaryConfig(effectiveConfig, request.session.baseagent);
-            let judgeMetadata = {
-                responseMode: auxiliary.responseMode,
-                baseagent: request.session.baseagent,
-                model: auxiliary.model,
-                effort: auxiliary.effort,
-            };
-            try {
-                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 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;
-                source = 'model';
-            }
-            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, evaluationStartedAt, judgeMetadata);
+        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, evaluationStartedAt);
+        return await this.finishDecision(routeKey, request, decision, source, idleMs, evaluationStartedAt, judgeMetadata);
     }
     async finishDecision(routeKey, request, decision, source, idleMs, evaluationStartedAt, judge) {
         const selected = decision === 'new'
@@ -200,14 +257,14 @@ export class SessionRenewService {
             selectedSessionId: selected.id,
             decision,
             source,
+            newProbability: judge?.newProbability,
             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)}`
-            + ` responseMode=${judge?.responseMode ?? 'none'}`
-            + ` baseagent=${judge?.baseagent ?? 'none'}`
             + ` model=${judge?.model ?? 'none'}`
-            + ` effort=${judge?.effort ?? 'provider-default'}`
+            + ` newProbability=${judge?.newProbability ?? 'none'}`
+            + ` threshold=${judge?.threshold ?? 'none'}`
             + ` fallbackReason=${judge?.fallbackReason ?? 'none'}`);
         this.eventBus?.publish({
             type: 'session:renew-evaluated',
@@ -221,16 +278,20 @@ export class SessionRenewService {
             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,
+            newProbability: judge?.newProbability,
             fallbackReason: judge?.fallbackReason,
             durationMs: Math.max(0, Date.now() - evaluationStartedAt),
             timestamp: this.now(),
             causation: request.causation,
         });
-        return { session: selected, renewed: decision === 'new', decision, source };
+        return {
+            session: selected,
+            renewed: decision === 'new',
+            decision,
+            source,
+            newProbability: judge?.newProbability,
+        };
     }
     resolveEffectiveConfig(request) {
         if (this.effectiveConfigResolver)
@@ -246,76 +307,38 @@ export class SessionRenewService {
             peerKey,
         }, { cache: true, expand: true });
     }
-    resolveAuxiliaryConfig(config, baseagent) {
-        const canonicalBaseagent = normalizeBaseagent(baseagent).canonical;
-        const baseagentConfig = canonicalBaseagent !== 'unknown'
-            ? config.baseagents?.[canonicalBaseagent]
-            : undefined;
-        const rawBaseagentConfig = baseagentConfig && typeof baseagentConfig === 'object'
-            ? baseagentConfig
-            : undefined;
-        // Auxiliary inference is owned exclusively by the selected baseagent. Old
-        // response-mode bucket values must be migrated before they can take effect.
-        const configuredMode = typeof config.responseMode === 'string' && config.responseMode.trim()
-            ? config.responseMode.trim()
-            : undefined;
-        const responseMode = configuredMode && this.responseModeRegistry.has(configuredMode)
-            ? configuredMode
-            : this.responseModeRegistry.getPreferredId() ?? 'single-session';
-        const rawModel = rawBaseagentConfig?.auxiliaryModel;
-        const rawEffort = rawBaseagentConfig?.auxiliaryEffort;
-        const model = typeof rawModel === 'string' && rawModel.trim()
-            ? rawModel.trim()
-            : undefined;
-        const effort = typeof rawEffort === 'string' && AUXILIARY_EFFORTS.has(rawEffort)
-            ? rawEffort
-            : undefined;
-        return {
-            responseMode,
-            model,
-            effort,
-            invalidEffort: rawEffort !== undefined && effort === undefined,
-        };
-    }
     readConversationEntries(session) {
         const entries = readAllJsonlLines(messageLogPath(this.sessionManager.getChatDir(session)));
         return entries
             .filter(entry => isSessionRenewConversationEntry(entry, session.id))
             .sort((left, right) => left.ts - right.ts);
     }
-    async judgeWithModel(request, entries, idleMs, provider, auxiliary) {
-        const context = selectSessionRenewContext(entries).map(entry => ({
-            dir: entry.dir,
-            content: entry.content.slice(0, MAX_MESSAGE_CHARS),
-            ts: entry.ts,
-            msgType: entry.msgType,
-        }));
-        const prompt = JSON.stringify({
-            old_session_messages: context,
-            new_message: request.content,
-            reply_to_message_id: request.replyToMessageId || null,
-            chat_type: request.chatType,
-            idle_hours: Number((idleMs / 3_600_000).toFixed(2)),
-        });
-        const systemPrompt = [
-            'You are a session continuity classifier.',
-            'Decide whether the new message continues the old conversation or starts an independent conversation.',
-            'Use NEW only when the new intent is clearly independent. When uncertain, choose CONTINUE.',
-            'Do not call tools. Do not explain your reasoning.',
-            'Return exactly one JSON object: {"decision":"continue|new","confidence":0..1,"reason_code":"short_code"}.',
-        ].join('\n');
+    async judgeWithModel(request, entries, idleMs, provider, model) {
+        const prompt = loadSessionRenewPrompt();
+        const state = {
+            content: buildSessionRenewStateContent(request, entries, idleMs),
+        };
+        const questions = {
+            new_session: {
+                type: 'noul',
+                instructions: prompt.questionInstructions,
+                criteria: {
+                    true: prompt.trueCriteria,
+                    false: prompt.falseCriteria,
+                },
+            },
+        };
         const controller = new AbortController();
         let timer;
         try {
             const operation = (async () => {
-                const text = await provider.completeText({
-                    model: auxiliary.model,
-                    ...(auxiliary.effort ? { effort: auxiliary.effort } : {}),
-                    system: systemPrompt,
-                    input: prompt,
+                const text = await provider.completeDecision({
+                    model,
+                    state,
+                    questions,
                     signal: controller.signal,
                 });
-                return { model: auxiliary.model, text };
+                return text;
             })();
             const timeout = new Promise((_resolve, reject) => {
                 timer = setTimeout(() => {
@@ -324,7 +347,7 @@ export class SessionRenewService {
                 }, MODEL_TIMEOUT_MS);
             });
             const result = await Promise.race([operation, timeout]);
-            return { ...parseModelResult(result.text), model: result.model };
+            return parseModelResult(result);
         }
         finally {
             if (timer)
@@ -367,29 +390,68 @@ function sessionRenewFallbackReason(error) {
         return 'timeout';
     if (/HTTP \d+/i.test(message))
         return 'http_error';
-    if (/no JSON|invalid decision|invalid confidence/i.test(message))
+    if (/no JSON|invalid noul|invalid response/i.test(message))
         return 'invalid_response';
-    if (/no text|empty/i.test(message))
+    if (/empty/i.test(message))
         return 'empty_response';
     return 'inference_error';
 }
 function validPositiveNumber(value) {
     return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : undefined;
 }
+function validProbability(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1 ? value : undefined;
+}
+function buildSessionRenewStateContent(request, entries, idleMs) {
+    const title = request.session.name?.trim() || '无标题';
+    const header = [
+        `话题标题：${title}`,
+        `当前聊天类型：${request.chatType}`,
+        `空闲时长：${Number((idleMs / 3_600_000).toFixed(2))} 小时`,
+        `是否回复旧消息：${request.replyToMessageId ? `是，消息 ID=${request.replyToMessageId}` : '否'}`,
+        loadSessionRenewPrompt().stateRules,
+        `当前新消息：${request.content}`,
+        '',
+        '历史会话上下文：',
+    ].join('\n');
+    const selected = selectSessionRenewContext(entries);
+    const historyHeader = `${header}\n`;
+    if (historyHeader.length >= MAX_CONTEXT_CHARS)
+        return historyHeader.slice(0, MAX_CONTEXT_CHARS);
+    const blocks = [];
+    for (const [index, entry] of selected.entries()) {
+        const block = [
+            `历史消息 ${index + 1}（${entry.dir}，${entry.msgType}，${new Date(entry.ts).toISOString()}，消息 ID=${entry.msgId || '无'}）：`,
+            entry.content,
+        ].join('\n');
+        const candidate = blocks.length > 0
+            ? `${blocks.join('\n\n')}\n\n${block}`
+            : block;
+        if (historyHeader.length + candidate.length <= MAX_CONTEXT_CHARS)
+            blocks.push(block);
+    }
+    return `${historyHeader}${blocks.join('\n\n')}`.slice(0, MAX_CONTEXT_CHARS);
+}
 function parseModelResult(text) {
-    const match = text.match(/\{[\s\S]*\}/);
-    if (!match)
-        throw new Error('judge returned no JSON object');
-    const parsed = JSON.parse(match[0]);
-    if (parsed.decision !== 'continue' && parsed.decision !== 'new') {
-        throw new Error('judge returned invalid decision');
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
     }
-    if (typeof parsed.confidence !== 'number' || !Number.isFinite(parsed.confidence) || parsed.confidence < 0 || parsed.confidence > 1) {
-        throw new Error('judge returned invalid confidence');
+    catch {
+        throw new Error('judge returned invalid response JSON');
     }
-    return {
-        decision: parsed.decision,
-        confidence: parsed.confidence,
-        reasonCode: typeof parsed.reason_code === 'string' ? parsed.reason_code : undefined,
-    };
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('judge returned invalid response');
+    }
+    const answer = parsed.answers;
+    const newSession = answer && typeof answer === 'object' && !Array.isArray(answer)
+        ? answer.new_session
+        : undefined;
+    const noul = newSession && typeof newSession === 'object' && !Array.isArray(newSession)
+        ? newSession.noul
+        : undefined;
+    const newProbability = validProbability(noul);
+    if (newProbability === undefined)
+        throw new Error('judge returned invalid noul');
+    return { newProbability };
 }