mocode-ai 1.6.4 → 1.6.5

package/dist/repl/commands/model-actions.js

@@ -0,0 +1,138 @@
+/**
+ * 模型命令的共享动作（#模型命令交互）：应用预设、添加目录模型、刷新目录。
+ *
+ * 从 model-catalog.ts 抽出，供「统一模型面板」与旧 /model browse 复用，避免第三处重复。
+ * 纯编排：UI 走 promptIntervention，落盘走 presets/file，运行时切 config。
+ */
+import * as layout from '../../ui/layout.js';
+import { ui } from '../../ui/theme.js';
+import { bannerLines } from '../../ui/render.js';
+import { config, updateModelConfig } from '../../config/index.js';
+import { writeConfigKeys } from '../../config/file.js';
+import { savePreset, setActivePresetName } from '../../config/presets.js';
+import { reconfigureClient } from '../../llm/index.js';
+import { promptIntervention } from '../../ui/intervention.js';
+import { renderHistory } from '../message-format.js';
+import { refreshCatalog } from '../../models/catalog.js';
+import { buildPreset, defaultPresetName, resolveApiKey } from '../../models/map-preset.js';
+/** 应用预设到 config + 落 config 文件 + 重建 client + 重显。 */
+export function applyPresetConfig(ctx, p) {
+    updateModelConfig({
+        provider: p.provider,
+        model: p.model,
+        baseURL: p.baseURL,
+        apiKey: p.apiKey,
+        contextWindowTokens: p.contextWindow,
+        anthropicPromptCache: p.anthropicPromptCache,
+        ...(p.reasoningEffort ? { reasoningEffort: p.reasoningEffort } : {}),
+    });
+    writeConfigKeys({
+        LLM_PROVIDER: p.provider,
+        LLM_BASE_URL: p.baseURL,
+        LLM_API_KEY: p.apiKey,
+        LLM_MODEL: p.model,
+        CONTEXT_WINDOW_TOKENS: String(p.contextWindow),
+        ANTHROPIC_PROMPT_CACHE: p.anthropicPromptCache ? 'true' : 'false',
+    });
+    reconfigureClient();
+    ctx.refreshStatusBase(ctx.history);
+    layout.clearContent();
+    if (ctx.history.some((m) => m.role === 'user'))
+        renderHistory(ctx.history);
+    else
+        layout.writeBanner(bannerLines(ctx.banner()));
+}
+/**
+ * 把一个目录模型添加为预设并激活。
+ * @returns 'added' 已切换；'cancelled' 用户中途取消。
+ */
+export async function addCatalogModel(ctx, entry, providers) {
+    const catalogProvider = providers[entry.providerId];
+    if (!catalogProvider)
+        return 'cancelled';
+    // key：无论环境变量是否找到，都弹一次确认——回车沿用预填值、粘贴即覆盖。
+    const envName = catalogProvider.env?.[0] ?? 'API_KEY';
+    const detectedKey = resolveApiKey(catalogProvider);
+    const kres = await promptIntervention({
+        type: 'input',
+        title: `${envName}`,
+        detail: detectedKey
+            ? `已从环境变量 ${envName} 预填 key；回车沿用，或粘贴新 key 覆盖（仅存入本预设与配置文件）。`
+            : `未在环境变量 ${envName} 找到 key；粘贴该厂商 key（仅存入本预设与配置文件）。`,
+        seed: detectedKey ?? '',
+    });
+    if (kres.action === 'cancelled')
+        return 'cancelled';
+    const apiKey = (kres.value ?? '').trim();
+    if (!apiKey) {
+        layout.contentWrite(`${ui.yellow}未提供 key，已取消。${ui.reset}\n`);
+        return 'cancelled';
+    }
+    const built = buildPreset({ provider: catalogProvider, model: entry.model, apiKey });
+    if (!built) {
+        layout.contentWrite(`${ui.yellow}该模型当前协议不支持直发。${ui.reset}\n`);
+        return 'cancelled';
+    }
+    const nres = await promptIntervention({
+        type: 'input',
+        title: '预设名',
+        detail: '回车用默认名；可改名。',
+        seed: defaultPresetName(entry.providerId, entry.modelId),
+    });
+    if (nres.action === 'cancelled')
+        return 'cancelled';
+    built.name = (nres.value ?? '').trim() || built.name;
+    const mres = await promptIntervention({
+        type: 'input',
+        title: '下发模型名',
+        detail: `端点 ${built.baseURL}\n一般保持默认；厂商要求专用 ID（如火山 endpoint id）时在此修改。`,
+        seed: built.model,
+    });
+    if (mres.action === 'cancelled')
+        return 'cancelled';
+    built.model = (mres.value ?? '').trim() || built.model;
+    const preset = {
+        ...built,
+        catalogProvider: entry.providerId,
+        catalogModel: entry.modelId,
+        capabilities: {
+            ...(typeof entry.model.reasoning === 'boolean' ? { reasoning: entry.model.reasoning } : {}),
+            ...(entry.model.reasoning_options ? { reasoningOptions: entry.model.reasoning_options } : {}),
+            ...(typeof entry.model.tool_call === 'boolean' ? { toolCall: entry.model.tool_call } : {}),
+            ...(typeof entry.model.attachment === 'boolean' ? { attachment: entry.model.attachment } : {}),
+        },
+        ...(entry.model.cost
+            ? {
+                pricing: {
+                    ...(typeof entry.model.cost.input === 'number' ? { input: entry.model.cost.input } : {}),
+                    ...(typeof entry.model.cost.output === 'number' ? { output: entry.model.cost.output } : {}),
+                    ...(typeof entry.model.cost.cache_read === 'number' ? { cacheRead: entry.model.cost.cache_read } : {}),
+                },
+            }
+            : {}),
+    };
+    savePreset(preset);
+    try {
+        setActivePresetName(preset.name);
+    }
+    catch {
+        /* 指针失败不阻断 */
+    }
+    applyPresetConfig(ctx, preset);
+    layout.contentWrite(`${ui.dim}(已添加并切换 → ${preset.model} · ${preset.provider} @ ${preset.baseURL})${ui.reset}\n`);
+    layout.contentWrite(`${ui.dim}(已存为预设 “${preset.name}”)${ui.reset}\n`);
+    return 'added';
+}
+/** 强制刷新目录并打印统计。 */
+export async function refreshAndReport() {
+    const r = await refreshCatalog();
+    const n = Object.values(r.providers).reduce((acc, p) => acc + Object.keys(p.models ?? {}).length, 0);
+    if (r.source === 'empty') {
+        layout.contentWrite(`${ui.yellow}刷新失败且无本地快照。${ui.reset}\n`);
+    }
+    else {
+        const tag = r.source === 'live' ? '已更新' : '离线，使用快照';
+        layout.contentWrite(`${ui.dim}模型目录${tag}：${Object.keys(r.providers).length} 厂商 / ${n} 模型（${r.fetchedAt?.slice(0, 10)}）${ui.reset}\n`);
+    }
+}
+export { config };

package/dist/repl/commands/model-catalog.js

@@ -0,0 +1,67 @@
+/**
+ * 模型目录命令（#model-catalog，兼容入口）：/model browse · /model catalog [refresh]
+ *
+ * 交互逻辑已抽到 model-actions.ts，统一模型面板（裸 /model）与这里共用同一套动作。
+ * 本文件只保留命令路由与目录无参查看。
+ */
+import * as layout from '../../ui/layout.js';
+import { ui } from '../../ui/theme.js';
+import { promptIntervention } from '../../ui/intervention.js';
+import { loadCatalog } from '../../models/catalog.js';
+import { searchModels } from '../../models/search.js';
+import { addCatalogModel, refreshAndReport } from './model-actions.js';
+import { unhandled, next } from './types.js';
+/** 一次 browse 列表上限（统一面板可滚动更多；此兼容入口保持收窄）。 */
+const MAX_BROWSE = 30;
+export const modelCatalogCommands = [
+    async (ctx) => {
+        const { line } = ctx;
+        if (line === '/model browse' || line.startsWith('/model browse ')) {
+            const cat = await loadCatalog();
+            if (cat.source === 'empty' || Object.keys(cat.providers).length === 0) {
+                layout.contentWrite(`${ui.yellow}暂无模型目录且离线：联网后 /model catalog refresh，或用 /model 配置。${ui.reset}\n`);
+                return next();
+            }
+            // 兼容 browse：先输入关键字，再从收窄结果里选（添加动作与统一面板一致）。
+            const qres = await promptIntervention({
+                type: 'input',
+                title: '搜索模型',
+                detail: '输入厂商/模型关键字（glm、qwen、claude、doubao…），回车列出。',
+                seed: '',
+            });
+            if (qres.action === 'cancelled')
+                return next();
+            const query = (qres.value ?? '').trim();
+            const results = searchModels(cat.providers, { query }).slice(0, MAX_BROWSE);
+            if (results.length === 0) {
+                layout.contentWrite(`${ui.yellow}没有匹配 “${query}” 的可直发模型。${ui.reset}\n`);
+                return next();
+            }
+            const sel = await promptIntervention({
+                type: 'choice',
+                title: `选择模型（${results.length}）`,
+                options: results.map((e) => e.model.name || e.modelId),
+                allowCustom: false,
+            });
+            if (sel.action === 'cancelled')
+                return next();
+            const picked = results.find((e) => (e.model.name || e.modelId) === sel.value);
+            if (picked)
+                await addCatalogModel(ctx, picked, cat.providers);
+            return next();
+        }
+        if (line === '/model catalog' || line === '/model catalog refresh') {
+            if (line === '/model catalog refresh')
+                await refreshAndReport();
+            else {
+                const cat = await loadCatalog();
+                const n = Object.values(cat.providers).reduce((acc, p) => acc + Object.keys(p.models ?? {}).length, 0);
+                layout.contentWrite(cat.source === 'empty'
+                    ? `${ui.yellow}本地无目录：/model catalog refresh 拉取。${ui.reset}\n`
+                    : `${ui.dim}目录（${cat.source === 'live' ? '在线' : '快照'}）：${Object.keys(cat.providers).length} 厂商 / ${n} 模型（${cat.fetchedAt?.slice(0, 10)}）${ui.reset}\n`);
+            }
+            return next();
+        }
+        return unhandled();
+    },
+];

package/dist/repl/commands/model-panel-ui.js

@@ -0,0 +1,107 @@
+/**
+ * 统一模型面板的交互编排（#模型命令交互）：openModelPanel。
+ *
+ * 两级浏览：先列厂商，进入某厂商后再列其下模型/预设；搜索栏为作用域内过滤——
+ * 顶层只按厂商名、厂商内只按模型名，不跨层混搜。思考强度统一在 /effort 设置，
+ * 不放进模型面板。动作复用 model-actions.ts。
+ */
+import * as layout from '../../ui/layout.js';
+import { ui } from '../../ui/theme.js';
+import { promptHierarchicalPicker } from '../../ui/hierarchical-picker.js';
+import { promptIntervention } from '../../ui/intervention.js';
+import { loadCatalog } from '../../models/catalog.js';
+import { flattenCatalog } from '../../models/search.js';
+import { buildModelTree } from '../../models/model-panel.js';
+import { config } from '../../config/index.js';
+import { savePreset } from '../../config/presets.js';
+import { applyPresetConfig, addCatalogModel, refreshAndReport } from './model-actions.js';
+/**
+ * 选中已存预设时确认 API key：回车沿用当前 key；粘贴新值则更新并写回预设文件。
+ * 修复「预设里存着失效 key、重选同一模型又静默套用 → 401 死循环」——套用任何预设前
+ * 都给一次改 key 的机会。取消返回 null。
+ */
+async function confirmPresetKey(preset) {
+    const res = await promptIntervention({
+        type: 'input',
+        title: 'API Key',
+        detail: `端点：${preset.baseURL}\n` + `回车沿用当前 key；认证失败时粘贴新 key（会一并写回预设 “${preset.name}”）。`,
+        seed: preset.apiKey,
+    });
+    if (res.action === 'cancelled')
+        return null;
+    const v = (res.value ?? '').trim();
+    if (!v || v === preset.apiKey)
+        return preset;
+    const updated = { ...preset, apiKey: v };
+    savePreset(updated);
+    return updated;
+}
+/** 域模型树 → 层级选择器节点（叶子 value 为 PanelChoice）。 */
+function toHPNode(node) {
+    const base = {
+        searchText: node.searchText,
+        label: node.label,
+        detail: node.detail,
+    };
+    if (node.children && node.children.length) {
+        base.children = node.children.map(toHPNode);
+    }
+    else if (node.choice) {
+        base.value = node.choice;
+    }
+    return base;
+}
+/**
+ * 打开统一模型面板。
+ * @returns 'custom' 表示用户选了「手动填写」，调用方回落到手填向导；其余均已处理。
+ */
+export async function openModelPanel(ctx) {
+    // 目录：新鲜快照不联网；离线/无快照仍能列已存预设与操作行。
+    const cat = await loadCatalog();
+    const catalog = flattenCatalog(cat.providers);
+    const tree = buildModelTree({
+        presets: listAllPresets(),
+        providers: cat.providers,
+        catalog,
+        current: {
+            provider: config.provider,
+            baseURL: config.baseURL,
+            model: config.model,
+            contextWindowTokens: config.contextWindowTokens,
+        },
+    });
+    const srcTag = cat.source === 'empty' ? '无目录' : cat.source === 'live' ? '在线目录' : '目录快照';
+    const picked = await promptHierarchicalPicker({
+        title: `选择模型（${srcTag}）`,
+        roots: tree.map(toHPNode),
+        maxVisible: 12,
+    });
+    if (!picked)
+        return 'handled'; // Esc：什么都不做
+    switch (picked.kind) {
+        case 'preset': {
+            const confirmed = await confirmPresetKey(picked.preset);
+            if (!confirmed)
+                return 'handled';
+            applyPresetConfig(ctx, confirmed);
+            layout.contentWrite(`${ui.dim}(已切换 → ${confirmed.model})${ui.reset}\n`);
+            return 'handled';
+        }
+        case 'catalog':
+            await addCatalogModel(ctx, picked.entry, cat.providers);
+            return 'handled';
+        case 'action':
+            if (picked.action === 'custom')
+                return 'custom';
+            if (picked.action === 'refresh') {
+                await refreshAndReport();
+                return 'handled';
+            }
+            return 'handled';
+    }
+}
+// 延迟取预设列表，避免在模块顶部引入多余耦合。
+import { listPresets } from '../../config/presets.js';
+function listAllPresets() {
+    return listPresets();
+}

package/dist/repl/commands/model.js

@@ -19,6 +19,7 @@ import { config, updateModelConfig } from '../../config/index.js';
 import { writeConfigKeys, CONFIG_PATH } from '../../config/file.js';
 import { deletePreset, getPreset, isValidPresetName, listPresets, savePreset, setActivePresetName, } from '../../config/presets.js';
 import { reconfigureClient } from '../../llm/index.js';
+import { recognizesReasoning } from '../../llm/reasoning.js';
 import { promptIntervention } from '../../ui/intervention.js';
 import { renderHistory } from '../message-format.js';
 import { MODEL_PRESETS, maskKey } from '../commands.js';
@@ -57,6 +58,13 @@ export const modelCommands = [
             return unhandled();
         const arg = line.startsWith('/model ') ? line.slice('/model '.length).trim() : '';
         const { history } = ctx;
+        // 裸 /model → 统一模型面板(打字过滤+预设+目录+思考强度)。选「自定义」才落到下方手填向导。
+        if (arg === '') {
+            const { openModelPanel } = await import('./model-panel-ui.js');
+            const outcome = await openModelPanel(ctx);
+            if (outcome !== 'custom')
+                return next();
+        }
         // 共用:apply 一个预设到 config + 持久化 + 重建 client + 重显横幅。无参 /model 选菜单和 /model use 都走这里。
         const applyPresetAndPersist = (target) => {
             updateModelConfig({
@@ -66,6 +74,7 @@ export const modelCommands = [
                 apiKey: target.apiKey,
                 contextWindowTokens: target.contextWindow,
                 anthropicPromptCache: target.anthropicPromptCache,
+                ...(target.reasoningEffort ? { reasoningEffort: target.reasoningEffort } : {}),
             });
             writeConfigKeys({
                 LLM_PROVIDER: target.provider,
@@ -74,6 +83,7 @@ export const modelCommands = [
                 LLM_MODEL: target.model,
                 CONTEXT_WINDOW_TOKENS: String(target.contextWindow),
                 ANTHROPIC_PROMPT_CACHE: target.anthropicPromptCache ? 'true' : 'false',
+                ...(target.reasoningEffort ? { REASONING_EFFORT: target.reasoningEffort } : {}),
             });
             reconfigureClient();
             // 记为激活预设:让上下文窗口等配置从此跟随该预设文件(下次启动也用它,不再回退 config 裸键)。
@@ -167,6 +177,13 @@ export const modelCommands = [
             layout.contentWrite(`  ${ui.accent}baseURL ${ui.reset}  ${config.baseURL}\n`);
             layout.contentWrite(`  ${ui.accent}apiKey  ${ui.reset}  ${maskKey(config.apiKey)}\n`);
             layout.contentWrite(`  ${ui.accent}model   ${ui.reset}  ${config.model}\n`);
+            const recognized = recognizesReasoning({
+                provider: config.provider === 'anthropic' ? 'anthropic' : 'openai',
+                model: config.model,
+                maxTokens: config.maxTokens,
+            });
+            layout.contentWrite(`  ${ui.accent}effort  ${ui.reset}  ${config.reasoningEffort}` +
+                (recognized ? '\n' : `${ui.dim}(当前模型未识别,参数不会下发)${ui.reset}\n`));
             layout.contentWrite(`  ${ui.accent}窗口    ${ui.reset}  ${config.contextWindowTokens} tokens\n`);
             if (config.provider === 'anthropic') {
                 layout.contentWrite(`  ${ui.accent}缓存    ${ui.reset}  Prompt Cache ${config.anthropicPromptCache ? 'on' : 'off'}\n`);

package/dist/repl/commands/registry.js

@@ -5,12 +5,15 @@ import { modeCommands } from './mode.js';
 import { petCommands } from './pet.js';
 import { imageCommands } from './image.js';
 import { contextCommands } from './context.js';
+import { statsCommands } from './stats.js';
 import { sessionCommands } from './session.js';
 import { memoryCommands } from './memory.js';
 import { skillCommands } from './skill.js';
 import { compactCommands } from './compact.js';
 import { appearanceCommands } from './appearance.js';
 import { modelCommands } from './model.js';
+import { modelCatalogCommands } from './model-catalog.js';
+import { effortCommands } from './effort.js';
 import { routerCommands } from './router.js';
 import { toolGroupCommands } from './tool-group.js';
 /**
@@ -26,11 +29,14 @@ export const commandHandlers = [
     ...petCommands,
     ...imageCommands,
     ...contextCommands,
+    ...statsCommands,
     ...sessionCommands,
     ...memoryCommands,
     ...skillCommands,
     ...compactCommands,
     ...appearanceCommands,
+    ...effortCommands,
+    ...modelCatalogCommands,
     ...modelCommands,
     ...routerCommands,
     ...toolGroupCommands,

package/dist/repl/commands/session.js

@@ -84,6 +84,60 @@ export const sessionCommands = [
         await ctx.resumeFromPick(pick);
         return next();
     },
+    // /session gc [--yes]:老会话垃圾回收。30 天未活动→gzip 归档(archive/),90 天→清正文。
+    // 默认(及 --dry-run)只列计划不写盘;--yes 才执行——删除不可逆,用显式参数而非交互确认。
+    async (ctx) => {
+        const m = /^\/sessions?\s+gc\b(.*)$/.exec(ctx.line);
+        if (!m)
+            return unhandled();
+        const args = (m[1] ?? '').trim();
+        const execute = args === '--yes';
+        if (args && args !== '--yes' && args !== '--dry-run') {
+            layout.contentWrite(`${ui.yellow}用法: /session gc [--dry-run|--yes]${ui.reset}\n`);
+            return next();
+        }
+        const fmtKb = (n) => `${(n / 1024).toFixed(0)}KB`;
+        if (execute) {
+            const result = await ctx.runtime.session.gc({ dryRun: false });
+            layout.contentWrite(`${ui.accent}已归档 ${result.archived}、清除 ${result.purged},回收 ${fmtKb(result.bytesReclaimed)}${ui.reset}\n`);
+            return next();
+        }
+        const plan = ctx.runtime.session.gc({ dryRun: true });
+        if (plan.items.length === 0) {
+            layout.contentWrite(`${ui.dim}(没有需要归档或清除的会话)${ui.reset}\n`);
+            return next();
+        }
+        for (const it of plan.items) {
+            const label = it.action === 'archive' ? `${ui.cyan}归档` : `${ui.yellow}清除`;
+            layout.contentWrite(`  ${label}${ui.reset}  ${it.id}  ${it.ageDays.toFixed(0)}天  ${fmtKb(it.sizeBytes)}  ${it.firstUser}\n`);
+        }
+        layout.contentWrite(`  ${ui.dim}共 ${plan.items.length} 项,可回收 ${fmtKb(plan.bytesReclaimable)}${ui.reset}\n`);
+        layout.contentWrite(`${ui.dim}(dry-run;加 --yes 执行,归档/清除不可逆)${ui.reset}\n`);
+        return next();
+    },
+    // /ssearch <关键词>:跨会话搜索归档(episodic),命中显示 id/日期/摘要。
+    // 未 purge 的会话可直接 /resume <id> 取回;已 purge 仅可检索摘要。
+    (ctx) => {
+        if (!ctx.line.startsWith('/ssearch'))
+            return unhandled();
+        const query = ctx.line.replace(/^\/ssearch\s*/, '').trim();
+        if (!query) {
+            layout.contentWrite(`${ui.yellow}用法: /ssearch <关键词>${ui.reset}\n`);
+            return next();
+        }
+        const hits = ctx.runtime.session.searchArchive(query, 10);
+        if (hits.length === 0) {
+            layout.contentWrite(`${ui.dim}(无匹配归档会话)${ui.reset}\n`);
+            return next();
+        }
+        for (const h of hits) {
+            const tag = h.purgedAt ? ` ${ui.yellow}[仅摘要]${ui.reset}` : ` ${ui.dim}[可 resume]${ui.reset}`;
+            layout.contentWrite(`  ${ui.cyan}${h.id}${ui.reset}  ${h.createdAt}${tag}\n`);
+            const body = (h.summary || h.firstUser).split('\n').slice(0, 4).join('\n');
+            layout.contentWrite(`  ${ui.dim}${body}${ui.reset}\n\n`);
+        }
+        return next();
+    },
     // /rollback:打开轮次菜单(↑/↓ 选,Enter 回滚到该轮并预填其输入,再 Enter 重新跑)。
     // 忽略任何数字参数(原「输数字选回滚」已删,统一走菜单)。无快照的旧轮次(/resume 重建)文件改动不可撤销。
     async (ctx) => {

package/dist/repl/commands/stats.js

@@ -0,0 +1,28 @@
+/**
+ * 用量命令组:/stats(#token-efficiency P1)
+ *
+ * dialog-only:读取当前会话 usage.jsonl,输出 cache 命中率 / 分层用量 / compact 次数。
+ * 后端从未上报 cached 时命中率显示 n/a,不报错。
+ */
+import * as layout from '../../ui/layout.js';
+import { getActiveSessionStore } from '../../session/store.js';
+import { formatUsageSummary, summarizeUsage } from '../../session/usage-stats.js';
+import { unhandled, next } from './types.js';
+export const statsCommands = [
+    (ctx) => {
+        if (ctx.line !== '/stats')
+            return unhandled();
+        const sessionId = ctx.state.currentSessionId;
+        if (!sessionId) {
+            layout.contentWrite('  No active session yet.\n');
+            return next();
+        }
+        const raw = getActiveSessionStore().readUsage(sessionId);
+        if (raw.length === 0) {
+            layout.contentWrite('  No usage recorded yet (run a task first).\n');
+            return next();
+        }
+        layout.contentWrite(`  ${formatUsageSummary(summarizeUsage(raw))}\n`);
+        return next();
+    },
+];

package/dist/repl/commands.js

@@ -24,9 +24,12 @@ export function buildSlashCommands() {
         { name: '/skills', desc: d('commands.skills') },
         { name: '/skill', desc: '执行某个 skill(/skill <name> [args-json])' },
         { name: '/compact', desc: d('commands.compact') },
+        { name: '/stats', desc: '查看本会话 token 用量与缓存命中率' },
+        { name: '/effort', desc: '设置思考强度(/effort [low|medium|high|auto])' },
         { name: '/resume', desc: d('commands.sessionResume') },
         { name: '/sessions', desc: d('commands.sessionBrowse') },
         { name: '/rollback', desc: d('commands.sessionRollback') },
+        { name: '/ssearch <关键词>', value: '/ssearch ', submit: false, desc: '跨会话搜索归档会话' },
         {
             name: '/memory',
             desc: d('commands.memory'),

package/dist/repl/runtime.js

@@ -1,6 +1,6 @@
 import { emitKeypressEvents } from 'node:readline';
 import { stdin } from 'node:process';
-import { config, isModelConfigured, isMemoryEnabled, buildBasePrompt, getPlanModeSuffix, pinSessionModel, } from '../config/index.js';
+import { config, isModelConfigured, isMemoryEnabled, buildBasePrompt, getPlanModeSuffix, pinSessionModel, pinSessionEffort, } from '../config/index.js';
 import { t } from '../i18n/index.js';
 import { listPresets, migrateCurrentToPreset } from '../config/presets.js';
 import { runAgent } from '../agent/index.js';
@@ -166,6 +166,7 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
     setAgentMode('auto');
     // 钉死本会话模型：之后运行中 agent 一律用此值，其它窗口的 /model switch 不会影响本窗口。
     pinSessionModel();
+    pinSessionEffort();
     // 沙箱根:文件操作边界。优先级 --sandbox-root > SANDBOX_ROOT env > process.cwd()。
     // 纯边界记录(不 chdir),jail.ts 内部 resolve。子 agent 同进程继承全局 root。
     setSandboxRoot(sandboxRootOverride ?? config.sandboxRoot ?? process.cwd());
@@ -305,6 +306,9 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
     if (!history.some((m) => m.role === 'user')) {
         layout.writeWelcomeBlock(welcomeLines());
     }
+    // 启动时限频自动 GC(24h 闸门,归档+purge 全做):fire-and-forget,
+    // 不阻塞进入主循环;runRetention 内部归档本地秒完、reflection 后台跑。可用 MOCODE_AUTO_GC=false 关闭。
+    void runtime.session.autoGc().catch(() => undefined);
     /**
      * 切换 agent 模式(Shift+Tab 触发,经 prompt.ts 的 onCycleMode 回调)。
      * cycleMode 翻 agentMode + applyMode 重写 history[0] + refreshStatusBase 设状态行 modeTag;

package/dist/repl/status-bar.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { ui } from '../ui/theme.js';
 import * as layout from '../ui/layout.js';
 import { t } from '../i18n/index.js';
-import { config } from '../config/index.js';
+import { config, getActiveEffort } from '../config/index.js';
 import { contextState } from '../session/index.js';
 import { DEFAULT_BUDGET_POLICY } from '../context/budget.js';
 import { chatTools, correctTokenEstimate, estimateMessagesTokens, estimateToolSchemaTokens, estimateTokens, } from '../llm/index.js';
@@ -47,7 +47,8 @@ export function renderContextBar(history) {
     const lifecycleLine = lifecycle
         ? `\n  lifecycle · live ${lifecycle.live} · referenced ${lifecycle.referenced} · digested ${lifecycle.digested} · stubbed ${lifecycle.stubbed}`
         : '\n  lifecycle · no active snapshot (run a tool-enabled turn first)';
-    const archiveLine = `\n  archived tool results · ${archived.stubbed}`;
+    const archiveLine = `
+  archived tool results · ${archived.stubbed}${archived.cleared > 0 ? ` · cleared ${archived.cleared} (low-pressure)` : ''}`;
     return `${ui.gray}[${pctCol}${bar}${ui.reset}] ${Math.round(pct * 100)}%  ${k(est)}/${k(win)} tokens · ${t('status.messages', { count: history.length })} (${src})${measuredNote}${ui.reset}${artifactLine}${lifecycleLine}${archiveLine}`;
 }
 /** 状态行用量条(精简版,进底栏):[bar] pct% k/k。
@@ -167,6 +168,7 @@ export function refreshStatusBase(history, lastTurnUsage) {
         contextBar: renderContextBarInline(history),
         cwd: process.cwd(),
         modeTag: getAgentMode() === 'plan' ? 'Plan' : 'Auto',
+        effort: getActiveEffort() === 'auto' ? undefined : getActiveEffort(),
         planSummary: readPlanFromNotes(),
         lastTurnUsage,
     });

package/dist/rollback/store.js

@@ -3,6 +3,7 @@ import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync
 import * as fsp from 'node:fs/promises';
 import path from 'node:path';
 import { config } from '../config/index.js';
+import { MAX_SNAPSHOT_TURNS } from '../tools/constants.js';
 import { toText } from '../context/utils.js';
 import { truncateDisplay } from '../ui/render.js';
 const EXCLUDED_WORKSPACE_DIRS = Object.freeze([
@@ -192,8 +193,24 @@ export class RollbackStore {
         this.turnIdCounter += 1;
         this.currentTurnId = this.turnIdCounter;
         this.turns.push({ turnId: this.currentTurnId, firstLine });
+        // 压缩前滚动窗口:snapshots.json 此前只在 compact 后剪枝,长会话压缩前持续累积
+        // (实测单文件 2MB)。每开新 turn 即丢掉超过 MAX_SNAPSHOT_TURNS 的老 turn 及其快照。
+        // env 覆盖仅供测试:MOCODE_MAX_SNAPSHOT_TURNS=2 可立刻触发滚动剪枝。
+        const envMax = Number(process.env.MOCODE_MAX_SNAPSHOT_TURNS);
+        this.pruneOldTurns(Number.isFinite(envMax) && envMax >= 1 ? envMax : MAX_SNAPSHOT_TURNS);
         return this.currentTurnId;
     }
+    /** 仅保留最近 maxTurns 个 turn 及其快照;currentTurnId 被剪掉时归零(不应发生,当前 turn 恒在尾部)。 */
+    pruneOldTurns(maxTurns) {
+        if (this.turns.length <= maxTurns)
+            return;
+        const kept = this.turns.slice(-maxTurns);
+        const alive = new Set(kept.map((turn) => turn.turnId));
+        this.turns = kept;
+        this.snapshots = this.snapshots.filter((snapshot) => alive.has(snapshot.turnId));
+        if (!alive.has(this.currentTurnId))
+            this.currentTurnId = 0;
+    }
     getCurrentTurnId() {
         return this.currentTurnId;
     }

package/dist/runtime/runtime.js

@@ -1,7 +1,7 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { runAgentCore } from '../agent/core.js';
 import { createAgentRuntimeContext, defaultAgentRuntimeContext, } from '../agent/runtime-context.js';
-import { contextState as defaultContextState, createContextState, manualCompact, } from '../session/index.js';
+import { contextState as defaultContextState, createContextState, manualCompact, planRetention, runRetention, searchArchiveIndex, shouldAutoGc, writeLastAutoGc, DEFAULT_RETENTION_POLICY, } from '../session/index.js';
 const activeRuntimes = new AsyncLocalStorage();
 /** Runtime facade active in the current agent async tree, used by nested agents to borrow the parent lifecycle. */
 export function getActiveRuntime() {
@@ -54,6 +54,36 @@ export class Runtime {
                 return this.context.sessionStore.list(limit);
             },
             clear: () => this.createSession(true),
+            gc: (async (opts = {}) => {
+                this.assertIdle('gc sessions');
+                const root = this.context.sessionStore.sessionsRoot;
+                const currentId = this.context.sessionStore.getCurrentSessionId();
+                const plan = planRetention(root, DEFAULT_RETENTION_POLICY, Date.now(), currentId);
+                if (opts.dryRun !== false)
+                    return plan;
+                const result = await runRetention(root, plan);
+                this.emit('session.gc', { archived: result.archived, purged: result.purged });
+                return result;
+            }),
+            searchArchive: (query, limit) => {
+                this.assertOpen();
+                return searchArchiveIndex(this.context.sessionStore.sessionsRoot, query, limit ?? 10);
+            },
+            autoGc: async () => {
+                this.assertOpen();
+                const root = this.context.sessionStore.sessionsRoot;
+                if (!shouldAutoGc(root))
+                    return null;
+                const currentId = this.context.sessionStore.getCurrentSessionId();
+                const plan = planRetention(root, DEFAULT_RETENTION_POLICY, Date.now(), currentId);
+                // 先写闸门:即使本次没有命中项,也 记录“已检查”,避免每次启动都重新扫描。
+                writeLastAutoGc(root);
+                if (plan.items.length === 0)
+                    return null;
+                const result = await runRetention(root, plan);
+                this.emit('session.gc', { archived: result.archived, purged: result.purged, auto: true });
+                return result;
+            },
         };
         this.rollback = {
             list: () => {