sema-core 2.0.15 → 2.1.0

package/dist/util/compact.js

@@ -4,6 +4,7 @@ exports.NULL_TOOL = exports.__compactTestHooks = void 0;
 exports.needsAutoCompact = needsAutoCompact;
 exports.applyMicroCompact = applyMicroCompact;
 exports.compactMessages = compactMessages;
+exports.collectSkillActivations = collectSkillActivations;
 exports.autoCompact = autoCompact;
 const tokens_1 = require("./tokens");
 const message_1 = require("./message");
@@ -15,6 +16,9 @@ const microcompact_1 = require("./microcompact");
 const zod_1 = require("zod");
 const tokens_2 = require("./tokens");
 const compact_1 = require("../prompt/compact");
+const genSystemReminder_1 = require("../services/agents/genSystemReminder");
+const tool_1 = require("../prompt/tool");
+const define_1 = require("../prompt/define");
 const defaultCompactDependencies = {
     queryLLM: queryLLM_1.queryLLM,
     getModelManager: ModelManager_1.getModelManager,
@@ -35,6 +39,13 @@ exports.__compactTestHooks = {
  * 提前触发压缩以避免接近token限制时的API调用失败
  */
 const AUTO_COMPACT_THRESHOLD_RATIO = 0.75;
+/**
+ * 自动压缩时原样保留的最近工具轮次数（一个轮次 = assistant(tool_use) + 紧随的 tool_result user 消息）。
+ * 最后一条 assistant 之后的未消费批次另行无条件保留，不计入此数。
+ */
+const COMPACT_KEEP_RECENT_TOOL_ROUNDS = 4;
+// 图片块固定估算，与 microcompact 口径一致（勿按 base64 长度折算）
+const IMAGE_BLOCK_TOKEN_ESTIMATE = 1500;
 function getContextLimit(sessionId) {
     try {
         return compactDependencies.getModelManager().getModel('main', sessionId)?.contextLength ?? 128_000;
@@ -94,8 +105,9 @@ function truncateMessages(messages, targetTokenLimit) {
         if (message.type === 'assistant' && 'usage' in message.message) {
             const inputTokens = getInputTokensFromUsage(message.message.usage);
             if (inputTokens >= tokensToRemove) {
-                // 从下一条消息开始保留
-                cutIndex = i + 1;
+                // 从这条 assistant 开始保留：它的 tool_use 与下一条 user 消息里的 tool_result 配对，
+                // 若从 i + 1 开始会留下孤儿 tool_result，API 会拒绝
+                cutIndex = i;
                 break;
             }
         }
@@ -117,7 +129,7 @@ function truncateMessages(messages, targetTokenLimit) {
     }
     // 在开头添加截断提示消息
     if (result.length < messages.length) {
-        const truncatedMessage = (0, message_1.buildUserMsg)(`Context truncated due to token limit. ${messages.length - result.length} earlier messages removed. Recent conversation preserved.`);
+        const truncatedMessage = (0, message_1.buildUserMsg)(`${compact_1.CONTEXT_TRUNCATED_NOTICE_LEAD} ${messages.length - result.length} earlier messages removed. Recent conversation preserved.`);
         result.unshift(truncatedMessage);
     }
     (0, log_1.logDebug)(`[Compact] Truncation result: kept ${result.length} of ${messages.length} messages`);
@@ -183,18 +195,29 @@ function emitCompactUsage(messagesBefore, messagesAfter, sessionId, mode, reason
     }
 }
 /**
- * 根据令牌使用量判断是否应触发自动压缩
- * 只计算输入token数，因为API调用时主要关心的是输入token限制
+ * 估算当前上下文占用，口径为"即将发送的请求"：
+ * 最近有效 usage 的 input（上次请求的上下文）+ 该次 output（本次响应已进入上下文）
+ * + 该 assistant 之后新增消息（工具结果、新用户输入）的估算。
+ * 只看 input 会滞后一轮，单轮新增多个大工具结果时可能撞限。
+ * 没有任何有效 usage 时（如全是合成消息的历史）按全部消息估算。
+ * 压缩判断与 compact:micro 事件统计共用此函数，保证口径一致。
+ */
+function estimateContextTokens(messages) {
+    const { inputTokens, outputTokens, index } = (0, tokens_1.countTokens)(messages);
+    return inputTokens + outputTokens + estimateMessagesTokens(messages.slice(index + 1));
+}
+/**
+ * 根据令牌使用量判断是否应触发自动压缩（口径见 estimateContextTokens）
  *
- * @param discountTokens 估算折扣：countTokens 读的是上一次 API 响应的 usage，
- * micro 清理的节省要到下一次响应才可见，期间用该折扣修正判断。默认 0，行为与原先一致。
+ * @param discountTokens 估算折扣：usage 读的是上一次 API 响应，
+ * micro 清理的节省要到下一次响应才可见，期间用该折扣修正判断。默认 0。
+ * 传入的 messages 应是清理前的历史，否则 usage 下标之后被清理的块会在估算与折扣中重复扣减。
  */
 function needsAutoCompact(messages, discountTokens = 0, sessionId) {
     if (messages.length < 3)
         return false;
-    const inputTokenCount = (0, tokens_1.countTokens)(messages).inputTokens;
     const autoCompactThreshold = getContextLimit(sessionId) * AUTO_COMPACT_THRESHOLD_RATIO;
-    return (inputTokenCount - discountTokens) >= autoCompactThreshold;
+    return (estimateContextTokens(messages) - discountTokens) >= autoCompactThreshold;
 }
 /**
  * Micro 压缩集成入口（全量摘要前的第一道防线）
@@ -211,10 +234,11 @@ function applyMicroCompact(messages, sessionId) {
         if (!result.changed) {
             return { messages, needFullCompact: true, changed: false };
         }
-        const stillOver = needsAutoCompact(result.messages, result.estimatedSavedTokens, sessionId);
-        // estimatedTokenAfter = 上次 API 响应的真实 usage − 估算节省，与"要不要全量摘要"的判断口径一致；
-        // 清理前的值不重复携带（= 紧邻上一条 conversation:usage 的 promptTokens）
-        const tokenBefore = (0, tokens_1.countTokens)(result.messages).inputTokens;
+        // 在清理前的 messages 上判断再减本次节省：清理后的消息里 usage 下标之后的块已是占位符，
+        // 若在其上估算再减全部节省，这部分会被扣两次而低估占用
+        const stillOver = needsAutoCompact(messages, result.estimatedSavedTokens, sessionId);
+        // estimatedTokenAfter = 清理前的估算占用 − 估算节省，与 stillOver 的判断口径完全一致
+        const tokenBefore = estimateContextTokens(messages);
         const microData = {
             clearedCount: result.clearedCount,
             estimatedSavedTokens: result.estimatedSavedTokens,
@@ -250,17 +274,28 @@ function applyMicroCompact(messages, sessionId) {
  */
 async function compactMessages(messages, abortController, sessionId, options = {}) {
     const allowTruncationFallback = options.allowTruncationFallback ?? true;
+    // 自动压缩路径只压历史的一段，事件口径需按整段上下文计算，由 autoCompact 自行发出
+    const emitUsageEvent = options.emitUsageEvent ?? true;
+    const emitUsage = (messagesAfter, mode, reason, error) => {
+        if (emitUsageEvent)
+            emitCompactUsage(messages, messagesAfter, sessionId, mode, reason, error);
+    };
     if (messages.length < 2) {
         return { kind: 'unchanged', messages };
     }
     try {
         const summaryResult = await executeAutoCompact(messages, abortController, sessionId, options.customInstructions);
+        // 用户中断：适配层不抛错而是返回部分内容，不能当成摘要，也不能进有损的截断兜底
+        if (abortController.signal.aborted) {
+            (0, log_1.logInfo)('[Compact] Aborted by user, keeping messages unchanged');
+            return { kind: 'unchanged', messages };
+        }
         if (summaryResult.kind === 'summary') {
-            emitCompactUsage(messages, summaryResult.messages, sessionId, 'summary');
+            emitUsage(summaryResult.messages, 'summary');
             return summaryResult;
         }
         if (!allowTruncationFallback) {
-            emitCompactUsage(messages, null, sessionId, 'failed', summaryResult.reason);
+            emitUsage(null, 'failed', summaryResult.reason);
             return {
                 kind: 'failed',
                 error: new Error(`Compact did not produce a valid summary: ${summaryResult.reason}`),
@@ -269,7 +304,7 @@ async function compactMessages(messages, abortController, sessionId, options = {
         const contextLimit = getContextLimit(sessionId);
         const targetLimit = contextLimit * 0.5; // 截断到50%容量
         const truncatedMessages = truncateMessages(messages, targetLimit);
-        emitCompactUsage(messages, truncatedMessages, sessionId, 'truncated', summaryResult.reason);
+        emitUsage(truncatedMessages, 'truncated', summaryResult.reason);
         return {
             kind: 'truncated',
             messages: truncatedMessages,
@@ -277,8 +312,13 @@ async function compactMessages(messages, abortController, sessionId, options = {
         };
     }
     catch (error) {
+        // 用户中断（SDK 层抛出中断异常的路径）：同上，直接退出不降级
+        if (abortController.signal.aborted) {
+            (0, log_1.logInfo)('[Compact] Aborted by user, keeping messages unchanged');
+            return { kind: 'unchanged', messages };
+        }
         if (!allowTruncationFallback) {
-            emitCompactUsage(messages, null, sessionId, 'failed', 'COMPACT_ERROR', error);
+            emitUsage(null, 'failed', 'COMPACT_ERROR', error);
             return {
                 kind: 'failed',
                 error,
@@ -291,7 +331,7 @@ async function compactMessages(messages, abortController, sessionId, options = {
             const targetLimit = contextLimit * 0.5; // 截断到50%容量
             const truncatedMessages = truncateMessages(messages, targetLimit);
             (0, log_1.logError)(`Successfully applied truncation fallback, reduced from ${messages.length} to ${truncatedMessages.length} messages`);
-            emitCompactUsage(messages, truncatedMessages, sessionId, 'truncated', 'COMPACT_ERROR', error);
+            emitUsage(truncatedMessages, 'truncated', 'COMPACT_ERROR', error);
             return {
                 kind: 'truncated',
                 messages: truncatedMessages,
@@ -301,7 +341,7 @@ async function compactMessages(messages, abortController, sessionId, options = {
         catch (truncationError) {
             // 如果连截断都失败，返回失败结果
             (0, log_1.logError)(`Truncation fallback also failed: ${truncationError}`);
-            emitCompactUsage(messages, null, sessionId, 'failed', 'COMPACT_ERROR', truncationError);
+            emitUsage(null, 'failed', 'COMPACT_ERROR', truncationError);
             return {
                 kind: 'failed',
                 error: truncationError,
@@ -310,53 +350,355 @@ async function compactMessages(messages, abortController, sessionId, options = {
     }
 }
 /**
- * 自动上下文压缩的主要入口函数
+ * 扫描消息列表中 skill 工具的成功激活：tool_use(skill) 配对非报错 tool_result，
+ * 且同消息内有当时注入的 skill 全文 text 块。同名多次调用取最后一次。
+ * 全文从历史原样取：天然证明激活成功、参数已替换、与模型当时所见一致
+ * （microCompact 只清 tool_result 不碰 text 块，该块必然还在）。
+ */
+function collectSkillActivations(messages) {
+    // tool_use_id -> skill 名
+    const toolUseNames = new Map();
+    for (const msg of messages) {
+        if (msg.type !== 'assistant' || !Array.isArray(msg.message.content))
+            continue;
+        for (const block of msg.message.content) {
+            if (block.type === 'tool_use' && block.name === tool_1.TOOL_NAME_SKILL) {
+                const skillName = block.input?.skill;
+                if (skillName)
+                    toolUseNames.set(block.id, skillName);
+            }
+        }
+    }
+    const byName = new Map();
+    for (const msg of messages) {
+        if (msg.type !== 'user' || !Array.isArray(msg.message.content))
+            continue;
+        const content = msg.message.content;
+        for (let i = 0; i < content.length; i++) {
+            const block = content[i];
+            // 上一次压缩注入的 skill 原文块：解析后接力，保证 skill 上下文可跨多次压缩存续；
+            // 同名后续真实激活按消息序覆盖接力内容
+            if (block.type === 'text' && block.text.startsWith(`${define_1.REMINDER_SYS_OPEN}\n${compact_1.SKILL_CONTEXT_NOTICE}`)) {
+                for (const activation of parseSkillContextBlock(block.text, msg.uuid)) {
+                    byName.set(activation.name, activation);
+                }
+                continue;
+            }
+            if (block.type !== 'tool_result')
+                continue;
+            const name = toolUseNames.get(block.tool_use_id);
+            if (!name || block.is_error === true)
+                continue;
+            // skill 全文（additionalBlocks）紧随 tool_result 之后；
+            // 跳过 reminder-sys 开头的块（注入的用户消息、hook 上下文等非 skill 正文）
+            for (let j = i + 1; j < content.length; j++) {
+                const next = content[j];
+                if (next.type === 'tool_result')
+                    break;
+                if (next.type === 'text' && !next.text.startsWith(define_1.REMINDER_SYS_OPEN)) {
+                    byName.set(name, { name, text: next.text, uuid: msg.uuid });
+                    break;
+                }
+            }
+        }
+    }
+    return [...byName.values()];
+}
+/**
+ * 解析压缩后注入的 skill 原文块（格式见 generatePostCompactReminders 的 sections 拼装），
+ * 还原为激活列表。skill 正文若恰好含 "### Skill: " 行会造成误切分，风险极低且
+ * 伪名称会被后续的存在性过滤剔除。
+ */
+function parseSkillContextBlock(text, uuid) {
+    let body = text;
+    if (body.startsWith(define_1.REMINDER_SYS_OPEN))
+        body = body.slice(define_1.REMINDER_SYS_OPEN.length);
+    if (body.endsWith(define_1.REMINDER_SYS_CLOSE))
+        body = body.slice(0, -define_1.REMINDER_SYS_CLOSE.length);
+    return body.split(/^### Skill: /m).slice(1).map(section => {
+        const newlineIdx = section.indexOf('\n');
+        const name = (newlineIdx === -1 ? section : section.slice(0, newlineIdx)).trim();
+        const skillText = (newlineIdx === -1 ? '' : section.slice(newlineIdx + 1)).trim();
+        return { name, text: skillText, uuid };
+    }).filter(a => a.name && a.text);
+}
+/**
+ * 把 reminder 块插入首条 user 消息（压缩通知/截断通知）的通知文本之前：
+ * 阅读序为 [reminders..., 通知文本, 摘要(assistant)]，通知文本紧邻其引出的摘要。
+ * 首条消息非 user 时原样返回（截断兜底未删任何消息的罕见场景），不做强行注入。
+ */
+function prependBlocksToLeadingUserMsg(messages, blocks) {
+    const first = messages[0];
+    if (!first || first.type !== 'user') {
+        return messages;
+    }
+    const content = first.message.content;
+    const contentBlocks = typeof content === 'string'
+        ? [{ type: 'text', text: content }]
+        : [...content];
+    const nextFirst = {
+        ...first,
+        message: { ...first.message, content: [...blocks, ...contentBlocks] },
+    };
+    return [nextFirst, ...messages.slice(1)];
+}
+/**
+ * 按文本长度估算一组消息的 token 数（口径与 microcompact 一致）。
+ * 用于 compact:exec 事件里被压区与新前缀的差值计算，以及 needsAutoCompact 对
+ * 最近 usage 之后新增消息的估算。
+ */
+function estimateMessagesTokens(messages) {
+    let total = 0;
+    for (const msg of messages) {
+        const content = msg.message.content;
+        if (typeof content === 'string') {
+            total += (0, microcompact_1.estimateTokensFromText)(content);
+            continue;
+        }
+        if (!Array.isArray(content))
+            continue;
+        for (const block of content) {
+            switch (block?.type) {
+                case 'text':
+                    total += (0, microcompact_1.estimateTokensFromText)(block.text ?? '');
+                    break;
+                case 'thinking':
+                    total += (0, microcompact_1.estimateTokensFromText)(block.thinking ?? '');
+                    break;
+                case 'tool_use':
+                    total += (0, microcompact_1.estimateTokensFromText)(JSON.stringify(block.input ?? {}));
+                    break;
+                case 'tool_result': {
+                    const inner = block.content;
+                    if (typeof inner === 'string') {
+                        total += (0, microcompact_1.estimateTokensFromText)(inner);
+                    }
+                    else if (Array.isArray(inner)) {
+                        for (const part of inner) {
+                            if (part?.type === 'text')
+                                total += (0, microcompact_1.estimateTokensFromText)(part.text ?? '');
+                            else if (part?.type === 'image')
+                                total += IMAGE_BLOCK_TOKEN_ESTIMATE;
+                        }
+                    }
+                    break;
+                }
+                case 'image':
+                    total += IMAGE_BLOCK_TOKEN_ESTIMATE;
+                    break;
+            }
+        }
+    }
+    return total;
+}
+/**
+ * 计算自动压缩的切点：messages.slice(0, cutIdx) 为被压区，其余为保留区。
  *
- * 该函数在每次查询前被调用，用于检查对话是否已超出容量需要压缩。
- * 找到最后一条真实用户消息（非 tool_result），只压缩它之前的历史，
- * 保留"当前对话轮次"（lastRealUserMsg + assistantMsg + toolResults）不动。
- * 这样可以保证：
- * 1. 压缩后的消息列表以用户消息结尾，LLM 调用不会失败
- * 2. tool_use / tool_result 的配对关系不被破坏
+ * 切点只落在两类位置，二者都保证 tool_use/tool_result 不被拆散，
+ * 也保证 skill 激活的 tool_use 与其 tool_result/全文块在同一侧（collectSkillActivations 按区域配对）：
+ * - 某个工具轮次的 assistant 消息：保留最后一条 assistant 起的未消费尾部，
+ *   再往前保留 COMPACT_KEEP_RECENT_TOOL_ROUNDS 个已消费轮次，切在最老一个保留轮次的 assistant 上；
+ * - 最后一条真实用户消息：它落在保留窗口内或紧贴切点时（本轮很短、或最新消息就是新查询），
+ *   切到它，用户原话原样保留，等价于旧行为。
  *
- * 执行自动压缩（调用前应先通过 needsAutoCompact 判断是否需要压缩）
+ * 旧行为整轮豁免：agent 单轮跑几十次工具时可压区几乎为空，再触发只能对上一份摘要复摘，
+ * 摘要越压越大而真实上下文单调增长。
  */
-async function autoCompact(messages, abortController, sessionId) {
-    // 从后往前找最后一条真实用户消息（非 tool_result）的索引
+function findCompactCut(messages) {
+    // 从后往前找最后一条真实用户消息（首块非 tool_result）
     let lastRealUserIdx = -1;
     for (let i = messages.length - 1; i >= 0; i--) {
-        if (messages[i].type === 'user') {
-            const content = messages[i].message.content;
-            const isToolResult = Array.isArray(content) &&
-                content.length > 0 &&
-                content[0]?.type === 'tool_result';
-            if (!isToolResult) {
-                lastRealUserIdx = i;
-                break;
+        if (messages[i].type !== 'user')
+            continue;
+        const content = messages[i].message.content;
+        const isToolResult = Array.isArray(content) &&
+            content.length > 0 &&
+            content[0]?.type === 'tool_result';
+        if (!isToolResult) {
+            lastRealUserIdx = i;
+            break;
+        }
+    }
+    if (lastRealUserIdx === -1) {
+        return { cutIdx: 0, lastRealUserIdx };
+    }
+    let lastAssistantIdx = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].type === 'assistant') {
+            lastAssistantIdx = i;
+            break;
+        }
+    }
+    // 未消费尾部（最后一条 assistant 起）无条件保留，再往前数 N 个 assistant 轮次
+    let cutIdx = lastAssistantIdx;
+    if (lastAssistantIdx > 0) {
+        let rounds = 0;
+        for (let i = lastAssistantIdx - 1; i >= 0 && rounds < COMPACT_KEEP_RECENT_TOOL_ROUNDS; i--) {
+            if (messages[i].type === 'assistant') {
+                rounds++;
+                cutIdx = i;
+            }
+        }
+    }
+    // 没有 assistant，或最后一条真实用户消息落在保留窗口内/紧贴切点：切到用户消息
+    if (lastAssistantIdx === -1 || lastRealUserIdx >= cutIdx - 1) {
+        cutIdx = lastRealUserIdx;
+    }
+    return { cutIdx, lastRealUserIdx };
+}
+// 回注用户指令原文的上限：超长粘贴不应抵消压缩收益
+const MAX_VERBATIM_INSTRUCTION_CHARS = 4000;
+/**
+ * 系统合成的 user 文本块，不是用户原话，不得当作指令回注：
+ * reminder-sys 注入、压缩摘要、截断通知、中断标记
+ */
+function isSyntheticUserText(text) {
+    return text.startsWith(define_1.REMINDER_SYS_OPEN) ||
+        text.startsWith(compact_1.COMPACT_SUMMARY_LEAD) ||
+        text.startsWith(compact_1.CONTEXT_TRUNCATED_NOTICE_LEAD) ||
+        text.trim() === message_1.REQ_INTERRUPT_MSG;
+}
+/**
+ * 提取真实用户消息的正文（跳过系统合成块与非文本块），用于压缩后原样回注。
+ * 被压区开头若是上一次压缩的前缀消息，其中回注过的指令块（LATEST_USER_INSTRUCTION_NOTICE 起始）
+ * 原样接力，保证用户指令可跨多次压缩存续；摘要块本身跳过，避免摘要被当作指令滚雪球。
+ */
+function extractUserInstructionText(msg) {
+    const content = msg.message.content;
+    let text = '';
+    if (typeof content === 'string') {
+        text = isSyntheticUserText(content) ? '' : content.trim();
+    }
+    else if (Array.isArray(content)) {
+        const parts = [];
+        for (const block of content) {
+            if (block.type !== 'text')
+                continue;
+            if (block.text.startsWith(compact_1.LATEST_USER_INSTRUCTION_NOTICE)) {
+                // 上一次压缩回注的指令块：直接接力，不再拼接其他块
+                return block.text.slice(compact_1.LATEST_USER_INSTRUCTION_NOTICE.length).trim();
             }
+            if (isSyntheticUserText(block.text))
+                continue;
+            const trimmed = block.text.trim();
+            if (trimmed)
+                parts.push(trimmed);
         }
+        text = parts.join('\n\n');
+    }
+    if (text.length > MAX_VERBATIM_INSTRUCTION_CHARS) {
+        text = `${text.slice(0, MAX_VERBATIM_INSTRUCTION_CHARS)}\n[... truncated]`;
     }
+    return text;
+}
+/**
+ * 自动压缩路径的 compact:exec / conversation:usage 事件。
+ * 被压区只是整段上下文的一段，事件按整段口径计算：
+ * tokenBefore = 触发时的整段占用（含 system prompt 与工具定义，取自上次 API 响应的 usage），
+ * tokenCompact = tokenBefore − 被压区估算 + 新前缀估算。
+ */
+function emitAutoCompactUsage(tokenBefore, messagesToCompact, compactedMessages, sessionId, mode, reason) {
+    try {
+        const removed = estimateMessagesTokens(messagesToCompact);
+        const added = estimateMessagesTokens(compactedMessages);
+        const tokenCompact = Math.max(0, tokenBefore - removed + added);
+        if (added >= removed) {
+            (0, log_1.logWarn)(`[Compact] Compacted prefix (~${added} tokens) is not smaller than the compacted range (~${removed} tokens)`);
+        }
+        (0, log_1.logDebug)(`[Compact] Usage: before=${tokenBefore}, removed≈${removed}, added≈${added}, after≈${tokenCompact}`);
+        const compactExecData = {
+            tokenBefore,
+            tokenCompact,
+            compactRate: tokenBefore > 0 ? calculateCompactRate(tokenBefore, tokenCompact) : 0,
+            mode,
+            reason,
+        };
+        const eventBus = compactDependencies.getEventBus();
+        eventBus.emit('compact:exec', compactExecData, sessionId);
+        eventBus.emit('conversation:usage', {
+            usage: { useTokens: tokenCompact, maxTokens: getContextLimit(sessionId), promptTokens: tokenCompact },
+        }, sessionId);
+    }
+    catch (usageError) {
+        (0, log_1.logError)(`Failed to emit auto compact usage: ${usageError}`);
+    }
+}
+/**
+ * 自动上下文压缩的主要入口函数
+ *
+ * 该函数在每次查询前被调用，用于检查对话是否已超出容量需要压缩。
+ * 切点由 findCompactCut 决定：保留最近几个工具轮次与未消费尾部，其余历史（含本轮更早的工具轮次）
+ * 交给摘要。这样可以保证：
+ * 1. tool_use / tool_result 的配对关系不被破坏（切点只落在轮次边界的 assistant 或真实用户消息上）
+ * 2. 压缩后前缀是单条 user 消息（与手动 /compact 同形），保留区无论以 user 还是 assistant 开头，
+ *    角色交替都合法（连续 user 由 prepareMessagesForApi 合并）
+ * 3. 最后一条真实用户消息被压进摘要时，原文回注，模型不丢失用户措辞
+ *
+ * 执行自动压缩（调用前应先通过 needsAutoCompact 判断是否需要压缩）
+ */
+async function autoCompact(messages, abortController, sessionId, options = {}) {
+    const { cutIdx, lastRealUserIdx } = findCompactCut(messages);
     if (lastRealUserIdx === -1) {
         // 没有找到真实用户消息，跳过压缩
         return { changed: false, messages };
     }
-    // 只压缩最后一条真实用户消息之前的历史
-    const messagesToCompact = messages.slice(0, lastRealUserIdx);
-    // 保留当前对话轮次（最后一条真实用户消息及之后的所有内容）
-    const messagesToKeep = messages.slice(lastRealUserIdx);
+    const messagesToCompact = messages.slice(0, cutIdx);
+    const messagesToKeep = messages.slice(cutIdx);
     if (messagesToCompact.length < 2) {
         // 历史消息太少，不值得压缩
         return { changed: false, messages };
     }
-    const compactResult = await compactMessages(messagesToCompact, abortController, sessionId);
+    // 最后一条真实用户消息落入被压区（长工具轮次场景）：压缩后原样回注
+    const compactedUserMsg = lastRealUserIdx < cutIdx ? messages[lastRealUserIdx] : null;
+    // 收集将被压掉的 skill 激活；保留区仍有同名激活的不补（原文还在）
+    let compactedSkills = collectSkillActivations(messagesToCompact);
+    if (compactedSkills.length > 0) {
+        const keptNames = new Set(collectSkillActivations(messagesToKeep).map(a => a.name));
+        compactedSkills = compactedSkills.filter(a => !keptNames.has(a.name));
+    }
+    (0, log_1.logDebug)(`[Compact] Cut at ${cutIdx}/${messages.length} (lastRealUser=${lastRealUserIdx}, userMsgCompacted=${compactedUserMsg !== null}), ` +
+        `skills to re-inject: [${compactedSkills.map(a => a.name).join(', ')}]`);
+    // 触发时的整段上下文占用（上次 API 响应的 usage，含本次响应输出），作为事件基准
+    const tokensBefore = (0, tokens_1.countTokens)(messages);
+    const tokenBefore = tokensBefore.inputTokens + tokensBefore.outputTokens;
+    const compactResult = await compactMessages(messagesToCompact, abortController, sessionId, { emitUsageEvent: false });
     if (compactResult.kind === 'summary' || compactResult.kind === 'truncated') {
-        // 组合结果示例（工具调用场景）：
-        //   [compactNotice(user), summaryMsg(assistant), lastRealUserMsg(user), assistantMsg(assistant), toolResult(user)]
-        // 组合结果示例（新查询场景）：
-        //   [compactNotice(user), summaryMsg(assistant), newUserQuery(user)]
-        // 两种场景均以 user 消息结尾，API 调用合法
-        const finalMessages = [...compactResult.messages, ...messagesToKeep];
-        (0, log_1.logDebug)(`[Compact] Final messages count: ${finalMessages.length}, kept current turn: ${messagesToKeep.length} messages`);
+        // 截断兜底会保留部分历史：激活消息 / 用户消息幸存的不补注，避免重复
+        let userMsgSurvived = false;
+        if (compactResult.kind === 'truncated') {
+            const survivedUuids = new Set(compactResult.messages.map(m => m.uuid));
+            compactedSkills = compactedSkills.filter(a => !survivedUuids.has(a.uuid));
+            userMsgSurvived = compactedUserMsg !== null && survivedUuids.has(compactedUserMsg.uuid);
+        }
+        // 压缩后重新注入被压掉的 skill 原文与 skills/rules reminder（原注入随历史被摘要替换而丢失）
+        const reminders = await (0, genSystemReminder_1.generatePostCompactReminders)(options.hasSkillTool ?? false, compactedSkills);
+        const instruction = compactedUserMsg && !userMsgSurvived ? extractUserInstructionText(compactedUserMsg) : '';
+        const instructionBlocks = instruction
+            ? [{ type: 'text', text: `${compact_1.LATEST_USER_INSTRUCTION_NOTICE}\n\n${instruction}` }]
+            : [];
+        let compactedMessages;
+        if (compactResult.kind === 'summary') {
+            // 单条 user 前缀：[reminders..., 包装后的摘要, 用户指令原文]
+            compactedMessages = [(0, message_1.buildUserMsg)([
+                    ...reminders,
+                    { type: 'text', text: (0, compact_1.wrapCompactSummary)(compactResult.summary) },
+                    ...instructionBlocks,
+                ])];
+        }
+        else {
+            // 截断兜底：前置拼进首条截断通知 user 消息，不新增消息
+            const extraBlocks = [...reminders, ...instructionBlocks];
+            compactedMessages = extraBlocks.length > 0
+                ? prependBlocksToLeadingUserMsg(compactResult.messages, extraBlocks)
+                : compactResult.messages;
+        }
+        // 组合结果示例（长工具轮次场景）：
+        //   [prefix(user), assistant(tool_use), toolResult(user), ..., assistant(tool_use), toolResult(user)]
+        // 组合结果示例（短轮次 / 新查询场景）：
+        //   [prefix(user), lastRealUserMsg(user), ...]  → 连续 user 由 prepareMessagesForApi 合并
+        const finalMessages = [...compactedMessages, ...messagesToKeep];
+        (0, log_1.logDebug)(`[Compact] Final messages count: ${finalMessages.length}, kept: ${messagesToKeep.length} messages`);
+        emitAutoCompactUsage(tokenBefore, messagesToCompact, compactedMessages, sessionId, compactResult.kind, compactResult.kind === 'truncated' ? compactResult.reason : undefined);
         return {
             changed: true,
             messages: finalMessages,
@@ -398,12 +740,13 @@ exports.NULL_TOOL = {
 async function executeAutoCompact(messages, abortController, sessionId, customInstructions) {
     // 使用 null tool 作为占位，避免模型调用任何工具
     const tools = [exports.NULL_TOOL];
-    // 将压缩指令作为 user message 追加到要压缩的历史对话后
-    // 无自定义指示时 buildCompressionPrompt 返回 COMPRESSION_PROMPT 原文，自动压缩路径行为不变
-    const messagesWithPrompt = [
-        ...(0, message_1.prepareMessagesForApi)([...messages]),
+    // 将压缩指令作为 user message 追加到要压缩的历史对话后，再统一规范化：
+    // 被压区可能以 user(tool_result) 结尾（自动压缩切在轮次边界），规范化会把连续 user 合并
+    // 无自定义指示时 buildCompressionPrompt 返回 COMPRESSION_PROMPT 原文
+    const messagesWithPrompt = (0, message_1.prepareMessagesForApi)([
+        ...messages,
         (0, message_1.buildUserMsg)((0, compact_1.buildCompressionPrompt)(customInstructions))
-    ];
+    ]);
     const summaryResponse = await compactDependencies.queryLLM(messagesWithPrompt, [
         {
             type: 'text',
@@ -432,10 +775,10 @@ async function executeAutoCompact(messages, abortController, sessionId, customIn
     // 注意：新用户消息的添加由 checkAutoCompact 统一处理，这里不需要处理
     // 重要：summaryResponse 的 usage 包含了整个压缩过程的 token 数（历史对话 + 压缩指令）
     // 需要修正为压缩后消息的实际 token 数（压缩通知 + 摘要）
-    const compactNoticeMessage = (0, message_1.buildUserMsg)(`[Context Compression Notice]
-The conversation has been automatically compressed due to token limit. Below is a comprehensive summary.`);
+    const compactNoticeMessage = (0, message_1.buildUserMsg)(compact_1.COMPACT_RESUME_NOTICE);
     // 修正 usage：压缩后的实际 token 数应该是压缩通知 + 摘要内容
-    // 估算：压缩通知约 30 tokens，摘要使用 completion_tokens
+    // 估算：压缩通知约 30 tokens，摘要使用 completion_tokens。
+    // countTokens 把 input + output 作为"该点的上下文占用"，摘要只计入 input，output 置 0 避免双计
     const originalUsage = summaryResponse.message.usage;
     const estimatedNoticeTokens = 30;
     const summaryTokens = originalUsage.completion_tokens || originalUsage.output_tokens || 0;
@@ -451,15 +794,14 @@ The conversation has been automatically compressed due to token limit. Below is
                 ...originalUsage,
                 // 修正 input_tokens：压缩通知 + 摘要内容
                 input_tokens: correctedInputTokens,
-                // 修正 output_tokens：摘要内容
-                output_tokens: summaryTokens,
+                output_tokens: 0,
                 // 如果是 OpenAI 格式，也要修正
                 prompt_tokens: correctedInputTokens,
-                completion_tokens: summaryTokens,
+                completion_tokens: 0,
             }
         }
     };
-    (0, log_1.logDebug)(`[Compact] Corrected summary usage: originalInput=${originalInputTokens}, originalOutput=${originalOutputTokens}, correctedInput=${correctedInputTokens}, correctedOutput=${summaryTokens}`);
+    (0, log_1.logDebug)(`[Compact] Corrected summary usage: originalInput=${originalInputTokens}, originalOutput=${originalOutputTokens}, correctedInput=${correctedInputTokens}, correctedOutput=0`);
     // 构建压缩后的消息列表（只包含压缩通知和摘要，不包含新用户消息）
     const compactedMessages = [compactNoticeMessage, correctedSummaryMessage];
     return {