mocode-ai 1.2.8 → 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, SUMMARY_MSG_MAX_CHARS, SUMMARY_OUTPUT_MAX_CHARS, SUMMARY_TRANSCRIPT_WINDOW_RATIO, } 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 = [];
@@ -273,7 +423,11 @@ function buildTranscript(stripped, scale) {
     })
         .join('\n');
 }
-async function defaultSummarize(older, focus) {
+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%,摘要器共享同一窗口——逐条封顶后旧区原文即可装入,
@@ -302,6 +456,8 @@ async function defaultSummarize(older, focus) {
             '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 = {
@@ -311,11 +467,12 @@ async function defaultSummarize(older, focus) {
             : `请将以下会话历史压缩成交接摘要:\n\n${transcript}\n\n摘要:`,
     };
     const spinner = new Spinner((msg, frame) => layout.setStatus(msg, frame ?? undefined));
-    spinner.start('压缩中');
+    spinner.start(signal ? '压缩中(Ctrl+C 取消)' : '压缩中');
     try {
+        // signal 必须透传:摘要是几十秒的 LLM 调用,不串进来 Ctrl+C 只能干等它跑完。
         // 空 handlers:不打印、不外显流式;tools=[] 不带工具表——摘要纯文本任务,
         // 全量工具 schema 白占几千 token 窗口,还诱导幻觉工具调用。
-        const r = await chat([sysMsg, userMsg], {}, undefined, []);
+        const r = await chat([sysMsg, userMsg], {}, signal, []);
         // 推理模型可能只返 reasoning_content(content 为 null),或幻觉出 tool_calls → 视为失败
         if (r.toolCalls.length > 0 || !r.content)
             return null;
@@ -335,7 +492,21 @@ 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。
     // force(手动 /compact 默认、硬闸触发)用更激进的保留比例;再加绝对上限,
     // 防大窗口(如 256k)下保留区按比例仍过大——压缩目标 = 摘要 + 最小续工上下文。
@@ -355,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);
@@ -429,23 +615,58 @@ export async function compactHistory(history, opts) {
     // 触发压缩时旧区约占窗口 50-60%,摘要请求与摘要器共享窗口,逐条封顶后即装得下;
     // 不在这里预跑微压缩——预截断会让摘要模型看到 600 字符残片,等于弄瞎它,
     // 且摘要成功后旧区整体丢弃,预截断本身也无收益。
-    const older = flattenGroups(oldGroups);
+    // 上一代摘要的叙述段并入转录:它压的就是更早的轮次,不并进来等于把那些轮次整段丢弃;
+    // 并进来则由本代摘要统一重压(可重建内容,磨掉不心疼)。Key Facts 不并——它已被钉住。
+    let older = flattenGroups(oldGroups);
+    if (pinned?.rest) {
+        older = [
+            {
+                role: 'system',
+                content: `${PRIOR_NARRATIVE_LABEL}\n${pinned.rest}`,
+            },
+            ...older,
+        ];
+    }
     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];
@@ -525,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;
@@ -562,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

@@ -24,6 +24,13 @@ export const SUMMARY_MSG_MAX_CHARS = {
 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.8",
+  "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;

package/dist/agent/core.d.ts

@@ -1,112 +0,0 @@
-import type OpenAI from 'openai';
-import { type ChatMessage, type ChatUsage, type ToolCallRef } from '../llm/index.js';
-/** 解析工具 arguments JSON;非法或空返 null(调用方据此降级到普通 preview)。 */
-declare function parseArgs(raw: string): Record<string, unknown> | null;
-/** 只读工具集:一轮多个时,连续的只读工具成组 Promise.all 并行(无副作用、互不依赖)。 */
-declare const READ_TOOL_NAMES: Set<string>;
-/** mutation 工具:写盘 + 在 executeTool 内记回滚 before 快照,必须串行保快照序。 */
-declare const isMutationTool: (name: string) => boolean;
-/** 工具调用 ● 头所需信息(交给 hooks 渲染;core 不直接写屏)。 */
-export interface ToolCallView {
-    name: string;
-    arguments: string;
-    id: string;
-}
-/** mutation 执行前读旧内容供 diff:write_file 取整文件旧内容(不存在→null=新建),
- * edit_file 取 old_string 起始行号(供 diff 显示真实文件行号)。读不到则 diff 退化为相对行号。
- * 非 mutation 或参数非法返 { preWriteOld: null, editStartLine: 1 }。失败不阻断。 */
-declare function readDiffContext(tc: ToolCallRef, parsed: Record<string, unknown> | null): {
-    preWriteOld: string | null;
-    editStartLine: number;
-};
-/**
- * agent 循环的展示副作用接缝。主 agent 注入 TUI 渲染实现;子 agent 注入静默/摘要实现。
- * 所有方法可选——core 对 undefined hooks 安全跳过。
- */
-export interface AgentHooks {
-    /** 流式正文增量(主 agent:走 markdown 渲染写内容区)。 */
-    onText?: (delta: string) => void;
-    /** 模型开始生成某 tool_call 的参数(主 agent:补换行 + 启「生成中」spinner)。 */
-    onToolCall?: (name: string) => void;
-    /** 每步开始,spinner 启「思考中」(主 agent:spinner.start)。 */
-    onStepStart?: () => void;
-    /** chat 返回后停 spinner(主 agent:spinner.stop)。 */
-    onChatDone?: () => void;
-    /** 流式正文末尾补换行(若 onToolCall 已补则 no-op);防 ● 行黏在正文行尾。 */
-    onTextEnd?: () => void;
-    /** 工具调用 ● 头渲染(主 agent:工具名 + 参数摘要)。 */
-    onToolHeader?: (tc: ToolCallRef) => void;
-    /** 启「执行 工具」spinner(主 agent:spinner.start)。 */
-    onToolStart?: (name: string) => void;
-    /** 工具执行完停 spinner(主 agent:spinner.stop)。 */
-    onToolDone?: () => void;
-    /** 工具结果渲染(主 agent:mutation 走 diff 块;其余走一行 preview)。 */
-    onToolResult?: (tc: ToolCallRef, output: string, parsed: Record<string, unknown> | null, preWriteOld: string | null, editStartLine: number) => void;
-    /** 工具步末尾补一空行(与下一轮思考/正文分隔)。 */
-    onToolBatchEnd?: () => void;
-    /** 无回复提示(模型既无文本也无工具调用)。 */
-    onNoReply?: () => void;
-    /** 达到最大步数提示。 */
-    onMaxSteps?: () => void;
-    /** 中断还原:停 spinner + 补换行 + (已中断)提示 + history 还原 + 模式还原。 */
-    onAbort?: () => void;
-    /** 跑完(正常/达上限)在回复末尾打耗时摘要行;中断不调。
-     *  usage 是本轮 chat 调用累计的 token 用量(未开启 include_usage 或全失败时为 undefined)。 */
-    onDone?: (elapsedMs: number, usage?: ChatUsage) => void;
-}
-/** runAgentCore 的运行选项。 */
-export interface AgentRunOptions {
-    history: ChatMessage[];
-    /** 纯文本字符串,或多模态 parts 数组(OpenAI content 数组,text + image_url)。 */
-    userInput: string | ContentPart[];
-    signal?: AbortSignal;
-    /** 每步 chat() 返回后回调:repl 据此重算并重画状态行 context 用量条。 */
-    onContextUpdate?: () => void;
-    hooks: AgentHooks;
-    /** 步数上限;缺省 = config.maxSteps。子 agent 可传更低值。 */
-    maxSteps?: number;
-    /** 工具 schema 覆盖;plan 模式传 planChatTools(只读子集)。子 agent 可传受限子集。
-     *  缺省 = 按 getAgentMode() 自动选(auto=全量 / plan=只读)。 */
-    toolsOverride?: OpenAI.Chat.Completions.ChatCompletionTool[];
-    /** 跳过回滚快照记录(子 agent 逻辑隔离用)。true = 本 agent 的 write_file/edit_file 改动
-     *  不进主回滚链,主 /rollback 不撤销。透传给 executeTool。 */
-    skipRollback?: boolean;
-}
-/** OpenAI content array 的子集(text + image_url);repl 构造 user 多模态消息用。 */
-export type ContentPart = {
-    type: 'text';
-    text: string;
-} | {
-    type: 'image_url';
-    image_url: {
-        url: string;
-        detail?: 'auto' | 'low' | 'high';
-    };
-};
-/** runAgentCore 的运行结果。 */
-export interface AgentRunResult {
-    /** 正常完毕 / 达上限 true;中断 false。 */
-    completed: boolean;
-    /** 最终 assistant 文本回复(content);无回复或中断为 null。 */
-    finalText: string | null;
-    /** 本轮累计 token 用量(各 chat 步 prompt+completion 之和);后端不开 include_usage 或全失败则 undefined。 */
-    usage?: ChatUsage;
-}
-/**
- * agent 核心循环(纯逻辑):
- *  流式调 LLM(经 hooks.onText 实时渲染)→ 有 tool_calls 就分组执行并回灌
- *  → 否则流式正文即最终回复。history 在调用间持久,由调用方持有。
- *  步前经 session/maybeCompact 自动压缩(接近窗口上限时三层压缩);
- *  工具结果进 history 前经 Context Optimization Pipeline(optimizeToolResult:类型化编码 + 长度裁剪)。
- *
- *  中断语义:signal 经 executeTool(name, args, signal) 串进工具;run_command/web_fetch 等 abort 即时杀
- *  (树杀子进程 / 取消 fetch),循环顶 if(signal.aborted) 兜底还原。不会留下未配对的 tool_call_id。
- *  abort 时 history 还原到本 turn 前(savedHistory 浅拷贝),模式还原,调 hooks.onAbort。
- *
- *  所有展示副作用经 hooks 注入;core 自身不直接调 layout / spinner(不依赖 ui/layout.ts)。
- *  但 core 仍依赖 ui/render.ts 的纯函数(summarizeToolCall / truncateDisplay / fmtElapsed)——
- *  这些是纯字符串格式化,无副作用,共享安全。
- */
-export declare function runAgentCore(opts: AgentRunOptions): Promise<AgentRunResult>;
-export { parseArgs, readDiffContext, isMutationTool, READ_TOOL_NAMES };
-export type { ChatMessage, ToolCallRef, ChatUsage } from '../llm/index.js';

package/dist/agent/index.d.ts

@@ -1,19 +0,0 @@
-import type { ChatMessage } from '../llm/index.js';
-import { type AgentRunResult, type ContentPart } from './core.js';
-/**
- * agent 核心循环(主 agent,TUI 渲染版):
- *  流式调 LLM(onText 实时写内容区)→ 有 tool_calls 就执行并回灌
- *  → 否则流式正文即最终回复。history 在调用间持久,由 REPL 持有。
- *  步前经 session/maybeCompact 自动压缩(接近窗口上限时三层压缩);
- *  工具结果进 history 前经 capToolResultForHistory 裁到单条上限。
- *
- *  所有正文写经 layout.contentWrite(保证落在内容区、跟踪续写位、底栏不被顶);
- *  spinner 经 onFrame 回调刷状态行(layout.drawStatusBar),等待时内容区静止、底栏转圈。
- *  思考期间不写思考内容,只让 spinner 持续转「思考中…」(首个正文 / tool_call token 到达才停)。
- *
- *  循环逻辑委托 runAgentCore;本函数只注入 TUI 渲染 hooks(layout + spinner + diff + 回滚轮次)。
- *  开新轮次(beginTurn)在入口调——core 不依赖 rollback,回滚轮次是主 agent 的展示副作用。
- */
-export declare function runAgent(history: ChatMessage[], userInput: string | ContentPart[], signal?: AbortSignal, 
-/** 每步 chat() 返回后回调:repl 据此重算并重画状态行 context 用量条(运行中实时刷新,不冻结在轮首)。 */
-onContextUpdate?: () => void): Promise<AgentRunResult>;