mocode-ai 1.6.4 → 1.6.6

package/dist/session/compact.js

@@ -1,4 +1,4 @@
-import { chat, chatTools, correctTokenEstimate, estimatePromptTokens, estimateTokens, } from '../llm/index.js';
+import { chat, chatTools, correctTokenEstimate, estimateMessagesTokens, estimatePromptTokens, estimateToolSchemaTokens, estimateTokens, } from '../llm/index.js';
 import { config } from '../config/index.js';
 import { COMPACT_USER_VERBATIM_MAX_TOKENS, COMPACT_USER_VERBATIM_WINDOW_RATIO, 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, USER_DIRECTIVE_MAX_CHARS, USER_DIRECTIVE_MAX_CONSTRAINTS, } from '../tools/constants.js';
 import { ui } from '../ui/theme.js';
@@ -9,6 +9,9 @@ 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';
+import { getActiveSessionStore } from './store.js';
+import { getCurrentSessionId } from './state.js';
+import { toUsageRecord } from './usage-stats.js';
 /** 默认兼容依赖：旧调用方继续读取进程级 config/chat。 */
 export const defaultCompactionRuntime = {
     config,
@@ -552,7 +555,7 @@ async function defaultSummarize(older, focus, signal, runtime = defaultCompactio
         // signal 必须透传:摘要是几十秒的 LLM 调用,不串进来 Ctrl+C 只能干等它跑完。
         // 空 handlers:不打印、不外显流式;tools=[] 不带工具表——摘要纯文本任务,
         // 全量工具 schema 白占几千 token 窗口,还诱导幻觉工具调用。
-        const r = await runtime.modelTransport([sysMsg, userMsg], {}, signal, []);
+        const r = await runtime.modelTransport([sysMsg, userMsg], {}, signal, [], { reasoningEffort: 'low' });
         // 推理模型可能只返 reasoning_content(content 为 null),或幻觉出 tool_calls → 视为失败
         if (r.toolCalls.length > 0 || !r.content)
             return null;
@@ -562,6 +565,74 @@ async function defaultSummarize(older, focus, signal, runtime = defaultCompactio
         spinner.stop();
     }
 }
+// ── cache-safe fork 摘要器(#token-efficiency P0) ─────────────────────────
+/**
+ * 构造 fork 前缀:父会话 history[0](system)+ 所有不在 kept 里的原始消息
+ * (pinned 旧摘要 + oldGroups),保持原顺序与原对象引用。
+ * 与父请求编码结果逐字节一致是显式/隐式缓存命中的唯一条件。
+ */
+function buildForkMessages(history, kept) {
+    if (history.length === 0)
+        return [];
+    const keptSet = new Set(flattenGroups(kept));
+    const out = [history[0]];
+    for (const m of history.slice(1)) {
+        if (!keptSet.has(m))
+            out.push(m);
+    }
+    return out;
+}
+/** fork 尾部 user 消息:摘要任务指令(原 legacy sysMsg 的规则,措辞改为"上方对话")。 */
+function compactForkInstruction(focus) {
+    const focusLine = focus ? `Focus: prioritize facts / decisions / file changes related to 「${focus}」.\n\n` : '';
+    return (focusLine +
+        '[COMPACT TASK] You are an aggressive session compressor writing a handoff note for an agent that is about to lose the context above. ' +
+        'The agent will continue with ONLY your summary plus a few most-recent messages (not shown here), so your summary is the sole memory of every message above. ' +
+        'If the messages above include a prior session summary, merge its narrative; its Key Facts are pinned separately by the system — do not duplicate them.\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 above, 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, open questions, failed approaches and errors to avoid repeating. User requests and constraints are pinned verbatim by the system from the raw user messages — do not duplicate them here; you own the technical facts.\n' +
+        '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) later steps must cite; failures and what was tried, so mistakes are not repeated.\n' +
+        'Drop: verbatim file contents and tool-output dumps, step-by-step recaps, exploration dead-ends, polite chatter, anything re-derivable by re-reading files.\n' +
+        'GUI EXCEPTION to "step-by-step recaps": for computer/screen-control actions keep the SEQUENCE as an ordered list — one line per action: `N. <action> (<coordinates or target>) → <observed result>`. Never collapse it into prose and never drop attempts that produced no visible change.\n' +
+        'Rules: total ≤ 400 words. State conclusions and locations (path:line where useful), never paste content. ' +
+        'Write each Key Fact as one self-contained line (no pronouns, no "as above", no cross-references). ' +
+        'Do not emit tool calls and do not invent facts; if unsure whether something happened, omit it.');
+}
+/** buffer 校验:fork 全量(含指令 + 摘要输出上限)必须装得进窗口,否则回落 legacy。 */
+function forkFits(prefix, instruction, activeTools, window) {
+    const forkInput = estimateMessagesTokens([...prefix, { role: 'user', content: instruction }]) +
+        estimateToolSchemaTokens(activeTools);
+    const outputBudget = estimateTokens('a '.repeat(Math.max(1, Math.floor(SUMMARY_OUTPUT_MAX_CHARS / 2))));
+    return forkInput + outputBudget <= window;
+}
+/** 执行 fork 请求:复用父前缀 + activeTools,记录 compact phase 用量。 */
+async function forkSummarize(prefix, instruction, signal, runtime, activeTools, state) {
+    if (signal?.aborted)
+        throw new DOMException('This operation is aborted', 'AbortError');
+    const messages = [...prefix, { role: 'user', content: instruction }];
+    const spinner = new Spinner((msg, frame) => layout.setStatus(msg, frame ?? undefined));
+    spinner.start(signal ? '压缩中(Ctrl+C 取消)' : '压缩中');
+    try {
+        const r = await runtime.modelTransport(messages, {}, signal, activeTools, { reasoningEffort: 'low' });
+        if (r.usage) {
+            const rec = toUsageRecord(state.currentStep ?? -1, 'compact', r.usage);
+            const sessionId = getCurrentSessionId();
+            if (rec && sessionId)
+                getActiveSessionStore().appendUsage(sessionId, rec);
+        }
+        // 同 legacy:幻觉 tool_calls 或空 content → 失败(调用方回落 microcompact)。
+        if (r.toolCalls.length > 0 || !r.content)
+            return null;
+        return capSummaryOutput(r.content);
+    }
+    finally {
+        spinner.stop();
+    }
+}
 // ── 对外:compactHistory / maybeCompact ───────────────────────────────────
 /**
  * 用户可见的上下文占用口径:**裸估算**(不乘 correction)。
@@ -761,7 +832,17 @@ export async function compactHistory(history, opts) {
         ];
     }
     const summarizeFn = opts.summarize ??
-        ((older, focus, signal) => defaultSummarize(older, focus, signal, opts.runtime ?? defaultCompactionRuntime));
+        (async (older, focus, signal) => {
+            const rt = opts.runtime ?? defaultCompactionRuntime;
+            // P0:fork 关闭或 buffer 装不下 → 回落 legacy 独立 compressor 路径。
+            if (!config.compactFork)
+                return defaultSummarize(older, focus, signal, rt);
+            const prefix = buildForkMessages(history, kept);
+            const instruction = compactForkInstruction(focus);
+            if (!forkFits(prefix, instruction, activeTools, opts.window))
+                return defaultSummarize(older, focus, signal, rt);
+            return forkSummarize(prefix, instruction, signal, rt, activeTools, state);
+        });
     let summary = null;
     try {
         summary = await summarizeFn(older, opts.focus, opts.signal);

package/dist/session/index.js

@@ -12,6 +12,8 @@ export { compactHistory, maybeCompact, capToolResultForHistory, truncateMid, con
 export { runScheduler, manualCompact, createBudgetScheduler } from './scheduler.js';
 export { newSessionId, saveSession, loadSession, listSessions, sessionDir } from './persist.js';
 export { SessionStore, defaultSessionStore, getActiveSessionStore, withSessionStore } from './store.js';
+// ── 老会话 retention/GC(30 天归档 / 90 天清正文)────────────────────────
+export { planRetention, runRetention, readArchiveIndex, upsertArchiveIndex, loadArchivedSession, searchArchiveIndex, retentionPaths, shouldAutoGc, writeLastAutoGc, DEFAULT_RETENTION_POLICY, } from './retention.js';
 export { appendCurrentSessionTrace, appendCurrentSessionTraceEvent, appendCurrentSessionRuntimeEvent, createTraceEvent, } from './trace.js';
 export { reduceTraceMetrics, readTraceEvents, readTraceMetrics } from './trace-metrics.js';
 export { summarizeToolArguments, hashTraceValue, safeProviderId } from './trace-sanitize.js';

package/dist/session/retention.js

@@ -0,0 +1,297 @@
+// Session retention / GC: 老会话的分层生命周期治理。
+//
+// 此前 memory 有 decay/GC(30/90 天)而 session 没有——.mocode/sessions/ 只增不减
+// (实测 23MB+)。本模块对齐 memory 的节奏:
+//   ① archive:  超过 archiveAfterDays 未活动的会话,整份 SessionRecord gzip 到
+//                archive/<id>.json.gz,摘要+meta 落入 archive/index.jsonl,然后删原目录。
+//   ② purge:    archive 中的 .gz 超过 purgeAfterDays,删 gz;index 行保留(meta+摘要),
+//                仅标 purgedAt——老资料仍可检索,只是不可再整段恢复。
+//
+// 纯本地、确定性、零 LLM 成本。当前活跃会话(currentSessionId)永不归档。
+// 所有写盘走 tmp+rename(整文件读改写),与 memory/store.ts 同一原子模型。
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import path from 'node:path';
+import { gzipSync, gunzipSync } from 'node:zlib';
+import { TextSearchIndex } from '../context/text-search.js';
+import { config } from '../config/index.js';
+import { runReflection, snapshotTranscript } from '../memory/index.js';
+/** 摘要消息头(与 compact.ts SUMMARY_MARKER 同值;本地复制避免拉入 compact 的重依赖图)。 */
+const SUMMARY_MARKER = '# 会话摘要';
+const DAY_MS = 86_400_000;
+export const DEFAULT_RETENTION_POLICY = {
+    // env 覆盖仅供测试/调参:MOCODE_ARCHIVE_AFTER_DAYS=0 可立刻触发归档,不必真等 30 天。
+    archiveAfterDays: envNumber('MOCODE_ARCHIVE_AFTER_DAYS', 30),
+    purgeAfterDays: envNumber('MOCODE_PURGE_AFTER_DAYS', 90),
+};
+/** 读数字 env;允许显式 0(测试要立刻触发),非法/缺省回退默认。 */
+function envNumber(key, fallback) {
+    const v = Number(process.env[key]);
+    return Number.isFinite(v) && v >= 0 ? v : fallback;
+}
+export function retentionPaths(sessionsRoot) {
+    const archiveDir = path.join(sessionsRoot, 'archive');
+    return {
+        sessionsRoot,
+        archiveDir,
+        indexPath: path.join(archiveDir, 'index.jsonl'),
+        lastAutoGcPath: path.join(archiveDir, '.last-auto-gc'),
+    };
+}
+/** 两次自动 GC 的最小间隔(限频,避免每次启动都跑)。 */
+export const AUTO_GC_INTERVAL_MS = 24 * 60 * 60 * 1000;
+/** 读上次自动 GC 时间戳;无文件/损坏返回 null。 */
+export function readLastAutoGc(sessionsRoot) {
+    try {
+        const v = Number(readFileSync(retentionPaths(sessionsRoot).lastAutoGcPath, 'utf8').trim());
+        return Number.isFinite(v) ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 写自动 GC 时间戳(tmp+rename 虽非必需,保持与其它落盘一致的原子性)。 */
+export function writeLastAutoGc(sessionsRoot, ts = Date.now()) {
+    const p = retentionPaths(sessionsRoot).lastAutoGcPath;
+    mkdirSync(path.dirname(p), { recursive: true });
+    writeFileSync(p + '.tmp', String(ts));
+    renameSync(p + '.tmp', p);
+}
+/** 是否该跑自动 GC:距上次 ≥ interval(或从未跑过)。env MOCODE_AUTO_GC=false 可关闭。 */
+export function shouldAutoGc(sessionsRoot, now = Date.now()) {
+    if (process.env.MOCODE_AUTO_GC === 'false')
+        return false;
+    const last = readLastAutoGc(sessionsRoot);
+    return last === null || now - last >= AUTO_GC_INTERVAL_MS;
+}
+function dirSize(dir) {
+    let total = 0;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        try {
+            total += entry.isDirectory() ? dirSize(full) : statSync(full).size;
+        }
+        catch {
+            // 统计尽力而为。
+        }
+    }
+    return total;
+}
+/** 从 SessionRecord 提取会话摘要(role:system 且以标记开头的消息),无则空串。 */
+function extractSummary(record) {
+    for (const m of record.history) {
+        if (m.role !== 'system')
+            continue;
+        const c = m.content;
+        if (typeof c === 'string' && c.startsWith(SUMMARY_MARKER))
+            return c;
+    }
+    return '';
+}
+// ── index.jsonl 读写 ─────────────────────────────────────────────────────
+export function readArchiveIndex(indexPath) {
+    if (!existsSync(indexPath))
+        return [];
+    const out = [];
+    for (const line of readFileSync(indexPath, 'utf8').split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = JSON.parse(line);
+            if (e && typeof e.id === 'string')
+                out.push(e);
+        }
+        catch {
+            // 跳过损坏行。
+        }
+    }
+    return out;
+}
+/** 整文件原子写:tmp+rename。 */
+function writeArchiveIndex(indexPath, entries) {
+    const tmp = indexPath + '.tmp';
+    writeFileSync(tmp, entries.map((e) => JSON.stringify(e)).join('\n') + (entries.length ? '\n' : ''), 'utf8');
+    renameSync(tmp, indexPath);
+}
+/** upsert 一条索引(按 id 覆盖)。 */
+export function upsertArchiveIndex(indexPath, entry) {
+    const entries = readArchiveIndex(indexPath).filter((e) => e.id !== entry.id);
+    entries.push(entry);
+    entries.sort((a, b) => (a.id < b.id ? 1 : a.id > b.id ? -1 : 0));
+    writeArchiveIndex(indexPath, entries);
+}
+// ── 计划(不落盘)──────────────────────────────────────────────────────────
+/**
+ * 生成 retention 计划。
+ * @param excludeCurrentId 当前活跃会话 id,永不归档。
+ */
+export function planRetention(sessionsRoot, policy = DEFAULT_RETENTION_POLICY, now = Date.now(), excludeCurrentId) {
+    const items = [];
+    const paths = retentionPaths(sessionsRoot);
+    // ① 待归档的活会话目录
+    if (existsSync(sessionsRoot)) {
+        for (const entry of readdirSync(sessionsRoot, { withFileTypes: true })) {
+            if (!entry.isDirectory() || entry.name === 'archive')
+                continue;
+            if (!/^\d{8}-\d{6}/.test(entry.name))
+                continue;
+            if (entry.name === excludeCurrentId)
+                continue;
+            const dir = path.join(sessionsRoot, entry.name);
+            const sessionPath = path.join(dir, 'session.json');
+            if (!existsSync(sessionPath))
+                continue;
+            // Date.now() 截断毫秒而 mtimeMs 带小数:新写入文件 age 可能微负,
+            // clamp 到 0 避免阈值 0(=立即归档)下把刚写入的会话误判为未超龄跳过。
+            const ageDays = Math.max(0, now - statSync(sessionPath).mtimeMs) / DAY_MS;
+            if (ageDays < policy.archiveAfterDays)
+                continue;
+            let firstUser = '';
+            try {
+                const rec = JSON.parse(readFileSync(sessionPath, 'utf8'));
+                firstUser = rec.firstUser ?? '';
+            }
+            catch {
+                // 损坏文件仍可归档,firstUser 留空。
+            }
+            items.push({ id: entry.name, ageDays, action: 'archive', firstUser, sizeBytes: dirSize(dir) });
+        }
+    }
+    // ② 待 purge 的归档 gz
+    if (existsSync(paths.archiveDir)) {
+        for (const entry of readdirSync(paths.archiveDir, { withFileTypes: true })) {
+            if (!entry.isFile() || !entry.name.endsWith('.json.gz'))
+                continue;
+            const id = entry.name.replace(/\.json\.gz$/, '');
+            const full = path.join(paths.archiveDir, entry.name);
+            const ageDays = Math.max(0, now - statSync(full).mtimeMs) / DAY_MS;
+            if (ageDays < policy.purgeAfterDays)
+                continue;
+            const idx = readArchiveIndex(paths.indexPath).find((e) => e.id === id);
+            items.push({ id, ageDays, action: 'purge', firstUser: idx?.firstUser ?? '', sizeBytes: statSync(full).size });
+        }
+    }
+    items.sort((a, b) => (a.id < b.id ? 1 : -1));
+    return { items, bytesReclaimable: items.reduce((s, i) => s + i.sizeBytes, 0) };
+}
+// ── 执行 ─────────────────────────────────────────────────────────────────
+/** 归档单个会话:读 session.json → gzip → 写 index → 删原目录。失败抛错由调用方统一处理。 */
+function archiveSession(sessionsRoot, id, now) {
+    const paths = retentionPaths(sessionsRoot);
+    const dir = path.join(sessionsRoot, id);
+    const sessionPath = path.join(dir, 'session.json');
+    const record = JSON.parse(readFileSync(sessionPath, 'utf8'));
+    mkdirSync(paths.archiveDir, { recursive: true });
+    const gzPath = path.join(paths.archiveDir, `${id}.json.gz`);
+    writeFileSync(gzPath + '.tmp', gzipSync(readFileSync(sessionPath)));
+    renameSync(gzPath + '.tmp', gzPath);
+    upsertArchiveIndex(paths.indexPath, {
+        id: record.id,
+        createdAt: record.createdAt,
+        model: record.model,
+        firstUser: record.firstUser,
+        summary: extractSummary(record),
+        archivedAt: new Date(now).toISOString(),
+    });
+    rmSync(dir, { recursive: true, force: true });
+}
+/** purge 单个归档:删 gz,index 行保留并标 purgedAt。 */
+function purgeArchived(sessionsRoot, id, now) {
+    const paths = retentionPaths(sessionsRoot);
+    const gzPath = path.join(paths.archiveDir, `${id}.json.gz`);
+    if (existsSync(gzPath))
+        unlinkSync(gzPath);
+    const entries = readArchiveIndex(paths.indexPath);
+    const e = entries.find((x) => x.id === id);
+    if (e && !e.purgedAt) {
+        e.purgedAt = new Date(now).toISOString();
+        writeArchiveIndex(paths.indexPath, entries);
+    }
+}
+/** 值得跑巩固的最短 history 长度;过短会话没有可沉淀的内容。 */
+const MIN_MESSAGES_TO_REFLECT = 6;
+/** 后台巩固单次超时:比 runReflection 默认 60s 更短,避免后台静默挂一串慢请求。 */
+const CONSOLIDATE_TIMEOUT_MS = 20000;
+/**
+ * 按计划执行归档/清除。**核心动作(归档/删正文)同步秒完并立即返回**。
+ *
+ * 记忆巩固(P2-9)是增强而非归档前提:先读出待归档会话转录、完成归档,
+ * 再把 reflection 放到**后台非阻塞**执行——gc 不再让用户干等 LLM。
+ * 记忆关闭(config.memoryEnabled=false)时完全跳过,不花一分钱。
+ */
+export async function runRetention(sessionsRoot, plan, now = Date.now()) {
+    let archived = 0;
+    let purged = 0;
+    let bytesReclaimed = 0;
+    const pendingTranscripts = [];
+    for (const item of plan.items) {
+        if (item.action === 'archive') {
+            if (config.memoryEnabled) {
+                const transcript = readTranscript(sessionsRoot, item.id);
+                if (transcript)
+                    pendingTranscripts.push(transcript);
+            }
+            archiveSession(sessionsRoot, item.id, now);
+            archived++;
+        }
+        else {
+            purgeArchived(sessionsRoot, item.id, now);
+            purged++;
+        }
+        bytesReclaimed += item.sizeBytes;
+    }
+    // 后台巩固:不 await、不阻塞返回。单项失败已在 runReflection 内部兜底。
+    for (const transcript of pendingTranscripts) {
+        void runReflection(transcript, AbortSignal.timeout(CONSOLIDATE_TIMEOUT_MS));
+    }
+    return { archived, purged, bytesReclaimed };
+}
+/** 读会话转录快照;history 过短或读取失败返回 null(跳过巩固)。 */
+function readTranscript(sessionsRoot, id) {
+    try {
+        const sessionPath = path.join(sessionsRoot, id, 'session.json');
+        const record = JSON.parse(readFileSync(sessionPath, 'utf8'));
+        const history = record.history;
+        if (!Array.isArray(history) || history.length < MIN_MESSAGES_TO_REFLECT)
+            return null;
+        return snapshotTranscript(history, 20);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 跨会话搜索归档索引(episodic 层):BM25 over firstUser + summary。
+ * 已 purge 的会话同样可命中——meta+摘要永久保留,只是不可整段恢复。
+ */
+export function searchArchiveIndex(sessionsRoot, query, limit = 10) {
+    const entries = readArchiveIndex(retentionPaths(sessionsRoot).indexPath);
+    if (entries.length === 0 || !query.trim())
+        return [];
+    const index = new TextSearchIndex(entries.map((e) => ({
+        id: e.id,
+        fields: [
+            { text: e.firstUser, weight: 3 },
+            { text: e.summary, weight: 1 },
+        ],
+    })));
+    const byId = new Map(entries.map((e) => [e.id, e]));
+    const hits = [];
+    for (const h of index.search(query, limit)) {
+        const e = byId.get(h.id);
+        if (e)
+            hits.push({ ...e, score: h.score });
+    }
+    return hits;
+}
+/** 读回一个已归档(未 purge)的完整 SessionRecord;已 purge/不存在返 null。 */
+export function loadArchivedSession(sessionsRoot, id) {
+    const gzPath = path.join(retentionPaths(sessionsRoot).archiveDir, `${id}.json.gz`);
+    if (!existsSync(gzPath))
+        return null;
+    try {
+        return JSON.parse(gunzipSync(readFileSync(gzPath)).toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/session/scheduler.js

@@ -5,6 +5,7 @@ import { chatTools } from '../llm/index.js';
 import { defaultCompactionRuntime, maybeCompact, contextState, } from './compact.js';
 import { pruneStaleArtifacts, refreshArtifactFreshness } from '../context/artifacts.js';
 import { pruneSuperseded } from '../context/relevance.js';
+import { clearRetrievableResults } from '../context/clearing.js';
 import { createAgeAwareEncodingState } from '../context/age-aware.js';
 function atPressure(report) {
     return Math.max(report.rawTotal, report.total) >= report.window * DEFAULT_BUDGET_POLICY.pressureTriggerRatio;
@@ -12,11 +13,13 @@ function atPressure(report) {
 function emptyPressure(report) {
     return {
         triggered: false,
+        lowTriggered: false,
         before: report.total,
         after: report.total,
         superseded: 0,
         staleArtifacts: 0,
         encodedLogsAndSearches: 0,
+        cleared: 0,
     };
 }
 /** One scheduler instance is owned by one agent run. */
@@ -29,11 +32,14 @@ export function createBudgetScheduler(state = contextState, runtime = defaultCom
             refreshArtifactFreshness(state, history);
             const report = evaluate(history, step, activeTools, ephemeralTokens);
             const pressure = emptyPressure(report);
-            pressure.triggered = atPressure(report);
+            const occupancy = Math.max(report.rawTotal, report.total);
+            pressure.triggered = occupancy >= report.window * DEFAULT_BUDGET_POLICY.pressureTriggerRatio;
+            pressure.lowTriggered = !pressure.triggered && occupancy >= report.window * runtime.config.lowPressureRatio;
             if (pressure.triggered) {
                 // A single 80% pressure event owns every history rewrite. Run all enabled
                 // low-cost cleanup first, then always compact; do not introduce per-stage
                 // thresholds or stop early when one stage happens to cross below 80%.
+                // 注意:此阶段不跑 tool-clearing——旧区内容马上要喂给摘要器,清掉会把摘要弄瞎。
                 if (runtime.config.contextRelprune) {
                     pressure.superseded = pruneSuperseded(history, report.hotBoundary);
                 }
@@ -44,12 +50,33 @@ export function createBudgetScheduler(state = contextState, runtime = defaultCom
                 }
                 pressure.after = evaluate(history, step, activeTools, ephemeralTokens).total;
             }
+            else if (pressure.lowTriggered) {
+                // 60-80% 低压:只做零 LLM 成本的确定性清理(masking/clearing),不摘要、不重建。
+                // 可重取结果在此阶段丢弃;热区(最近 4 user turn)不动。各步幂等,占用停留在
+                // 低压带时重复执行也很便宜。
+                if (runtime.config.contextRelprune) {
+                    pressure.superseded = pruneSuperseded(history, report.hotBoundary);
+                }
+                pressure.staleArtifacts = pruneStaleArtifacts(state, history, report.hotBoundary);
+                if (runtime.config.toolClearing) {
+                    pressure.cleared = clearRetrievableResults(history, report.hotBoundary);
+                }
+                if (runtime.config.contextOptimize) {
+                    const ageAware = createAgeAwareEncodingState(history);
+                    pressure.encodedLogsAndSearches = ageAware.sweepPressure(history, report.hotBoundary);
+                }
+                pressure.after = evaluate(history, step, activeTools, ephemeralTokens).total;
+            }
             // Use the trigger report intentionally: cleanup may reduce the current estimate,
             // but crossing 80% commits this step to compacting for maximum token savings.
-            const actions = scheduleActions(report);
+            // 低压不进 LLM 压缩:actions 仅在 80% 高压时生成。
+            const actions = pressure.triggered ? scheduleActions(report) : [];
             let compactHistoryCalled = false;
             let historyRebuilt = false;
-            let contentMutated = pressure.superseded > 0 || pressure.staleArtifacts > 0 || pressure.encodedLogsAndSearches > 0;
+            let contentMutated = pressure.superseded > 0 ||
+                pressure.staleArtifacts > 0 ||
+                pressure.encodedLogsAndSearches > 0 ||
+                pressure.cleared > 0;
             for (const _action of actions) {
                 const result = await maybeCompact(history, report, undefined, state, activeTools, signal, runtime);
                 compactHistoryCalled = true;

package/dist/session/store.js

@@ -1,7 +1,10 @@
 import { randomUUID } from 'node:crypto';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { gzipSync } from 'node:zlib';
 import path from 'node:path';
+import { MAX_TRACE_BYTES, MAX_TRACE_ROTATIONS } from '../tools/constants.js';
+import { loadArchivedSession, readArchiveIndex, retentionPaths } from './retention.js';
 import { config, getActiveModel } from '../config/index.js';
 import { getWorkspaceRoot } from '../workspace/index.js';
 import { isToolRouteGroupName } from '../config/profiles.js';
@@ -110,18 +113,95 @@ export class SessionStore {
     artifactPath(id, filename) {
         return path.join(this.sessionsRoot, id, filename);
     }
+    /**
+     * 追加一条 trace 事件;当前 trace.jsonl 已达 MAX_TRACE_BYTES 时先轮转:
+     * 旧内容 gzip 成 trace.1.jsonl.gz,既有轮转依次后移(只留最近 MAX_TRACE_ROTATIONS 份),
+     * 然后清空当前文件。纯诊断数据,任何失败静默降级为普通追加。
+     */
     appendTrace(id, value) {
         try {
             const dir = path.join(this.sessionsRoot, id);
             mkdirSync(dir, { recursive: true });
             const line = `${JSON.stringify(value)}\n`;
             const tracePath = path.join(dir, 'trace.jsonl');
+            // env 覆盖仅供测试:MOCODE_MAX_TRACE_BYTES=200 可立刻触发轮转。
+            const envMax = Number(process.env.MOCODE_MAX_TRACE_BYTES);
+            const maxTraceBytes = Number.isFinite(envMax) && envMax >= 0 ? envMax : MAX_TRACE_BYTES;
+            const size = existsSync(tracePath) ? statSync(tracePath).size : 0;
+            if (size >= maxTraceBytes) {
+                this.rotateTrace(dir, tracePath);
+            }
             writeFileSync(tracePath, line, { encoding: 'utf8', flag: 'a' });
         }
         catch {
             // Observability is best-effort and cannot block coding work.
         }
     }
+    rotateTrace(dir, tracePath) {
+        const rotPath = (n) => path.join(dir, `trace.${n}.jsonl.gz`);
+        // 最老的一份硬删;其余从老到新依次后移,腾出 trace.1。
+        try {
+            if (existsSync(rotPath(MAX_TRACE_ROTATIONS)))
+                unlinkSync(rotPath(MAX_TRACE_ROTATIONS));
+        }
+        catch {
+            // 删失败不致命,rename 覆盖亦可。
+        }
+        for (let n = MAX_TRACE_ROTATIONS - 1; n >= 1; n--) {
+            const from = rotPath(n);
+            if (!existsSync(from))
+                continue;
+            try {
+                renameSync(from, rotPath(n + 1));
+            }
+            catch {
+                // Windows 下目标存在时 rename 可能失败:尝试删目标再移。
+                try {
+                    unlinkSync(rotPath(n + 1));
+                    renameSync(from, rotPath(n + 1));
+                }
+                catch {
+                    // 放弃这份轮转,保留新 gz 更重要。
+                }
+            }
+        }
+        const content = readFileSync(tracePath);
+        writeFileSync(rotPath(1), gzipSync(content));
+        writeFileSync(tracePath, '');
+    }
+    /**
+     * 追加一条 per-step 用量记录到 <id>/usage.jsonl(#token-efficiency P1)。
+     * 与 appendTrace 同策略:纯诊断,失败静默,不做轮转(长会话的量级远小于 trace)。
+     */
+    appendUsage(id, value) {
+        try {
+            const dir = path.join(this.sessionsRoot, id);
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(path.join(dir, 'usage.jsonl'), `${JSON.stringify(value)}\n`, { encoding: 'utf8', flag: 'a' });
+        }
+        catch {
+            // Metrics must never block coding work.
+        }
+    }
+    /** 读取 <id>/usage.jsonl 全部记录;文件不存在或损坏行跳过。 */
+    readUsage(id) {
+        const file = path.join(this.sessionsRoot, id, 'usage.jsonl');
+        if (!existsSync(file))
+            return [];
+        const out = [];
+        for (const line of readFileSync(file, 'utf8').split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                out.push(JSON.parse(trimmed));
+            }
+            catch {
+                // 跳过损坏行。
+            }
+        }
+        return out;
+    }
     save(history, id, queryHistory = [], lastToolGroups = []) {
         const meta = {
             id,
@@ -143,7 +223,11 @@ export class SessionStore {
             queryHistory: [...queryHistory],
             lastToolGroups: [...lastToolGroups],
         };
-        writeFileSync(currentPath, JSON.stringify(record), 'utf8');
+        // 原子落盘:先写同目录 tmp 再 rename——全量重写(长会话可达数 MB)中途崩溃/断电
+        // 不会留下半个 JSON 把整个会话写坏(对齐 memory/store.ts writeAtomic)。
+        const tmpPath = path.join(this.sessionsRoot, id, 'session.json.tmp');
+        writeFileSync(tmpPath, JSON.stringify(record), 'utf8');
+        renameSync(tmpPath, currentPath);
         if (existsSync(legacyPath))
             unlinkSync(legacyPath);
         return meta;
@@ -151,9 +235,12 @@ export class SessionStore {
     load(id) {
         const currentPath = this.sessionPath(id);
         const legacyPath = path.join(this.sessionsRoot, `${id}.json`);
-        const source = existsSync(currentPath) ? currentPath : legacyPath;
-        if (!existsSync(source))
-            return null;
+        let source = existsSync(currentPath) ? currentPath : legacyPath;
+        // 活会话与 legacy 单文件都没有:回退从归档 gz 取回(30-90 天的会话仍可 resume)。
+        if (!existsSync(source)) {
+            const archived = loadArchivedSession(this.sessionsRoot, id);
+            return archived ?? null;
+        }
         try {
             const rec = JSON.parse(readFileSync(source, 'utf8'));
             if (!rec || !Array.isArray(rec.history))
@@ -211,7 +298,22 @@ export class SessionStore {
                 // 跳过损坏文件。
             }
         }
-        return out;
+        // 归档(未 purge)会话并入列表:正文在 archive/<id>.json.gz,仍可按 id resume。
+        // 与 live 去重(理论上不会重叠),按时间统一降序后再截 limit。
+        const liveIds = new Set(out.map((m) => m.id));
+        for (const e of readArchiveIndex(retentionPaths(root).indexPath)) {
+            if (e.purgedAt || liveIds.has(e.id))
+                continue;
+            out.push({
+                id: e.id,
+                createdAt: e.createdAt ?? idToIso(e.id),
+                model: e.model ?? '',
+                firstUser: e.firstUser ?? '',
+                archived: true,
+            });
+        }
+        out.sort((a, b) => (a.createdAt < b.createdAt ? 1 : a.createdAt > b.createdAt ? -1 : 0));
+        return Number.isFinite(maxResults) ? out.slice(0, maxResults) : out;
     }
 }
 /** 旧函数 API 的进程级兼容实例；session root 每次读取 config，保留测试和运行时切换语义。 */