mocode-ai 1.2.7 → 1.2.9

package/dist/session/compact.js

@@ -1,6 +1,6 @@
 import { chat, chatTools, correctTokenEstimate, estimatePromptTokens, estimateTokens, } from '../llm/index.js';
 import { config } from '../config/index.js';
-import { MAX_HISTORY_RESULT, MAX_MEMORY_RESULT, MAX_OLD_TOOL_STUB, MAX_SKILL_RESULT } from '../tools/constants.js';
+import { MAX_HISTORY_RESULT, MAX_MEMORY_RESULT, MAX_OLD_TOOL_STUB, MAX_SKILL_RESULT, SUMMARY_KEYFACTS_MAX_CHARS, SUMMARY_KEYFACTS_MIN_CHARS, SUMMARY_KEYFACTS_WINDOW_RATIO, SUMMARY_MSG_MAX_CHARS, SUMMARY_OUTPUT_MAX_CHARS, SUMMARY_TRANSCRIPT_WINDOW_RATIO, } from '../tools/constants.js';
 import { ui } from '../ui/theme.js';
 import { Spinner } from '../ui/spinner.js';
 import * as layout from '../ui/layout.js';
@@ -8,6 +8,7 @@ import { pruneAfterCompaction } from '../rollback/index.js';
 import { toText } from '../context/utils.js';
 import { DEFAULT_BUDGET_POLICY } from '../context/budget.js';
 import { collectArtifactRefs } from '../context/artifacts.js';
+import { writeCompactionSnapshot } from './notes.js';
 export function createContextState() {
     return { lastEstimate: 0, correction: 1, calibrationSamples: 0 };
 }
@@ -130,6 +131,155 @@ export function stripImagesForSummary(m) {
     }
     return m;
 }
+// ── 摘要钉住:Key Facts 跨代累积,叙述段照常滚动压缩 ──────────────────────
+//
+// 为什么需要:摘要写在 history[1](role:'system'),而 groupFromEnd 只排除 history[0],
+// 于是它被当成普通 group 排到最老位置 → 下次压缩进 oldGroups → 被喂给摘要器再摘要一遍。
+// 每代压缩都对上一代摘要做一次有损再压缩,首轮的用户约束经 2-3 代即糊掉。堵住这个衰减
+// 源比设计任何打分模型都划算。
+//
+// 为什么只钉 Key Facts:钉整段(含 Objective/Completed/Next Steps)会线性膨胀——那些
+// 叙述重跑一遍命令、重读一次文件就能拿回来;Key Facts 才是不在就真没了的东西(路径、
+// 约束、失败结论),且每代只增加几十字符。
+/** 摘要消息头。budget.ts 用同一前缀识别摘要层,勿改。 */
+export const SUMMARY_MARKER = '# 会话摘要';
+/** `## Key Facts` 段标题(model 按 prompt 输出,可能带 "— 说明" 后缀)。 */
+const KEY_FACTS_HEADING_RE = /^ {0,3}##\s*key facts\b/i;
+/** 任意 `## ` 级标题:Key Facts 段到此为止。 */
+const ANY_HEADING_RE = /^ {0,3}##\s+\S/;
+/** 上一代叙述段进 transcript 时的标注:告诉摘要器这是已压过一遍的内容,合并而非抄录。 */
+const PRIOR_NARRATIVE_LABEL = '[prior summary — 上一代摘要的叙述部分:与下方新内容合并压缩,不要重复罗列细节]';
+/** 尾部 provenance 块:解析时剥掉,重建时按当次 older 重算(否则跨代累积并重复)。 */
+const ARTIFACT_REFS_RE = /\n*\[artifact refs:[^\]]*\]\s*$/;
+/** Key Facts 累计预算(字符):窗口比例换算 + 上下限——小窗口留得住初始约束,
+ *  大窗口也不会让索引段膨胀成正文。 */
+export function keyFactsBudgetChars(window) {
+    const byWindow = Math.floor(Math.max(0, window) * SUMMARY_KEYFACTS_WINDOW_RATIO);
+    return Math.max(SUMMARY_KEYFACTS_MIN_CHARS, Math.min(SUMMARY_KEYFACTS_MAX_CHARS, byWindow));
+}
+/**
+ * 拆摘要成「Key Facts 段」+「叙述段」。
+ * 顺带剥掉 `# 会话摘要` 头与尾部 `[artifact refs: …]` provenance——后者每次压缩按当次
+ * older 重算,不该跨代累积。无 Key Facts 段时 rest 为全文、keyFacts 为空。
+ */
+export function splitSummaryText(raw) {
+    let text = (raw ?? '').replace(ARTIFACT_REFS_RE, '').trim();
+    if (text.startsWith(SUMMARY_MARKER)) {
+        const nl = text.indexOf('\n');
+        text = (nl < 0 ? '' : text.slice(nl + 1)).trim();
+    }
+    const lines = text.split('\n');
+    const headIdx = lines.findIndex((l) => KEY_FACTS_HEADING_RE.test(l));
+    if (headIdx < 0)
+        return { keyFacts: '', rest: text };
+    let endIdx = lines.length;
+    for (let i = headIdx + 1; i < lines.length; i++) {
+        if (ANY_HEADING_RE.test(lines[i])) {
+            endIdx = i;
+            break;
+        }
+    }
+    const keyFacts = lines.slice(headIdx + 1, endIdx).join('\n').trim();
+    const rest = [...lines.slice(0, headIdx), ...lines.slice(endIdx)].join('\n').trim();
+    return { keyFacts, rest };
+}
+/**
+ * 中断判定:signal 已 abort,或错误本身是 AbortError / APIUserAbortError。
+ * 与 llm 层、core 层的判定保持同一套(两处 name + signal 双判),避免各写各的漏判。
+ */
+function isAbortError(err, signal) {
+    if (signal?.aborted)
+        return true;
+    // 鸭子类型判定而非 instanceof Error:DOMException / SDK 的 APIUserAbortError 在
+    // 不同 Node 版本下 instanceof Error 的结果不一致,认 name 更稳。
+    if (!err || typeof err !== 'object')
+        return false;
+    const name = err.name;
+    return name === 'AbortError' || name === 'APIUserAbortError';
+}
+/** 归一化一行事实用于去重:去项目符号/空白/句末标点后小写。 */
+function factKey(line) {
+    return line
+        .toLowerCase()
+        .replace(/\s+/g, ' ')
+        .replace(/^[-*•]\s*/, '')
+        .replace(/[。.,;；:：]+$/, '')
+        .trim();
+}
+/**
+ * 从摘要正文提取「当前进度快照」段:Objective / In Progress / Next Steps。
+ * 这是压缩后最该被记住的「做到哪了」,固结到 notes.md 供恢复步骤注入。
+ * 只识别 `## ` 级标题(摘要器固定输出此结构);一个都没有时返 null(不写空快照)。
+ */
+export function extractProgressSnapshot(summaryRest) {
+    const WANT = new Set(['objective', 'in progress', 'next steps']);
+    const lines = summaryRest.split('\n');
+    const out = [];
+    let taking = false;
+    for (const line of lines) {
+        const m = line.match(/^ {0,3}##\s+(.+?)\s*$/);
+        if (m) {
+            const name = m[1].replace(/\s*[—–-].*$/, '').trim().toLowerCase();
+            taking = WANT.has(name);
+        }
+        if (taking)
+            out.push(line);
+    }
+    const text = out.join('\n').trim();
+    return text ? text : null;
+}
+/**
+ * 合并跨代 Key Facts:按行去重(老 → 新),超预算时丢较新条目。
+ *
+ * 丢新不丢旧的理由:最老那几条通常是首轮用户约束(不可重建,丢了就永远没了);
+ * 较新的事实通常在本代叙述段或保留区里还有副本。
+ */
+export function mergeKeyFacts(prev, next, maxChars) {
+    const lines = [];
+    const seen = new Set();
+    for (const block of [prev ?? '', next ?? '']) {
+        for (const rawLine of block.split('\n')) {
+            const line = rawLine.trim();
+            if (!line)
+                continue;
+            const key = factKey(line);
+            if (!key || seen.has(key))
+                continue;
+            seen.add(key);
+            lines.push(line);
+        }
+    }
+    const cap = Math.max(0, Math.floor(maxChars));
+    const text = lines.join('\n');
+    if (text.length <= cap)
+        return text;
+    const kept = [];
+    let len = 0;
+    for (const line of lines) {
+        if (len + line.length + 1 > cap)
+            break;
+        kept.push(line);
+        len += line.length + 1;
+    }
+    return `${kept.join('\n')}\n…[Key Facts 超预算,已省略较新条目]`;
+}
+/**
+ * 非空 user group 判定。LLM API(OpenAI / Anthropic)要求 messages 至少含一条**非空**
+ * user 消息,llm/chatOnce 入口有 hasNonEmptyUser 守卫,缺则直接抛。压缩重建 history 后
+ * 必须仍有这样一条,否则下一步 chat() 当场失败——见下方 user 保留兜底。
+ */
+function isUserGroup(g) {
+    const a = g.assistant;
+    return !!a && a.role === 'user' && toText(a.content).trim().length > 0;
+}
+/** 摘要 group 判定:非 history[0] 的 system 消息,以 `# 会话摘要` 开头,且不带 tool_calls。 */
+function isSummaryGroup(g) {
+    const a = g.assistant;
+    return (!!a &&
+        a.role === 'system' &&
+        g.tools.length === 0 &&
+        toText(a.content).startsWith(SUMMARY_MARKER));
+}
 /** 从尾向头划分 group;history[0](system)排除。连续 tool 归到前导 assistant。 */
 function groupFromEnd(history) {
     const groups = [];
@@ -221,45 +371,112 @@ function microcompactGroup(g) {
     return done;
 }
 // ── 默认摘要器:复用 chat(),空 handlers 不打印 ──────────────────────────
-async function defaultSummarize(older, focus) {
-    // 摘要前剥离多模态 user 消息里的图片(base64 会撑爆摘要 prompt;image 对摘要无信息量)。
-    const stripped = older.map(stripImagesForSummary);
-    let transcript = stripped
+/** 单条消息封顶:中间段省略、保头 + 尾(头有路径/意图,尾有结论/报错),总长 ≤ max。 */
+function capMessageText(text, max) {
+    if (text.length <= max)
+        return text;
+    const removed = text.length - max;
+    const marker = `\n…[中间 ${removed} 字符已省略]…\n`;
+    let remain = max - marker.length;
+    if (remain <= 0)
+        return text.slice(0, Math.max(0, max)) + marker;
+    const head = Math.ceil(remain * 0.6);
+    return text.slice(0, head) + marker + text.slice(text.length - (remain - head));
+}
+/** tool_call 参数封顶:只保头(路径/目标等关键信息在开头,长正文对摘要无信息量)。 */
+function capArgsHead(args, max) {
+    if (args.length <= max)
+        return args;
+    return args.slice(0, max) + ` …[另有 ${args.length - max} 字符已省略]`;
+}
+/** 摘要输出硬上限:按最后换行处裁断(不留半句),防模型不听话产出巨长摘要撑大 history。 */
+function capSummaryOutput(summary) {
+    if (summary.length <= SUMMARY_OUTPUT_MAX_CHARS)
+        return summary;
+    const cut = summary.lastIndexOf('\n', SUMMARY_OUTPUT_MAX_CHARS);
+    const at = cut > SUMMARY_OUTPUT_MAX_CHARS * 0.5 ? cut : SUMMARY_OUTPUT_MAX_CHARS;
+    return summary.slice(0, at) + '\n[摘要输出超长,已截断]';
+}
+/** 按封顶配额拼转录。scale ∈ (0,1] 等比缩小各角色配额(总预算不足时用)。 */
+function buildTranscript(stripped, scale) {
+    const caps = SUMMARY_MSG_MAX_CHARS;
+    const capFor = (role) => Math.max(200, Math.floor(scale *
+        (role === 'user'
+            ? caps.user
+            : role === 'assistant'
+                ? caps.assistant
+                : role === 'tool'
+                    ? caps.tool
+                    : caps.other)));
+    return stripped
         .map((m) => {
-        const role = m.role;
-        let line = `${role}: ${toText(m.content)}`;
+        const cap = capFor(m.role);
+        let line = `${m.role}: ${capMessageText(toText(m.content), cap)}`;
         const tcs = m.tool_calls;
         if (tcs) {
             for (const tc of tcs) {
-                line += `\n  [tool_call ${tc?.function?.name}] ${tc?.function?.arguments ?? ''}`;
+                const args = tc?.function?.arguments ?? '';
+                line += `\n  [tool_call ${tc?.function?.name}] ${capArgsHead(args, Math.max(200, Math.floor(scale * caps.tool)))}`;
             }
         }
         return line;
     })
         .join('\n');
-    // 防摘要提示本身溢出:超 60% 窗口就先中截到 50%
-    if (estimateTokens(transcript) >
-        Math.floor(config.contextWindowTokens * 0.6)) {
-        transcript = truncateMid(transcript, Math.floor(config.contextWindowTokens * 0.5));
+}
+async function defaultSummarize(older, focus, signal) {
+    // 已中断就别白拼转录了(几千 token 的字符串拼接 + 一去不回的 LLM 请求)。
+    if (signal?.aborted) {
+        throw new DOMException('This operation was aborted', 'AbortError');
+    }
+    // 摘要前剥离多模态 user 消息里的图片(base64 会撑爆摘要 prompt;image 对摘要无信息量)。
+    const stripped = older.map(stripImagesForSummary);
+    // 触发压缩时旧区约占窗口 50-60%,摘要器共享同一窗口——逐条封顶后旧区原文即可装入,
+    // 不需要"先压一遍再摘要"。封顶策略:先按满额封顶;总量仍超窗口 55% 预算时等比缩小
+    // 配额重拼(优先保条数/每轮都有代表,其次保单条长度);再超才整段中截兜底(罕见)。
+    let transcript = buildTranscript(stripped, 1);
+    const tokenBudget = Math.floor(config.contextWindowTokens * SUMMARY_TRANSCRIPT_WINDOW_RATIO);
+    let tokens = estimateTokens(transcript);
+    if (tokens > tokenBudget) {
+        transcript = buildTranscript(stripped, tokenBudget / tokens);
+        tokens = estimateTokens(transcript);
+        if (tokens > Math.floor(config.contextWindowTokens * 0.6)) {
+            transcript = truncateMid(transcript, Math.floor(config.contextWindowTokens * 0.5));
+        }
     }
     const sysMsg = {
         role: 'system',
-        content: 'You are a session summarizer. Output only the summary body, max 300 words, preserving: the user\'s core request; files read/written/modified and key changes; source artifact IDs/hashes; key commands run and their result highlights; decisions made; current task progress and next step; open questions. Do not recap every detail.',
+        content: 'You are an aggressive session compressor writing a handoff note for an agent that lost its context. ' +
+            'The agent will continue the task with ONLY your summary plus a few most-recent messages, so your summary is the sole memory of everything older.\n' +
+            'Output ONLY the summary body in this exact structure (omit empty sections):\n' +
+            '## Objective — the user\'s core request(s); cover EVERY distinct user request in the transcript, in order, noting which are completed vs pending.\n' +
+            '## Completed — what is already done: files created/modified (exact paths), key change per file, commands run and their outcomes (pass/fail, key numbers), decisions made and why.\n' +
+            '## In Progress — what is being worked on right now and exactly where it stopped (e.g. "edit applied to foo.ts, test not yet run").\n' +
+            '## Next Steps — the concrete next actions in order.\n' +
+            '## Key Facts — only what later steps cannot work without: exact paths, symbols/API shapes, artifact IDs/hashes, constraints, open questions, failed approaches and errors to avoid repeating.\n' +
+            'What counts as important (keep): user requests and constraints; final state of each modified file; conclusions and results, not the steps that led there; decisions with reasons; precise references (paths, symbols, hashes, commands) that later steps must cite; failures and what was tried, so mistakes are not repeated.\n' +
+            'What to drop: verbatim file contents and tool-output dumps, step-by-step recaps, exploration dead-ends that led nowhere, polite chatter, anything re-derivable by re-reading files.\n' +
+            'Rules: total ≤ 400 words. State conclusions and locations (path:line where useful), never paste content. ' +
+            'The Key Facts section is carried forward verbatim into future summaries: write each fact as one self-contained line ' +
+            '(no pronouns, no "as above", no cross-references), so it still reads correctly after later compactions. ' +
+            'Never invent facts, paths, or results that are not in the transcript; if unsure whether something happened, omit it.',
     };
     const userMsg = {
         role: 'user',
         content: focus
-            ? `请将以下会话历史压缩成摘要,重点保留与「${focus}」相关的事实/决策/文件改动:\n\n${transcript}\n\n摘要:`
-            : `请将以下会话历史压缩成摘要:\n\n${transcript}\n\n摘要:`,
+            ? `请将以下会话历史压缩成交接摘要,重点保留与「${focus}」相关的事实/决策/文件改动:\n\n${transcript}\n\n摘要:`
+            : `请将以下会话历史压缩成交接摘要:\n\n${transcript}\n\n摘要:`,
     };
     const spinner = new Spinner((msg, frame) => layout.setStatus(msg, frame ?? undefined));
-    spinner.start('压缩中');
+    spinner.start(signal ? '压缩中(Ctrl+C 取消)' : '压缩中');
     try {
-        const r = await chat([sysMsg, userMsg], {}); // 空 handlers:不打印、不外显流式
+        // signal 必须透传:摘要是几十秒的 LLM 调用,不串进来 Ctrl+C 只能干等它跑完。
+        // 空 handlers:不打印、不外显流式;tools=[] 不带工具表——摘要纯文本任务,
+        // 全量工具 schema 白占几千 token 窗口,还诱导幻觉工具调用。
+        const r = await chat([sysMsg, userMsg], {}, signal, []);
         // 推理模型可能只返 reasoning_content(content 为 null),或幻觉出 tool_calls → 视为失败
         if (r.toolCalls.length > 0 || !r.content)
             return null;
-        return r.content;
+        return capSummaryOutput(r.content);
     }
     finally {
         spinner.stop();
@@ -275,9 +492,28 @@ export async function compactHistory(history, opts) {
     const activeTools = opts.tools ?? chatTools;
     const estimateBefore = estimatePromptTokens(history, activeTools, state.correction);
     state.lastEstimate = estimateBefore;
-    const groups = groupFromEnd(history);
+    // 调用前就已中断(用户在上一步末尾按的 Ctrl+C):一步都别做,直接冒泡。
+    // 不做完再抛是为了保证 history 完全未被触碰——abortRestore 才还原得干净。
+    if (opts.signal?.aborted) {
+        throw new DOMException('This operation was aborted', 'AbortError');
+    }
+    const allGroups = groupFromEnd(history);
+    // 摘要钉住:把已有摘要从 group 序列里摘出来,永不送进摘要器(否则每代再摘要一次 →
+    // 递归衰减)。它的 Key Facts 段跨代累积,叙述段则并入下方转录照常滚动压缩。
+    const pinnedGroups = allGroups.filter(isSummaryGroup);
+    const groups = pinnedGroups.length > 0 ? allGroups.filter((g) => !isSummaryGroup(g)) : allGroups;
+    const pinned = pinnedGroups.length > 0
+        ? splitSummaryText(pinnedGroups
+            .map((g) => toText(g.assistant?.content))
+            .join('\n\n'))
+        : null;
     // 保近期:按策略中的 token 比例累积(至少保 1 组),永不劈开 group。
-    const keepBudget = Math.floor(opts.window * DEFAULT_BUDGET_POLICY.compactKeepRatio);
+    // force(手动 /compact 默认、硬闸触发)用更激进的保留比例;再加绝对上限,
+    // 防大窗口(如 256k)下保留区按比例仍过大——压缩目标 = 摘要 + 最小续工上下文。
+    const keepRatio = opts.force
+        ? DEFAULT_BUDGET_POLICY.compactForceKeepRatio
+        : DEFAULT_BUDGET_POLICY.compactKeepRatio;
+    const keepBudget = Math.min(Math.floor(opts.window * keepRatio), DEFAULT_BUDGET_POLICY.compactKeepMaxTokens);
     const kept = [];
     let keptTokens = 0;
     for (let k = groups.length - 1; k >= 0; k--) {
@@ -290,16 +526,31 @@ export async function compactHistory(history, opts) {
         keptTokens = nextTokens;
     }
     let oldGroups = groups.slice(0, groups.length - kept.length);
+    // 非空 user 兜底:保留区从尾部累积,长回合里最近的若干组常常全是 assistant+tool,
+    // 一个 8000 字符的工具结果就能吃满小窗口的 keepBudget → user 全落进旧区被摘要掉 →
+    // 重建后 history 无 user → 下一步 chat() 被 hasNonEmptyUser 守卫直接拒(整轮中断)。
+    // 把紧邻保留区之前的那条 user 移进保留区:它是当前任务的原始请求,且 user 消息本身极小。
+    // 放这里(而非重建后补 stub)是因为:原文保留,不造新消息形状,也不必进摘要器。
+    if (!kept.some(isUserGroup)) {
+        for (let i = oldGroups.length - 1; i >= 0; i--) {
+            if (!isUserGroup(oldGroups[i]))
+                continue;
+            kept.unshift(oldGroups[i]);
+            oldGroups.splice(i, 1);
+            break;
+        }
+    }
     // force(硬闸/手动强压):保护区不豁免——常规切分无旧区时只保最后一组,
     // 其余全部进可压区(首轮/当前轮也一样)。仍按 group 边界切,不破坏 tool_call 配对。
     // **必须保留最早 user 所在 group**:LLM API(OpenAI / Anthropic)要求 messages 至少
     //  含一条非空 user 消息,否则 400。force 旧实现把所有 user 丢进摘要 → 重建后 history
     //  无 user → 下一轮 chat() 被后端拒绝。保最早 user(而非最后一个)因为它是最原始的
-    //  请求上下文,摘要器已覆盖后续交互。
+    //  请求上下文,摘要器已覆盖后续交互。用 isUserGroup(非空判定)而非只看 role:
+    //  空 content 的 user 同样过不了 hasNonEmptyUser 守卫。
     if (oldGroups.length === 0 && opts.force && groups.length >= 2) {
         kept.length = 0;
         const lastIdx = groups.length - 1;
-        const firstUserIdx = groups.findIndex((g) => g.assistant?.role === 'user');
+        const firstUserIdx = groups.findIndex(isUserGroup);
         if (firstUserIdx >= 0 && firstUserIdx !== lastIdx) {
             kept.push(groups[firstUserIdx], groups[lastIdx]);
             oldGroups = groups.filter((_, i) => i !== firstUserIdx && i !== lastIdx);
@@ -360,35 +611,62 @@ export async function compactHistory(history, opts) {
         }
         return { ...noop, reason: 'noop-protected', protectedRatio };
     }
-    // 第一层:微压缩——旧区原地截短(保 tool_call_id,无 LLM 调用)
-    // 覆盖三类大字段,均只裁模型/工具产物,不动 user 原话与 system(摘要):
-    //   ① tool 结果 content;
-    //   ② 旧 assistant 的 tool_calls.arguments —— provenance stub:整体超长才进,大字段
-    //     替换为 "<N 字符,已省略>"(保 path + JSON 合法,见 stubToolCallArguments);
-    //   ③ 旧 assistant 正文 content(模型长解释,回看价值低)。
-    let microcompactDone = false;
-    for (const g of oldGroups) {
-        if (microcompactGroup(g))
-            microcompactDone = true;
+    // 主层:摘要——把旧区【原始内容】压成一条 system 摘要。
+    // 触发压缩时旧区约占窗口 50-60%,摘要请求与摘要器共享窗口,逐条封顶后即装得下;
+    // 不在这里预跑微压缩——预截断会让摘要模型看到 600 字符残片,等于弄瞎它,
+    // 且摘要成功后旧区整体丢弃,预截断本身也无收益。
+    // 上一代摘要的叙述段并入转录:它压的就是更早的轮次,不并进来等于把那些轮次整段丢弃;
+    // 并进来则由本代摘要统一重压(可重建内容,磨掉不心疼)。Key Facts 不并——它已被钉住。
+    let older = flattenGroups(oldGroups);
+    if (pinned?.rest) {
+        older = [
+            {
+                role: 'system',
+                content: `${PRIOR_NARRATIVE_LABEL}\n${pinned.rest}`,
+            },
+            ...older,
+        ];
     }
-    // 第二层:摘要——把旧区(微压缩后)压成一条 system 摘要
-    const older = flattenGroups(oldGroups);
     const summarizeFn = opts.summarize ?? defaultSummarize;
     let summary = null;
     try {
-        summary = await summarizeFn(older, opts.focus);
+        summary = await summarizeFn(older, opts.focus, opts.signal);
     }
-    catch {
-        summary = null; // 摘要失败 → 回退仅微压缩,不崩
+    catch (err) {
+        // **中断必须冒泡,不能降级成微压缩**:用户按了 Ctrl+C 是要立刻停,不是"换个姿势继续压"。
+        // 冒泡后由 runAgentCore 步骤 catch 里的 abort 分支走 abortRestore(还原 history + 模式)。
+        // 此处 history 尚未被改动(重建在摘要成功之后),所以直接抛是安全的。
+        if (isAbortError(err, opts.signal))
+            throw err;
+        summary = null; // 真·摘要失败 → 回退微压缩兜底,不崩
     }
     if (summary) {
         const artifactRefs = collectArtifactRefs(older);
         const provenance = artifactRefs.length > 0
             ? `\n\n[artifact refs: ${artifactRefs.join(', ')}]`
             : '';
+        // 钉住的 Key Facts 拼在段尾:单条 system 消息里尾部注意力最强,老事实不会被"读漏"。
+        // 恒为单条——并排多条 system 摘要会触发近因效应,早期摘要形同虚设。
+        const parsed = splitSummaryText(summary);
+        const pinnedFacts = mergeKeyFacts(pinned?.keyFacts, parsed.keyFacts, keyFactsBudgetChars(opts.window));
+        // P2:把 Objective/In Progress/Next Steps 固结到 notes.md——压缩那一刻
+        // notes.md 就有当前进度的权威副本,压缩后恢复提示据此续工,不再只依赖
+        // 模型自觉 plan_update。仅主 agent(共享 contextState)写;子 agent 独立
+        // contextState 不应污染主会话笔记。无活跃 plan 时写入(有则权威计划仍在)。
+        if (state === contextState) {
+            const snapshot = extractProgressSnapshot(parsed.rest);
+            if (snapshot)
+                writeCompactionSnapshot(snapshot);
+        }
+        const body = [
+            parsed.rest,
+            pinnedFacts ? `## Key Facts\n${pinnedFacts}` : '',
+        ]
+            .filter(Boolean)
+            .join('\n\n');
         const summaryMsg = {
             role: 'system',
-            content: `# 会话摘要\n${summary}${provenance}`,
+            content: `${SUMMARY_MARKER}\n${body}${provenance}`,
         };
         // 原地重建:[systemPrompt, summaryMsg, ...kept]
         const systemMsg = history[0];
@@ -417,7 +695,15 @@ export async function compactHistory(history, opts) {
             reason: 'summarize',
         };
     }
-    // 摘要失败:回退仅微压缩(tool content 已原地改),结构不动
+    // 摘要失败兜底:微压缩——旧区原地截短(保 tool_call_id,无 LLM 调用),结构不动。
+    // 覆盖三类大字段,均只裁模型/工具产物,不动 user 原话与 system:
+    //   ① tool 结果 content;② 旧 assistant 的 tool_calls.arguments(provenance stub,
+    //     整体超长才进,大字段替换为 "<N 字符,已省略>",保 path + JSON 合法);③ 旧 assistant 正文。
+    let microcompactDone = false;
+    for (const g of oldGroups) {
+        if (microcompactGroup(g))
+            microcompactDone = true;
+    }
     const estimateAfter = estimatePromptTokens(history, activeTools, state.correction);
     state.lastEstimate = estimateAfter;
     state.lastUsage = undefined; // token 数已变,旧 usage 失效
@@ -460,7 +746,9 @@ export async function compactHistory(history, opts) {
  * 强制走 compactHistory(manual/force 参数透传)。返 CompactResult 给 caller 文案展示。
  * 默认 manual=false 自动路径完全不变。
  */
-export async function maybeCompact(history, report, manualOpts, state = contextState, activeTools = chatTools) {
+export async function maybeCompact(history, report, manualOpts, state = contextState, activeTools = chatTools, 
+/** 主 agent 的 abort signal;透传给 compactHistory → 摘要器 → chat()。 */
+signal) {
     const est = estimatePromptTokens(history, activeTools, state.correction);
     state.lastEstimate = est;
     const isManual = manualOpts?.manual === true;
@@ -497,6 +785,7 @@ export async function maybeCompact(history, report, manualOpts, state = contextS
         force: manualOpts?.force === true || hardCap,
         tools: activeTools,
         contextState: state,
+        signal,
     });
     return r;
 }

package/dist/session/notes.js

@@ -116,11 +116,17 @@ const NOTE_SECTION_TITLES = {
     decisions: 'Decisions',
     open_questions: 'Open Questions',
     risks: 'Risks',
+    // compaction_snapshot 是压缩成功后自动写入的机器快照(非 note_append 手填):
+    // 让摘要的 Objective/In Progress/Next Steps 在压缩后仍作为活跃笔记段注入。
+    compaction_snapshot: 'Compaction Snapshot',
 };
 /** 预设段 key 列表(供工具 schema enum 与校验用)。 */
 export const NOTE_SECTION_KEYS = Object.keys(NOTE_SECTION_TITLES);
 /** 段注入优先级:数值越大越先占预算、越后丢弃正文。Risks 最重要。 */
 const SECTION_PRIORITY = {
+    // compaction_snapshot 提到最高:它是压缩当次的权威进度快照,比手填 findings 更能
+    // 直接告诉模型「做到哪了」,压缩后第一步最该看到的就是它。
+    compaction_snapshot: 5,
     risks: 4, findings: 3, decisions: 2, open_questions: 1,
 };
 /** 常驻笔记正文总预算(token)。5k:占百万级 context 的 0.5%,可常驻相当量笔记。 */
@@ -338,3 +344,60 @@ export function extractActiveNotesSections(budget = NOTES_INJECT_BUDGET_TOKENS,
     }
     return out.join('\n\n');
 }
+// ── Compaction Snapshot(压缩时自动固结的进度快照)──────────────────────────
+// 由 compactHistory 在摘要成功后写入;替代「模型需自觉 plan_update」的软约定——
+// 压缩那一刻 notes.md 里一定有当前进度的权威副本,压缩后恢复提示据此续工。
+// 与 plan/notes 不同:这是机器产出、整段替换(不逐条累积),因此不会跨压缩膨胀。
+/** 快照段标题。extractActiveNotesSections 经 matchSectionKey 识别并注入。 */
+export const COMPACTION_SNAPSHOT_TITLE = NOTE_SECTION_TITLES.compaction_snapshot;
+/**
+ * 把压缩摘要的关键段固结到 notes.md 的 `## Compaction Snapshot` 段。
+ * 整段替换旧快照(不累积);仅在当前无活跃 plan 时写入(已有 plan 时权威计划仍在,
+ * 快照只会重复)。body 为空时不动。永不抛错:压缩主流程不能因快照失败而失败。
+ */
+export function writeCompactionSnapshot(body, sessionId = getCurrentSessionId()) {
+    try {
+        const trimmed = (body ?? '').trim();
+        if (!trimmed)
+            return;
+        if (readActivePlanTitle(sessionId))
+            return; // 已有权威计划,快照是冗余
+        const p = getNotesFilePath(sessionId);
+        if (!p)
+            return;
+        let existing = '';
+        try {
+            existing = fs.readFileSync(p, 'utf8').replace(/\r\n?/g, '\n');
+        }
+        catch {
+            existing = '';
+        }
+        const header = `## ${COMPACTION_SNAPSHOT_TITLE}`;
+        const newSection = `${header}\n${trimmed}`;
+        const lines = existing.split('\n');
+        const start = lines.findIndex((l) => l.trim() === header);
+        let next;
+        if (start >= 0) {
+            // 段末 = 下一个 ## 或文件末;整段替换
+            let end = lines.length;
+            for (let k = start + 1; k < lines.length; k++) {
+                if (/^##\s/.test(lines[k])) {
+                    end = k;
+                    break;
+                }
+            }
+            const before = lines.slice(0, start).join('\n').replace(/\s+$/, '');
+            const after = lines.slice(end).join('\n').replace(/^\s+/, '');
+            next = [before, newSection, after].filter((s) => s.length > 0).join('\n\n') + '\n';
+        }
+        else {
+            const rest = existing.trim();
+            next = rest ? `${rest}\n\n${newSection}\n` : `${newSection}\n`;
+        }
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, next, 'utf8');
+    }
+    catch {
+        // 快照是 best-effort 增强,绝不影响压缩主流程。
+    }
+}

package/dist/session/scheduler.js

@@ -4,8 +4,6 @@ import { evaluateBudget, scheduleActions, formatReport, DEFAULT_BUDGET_POLICY, }
 import { chatTools } from '../llm/index.js';
 import { config } from '../config/index.js';
 import { maybeCompact, contextState } from './compact.js';
-import * as layout from '../ui/layout.js';
-import { ui } from '../ui/theme.js';
 import { pruneStaleArtifacts, refreshArtifactFreshness } from '../context/artifacts.js';
 import { pruneSuperseded } from '../context/relevance.js';
 import { createAgeAwareEncodingState } from '../context/age-aware.js';
@@ -28,7 +26,7 @@ export function createBudgetScheduler(state = contextState) {
     const evaluate = (history, step, activeTools, ephemeralTokens) => evaluateBudget(history, config.contextWindowTokens, step, state.correction, activeTools, ephemeralTokens);
     const scheduler = {
         lastRunLog: null,
-        async runStep(history, step, activeTools = chatTools, ephemeralTokens = 0) {
+        async runStep(history, step, activeTools = chatTools, ephemeralTokens = 0, signal) {
             // External file changes and mutations only update artifact metadata here.
             refreshArtifactFreshness(state, history);
             const report = evaluate(history, step, activeTools, ephemeralTokens);
@@ -54,11 +52,7 @@ export function createBudgetScheduler(state = contextState) {
             let compactHistoryCalled = false;
             let historyRebuilt = false;
             for (const action of actions) {
-                if (action.kind === 'warn') {
-                    layout.contentWrite(`  ${ui.accent}●${ui.reset} ${ui.yellow}调度器警告 [${action.layer}] ${action.reason}${ui.reset}\n`);
-                    continue;
-                }
-                const result = await maybeCompact(history, report, undefined, state, activeTools);
+                const result = await maybeCompact(history, report, undefined, state, activeTools, signal);
                 compactHistoryCalled = true;
                 historyRebuilt ||= result?.historyRebuilt === true;
             }
@@ -82,6 +76,7 @@ export async function runScheduler(history, step, state = contextState, activeTo
 }
 /** User-requested compaction bypasses automatic pressure gating. */
 export async function manualCompact(history, focus, opts) {
+    const signal = opts?.signal;
     if (config.contextBudget === false) {
         const result = await import('./compact.js').then(({ compactHistory }) => compactHistory(history, {
             window: config.contextWindowTokens,
@@ -89,6 +84,7 @@ export async function manualCompact(history, focus, opts) {
             focus,
             manual: true,
             force: opts?.force,
+            signal,
         }));
         const report = evaluateBudget(history, config.contextWindowTokens, -1, contextState.correction);
         const log = {
@@ -127,7 +123,7 @@ export async function manualCompact(history, focus, opts) {
             manual: true,
             force: opts?.force,
             focus: action.focus,
-        });
+        }, contextState, chatTools, signal);
         compactHistoryCalled = true;
         if (result) {
             compactDetail = {

package/dist/tools/constants.js

@@ -10,6 +10,27 @@ export const MAX_HISTORY_RESULT = 8000;
 export const MAX_SKILL_RESULT = 64000;
 /** 微压缩时旧工具结果截到的存根长度(字符)。 */
 export const MAX_OLD_TOOL_STUB = 600;
+// ── 上下文压缩摘要(见 session/compact.ts defaultSummarize)────────────────
+/** 摘要输入单条消息封顶:逐条封顶保证每轮对话都有代表,替代整段中截(会切掉中间整轮)。
+ *  转录总量超 SUMMARY_TRANSCRIPT_WINDOW_RATIO 时,这些封顶会被等比缩小重拼。 */
+export const SUMMARY_MSG_MAX_CHARS = {
+    user: 3000, // 用户原话价值最高,给大额度
+    assistant: 1600,
+    tool: 800,
+    other: 2000,
+};
+/** 摘要转录总预算占上下文窗口的比例:超预算时等比缩小单条封顶重拼——
+ *  优先保消息条数(每轮都有代表),其次才保单条长度。 */
+export const SUMMARY_TRANSCRIPT_WINDOW_RATIO = 0.55;
+/** 摘要输出硬上限(字符):模型不听话产出超长摘要时按段落边界裁,防摘要本身撑大 history。 */
+export const SUMMARY_OUTPUT_MAX_CHARS = 6000;
+// ── 跨代钉住的 Key Facts 预算(见 compact.ts mergeKeyFacts)────────────────
+/** 占窗口比例。按「字符≈token」的保守换算(中文 1 字≈1 token),取 summary 层的一半。 */
+export const SUMMARY_KEYFACTS_WINDOW_RATIO = 0.05;
+/** 小窗口下的绝对下限:首轮约束通常就几条,32k 窗口按比例只有 1.6k 也得保住。 */
+export const SUMMARY_KEYFACTS_MIN_CHARS = 1200;
+/** 大窗口下的绝对上限:Key Facts 是索引不是正文,不该无限膨胀。 */
+export const SUMMARY_KEYFACTS_MAX_CHARS = 8000;
 // ── 记忆(Tier-2 JSONL 工具库)──────────────────────────────────────────────
 /** 单条记忆 body 上限(字符)。进 history 前 memory_search 结果另有 MAX_MEMORY_RESULT 兜底。 */
 export const MAX_MEMORY_ENTRY = 4000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocode-ai",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 16 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {

package/dist/__trace_manual_test__.js

@@ -1 +0,0 @@
-export const TRACE_SECRET_MARKER_20260719 = 1;