mocode-ai 1.6.4 → 1.6.6

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`);
@@ -229,26 +246,11 @@ export const modelCommands = [
         }
         // /model 无参 → 直接进入「配置新模型」4 步向导(不弹动作菜单)。
         //   切换 / 查看 / 删除已配置预设改用显式子命令:/model switch · /model list · /model delete <name>。
-        // 1) 选 provider 预设(预填 baseURL,后续仍可逐项改)。
-        let preset;
-        try {
-            const res = await promptIntervention({
-                type: 'choice',
-                title: '选择后端预设(预填 baseURL,后续可改)',
-                detail: '选一个会预填 baseURL/model/窗口,之后逐项确认。选「自定义」全部手填。',
-                options: MODEL_PRESETS.map((p) => p.label),
-            });
-            if (res.action === 'cancelled') {
-                return next();
-            }
-            const idx = MODEL_PRESETS.findIndex((p) => p.label === res.value);
-            if (idx === -1) {
-                return next();
-            }
-            preset = MODEL_PRESETS[idx];
-        }
-        catch {
-            return next(); // Ctrl+C
+        // 1) 后端预设：本地/远程都可由一个 OpenAI 兼容端点表达，故只保留「自定义 base_url」
+        //    一个入口；既然只有一个预设，不再弹选择菜单，直接进入字段填写。
+        const preset = MODEL_PRESETS[0];
+        if (!preset) {
+            return next();
         }
         // 1.5) 一键应用确认:非「自定义」预设(带预填值)给直接应用入口,免连按 4 次回车。
         //      直接应用 = 用预设 model/baseURL/window + 保留当前 apiKey(等价于下方逐项链连按回车)。

package/dist/repl/commands/registry.js

@@ -5,14 +5,20 @@ 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';
+import { jobsCommands } from './jobs.js';
+import { scheduleCommands } from './schedule.js';
+import { botsCommands } from './bots.js';
 /**
  * 命令注册表。顺序即匹配优先级 —— 更具体的分支放前面。
  * 组内顺序由各文件自己保证(见文件头注释);组间顺序互不影响(条件互斥)。
@@ -26,14 +32,20 @@ export const commandHandlers = [
     ...petCommands,
     ...imageCommands,
     ...contextCommands,
+    ...statsCommands,
     ...sessionCommands,
     ...memoryCommands,
     ...skillCommands,
     ...compactCommands,
     ...appearanceCommands,
+    ...effortCommands,
+    ...modelCatalogCommands,
     ...modelCommands,
     ...routerCommands,
     ...toolGroupCommands,
+    ...jobsCommands,
+    ...scheduleCommands,
+    ...botsCommands,
 ];
 /**
  * 依次询问 handler,返回第一个非 unhandled 的结果。

package/dist/repl/commands/schedule.js

@@ -0,0 +1,37 @@
+/**
+ * 调度计划命令:/schedules
+ * 只读列出 schedules + 守护进程状态；增删改/启停走 CLI `mocode schedule …`。
+ */
+import * as layout from '../../ui/layout.js';
+import { ui } from '../../ui/theme.js';
+import { listSchedules } from '../../schedule/store.js';
+import { isDaemonRunning, getDaemonState } from '../../schedule/daemon.js';
+import { unhandled, next } from './types.js';
+function oneLine(prompt) {
+    const line = prompt.split('\n')[0] ?? '';
+    return line.length > 50 ? `${line.slice(0, 50)}…` : line;
+}
+export const scheduleCommands = [
+    (ctx) => {
+        if (ctx.line !== '/schedules')
+            return unhandled();
+        const daemonState = getDaemonState();
+        const daemon = isDaemonRunning() && daemonState;
+        layout.contentWrite(daemon
+            ? `${ui.dim}scheduler:${ui.reset} ${ui.green}running${ui.reset} ` +
+                `${ui.dim}(pid ${daemonState?.pid}, port ${daemonState?.port})${ui.reset}\n`
+            : `${ui.dim}scheduler:${ui.reset} ${ui.yellow}stopped${ui.reset} ` +
+                `${ui.dim}(mocode schedule start)${ui.reset}\n`);
+        const all = listSchedules();
+        if (all.length === 0) {
+            layout.contentWrite(`${ui.dim}(no schedules; mocode schedule add …)${ui.reset}\n`);
+            return next();
+        }
+        for (const s of all) {
+            const trigger = s.cron ? s.cron : s.webhookToken ? `webhook:${s.webhookToken}` : '?';
+            layout.contentWrite(`  ${s.enabled ? ui.green + '●' : ui.dim + '○'}${ui.reset} ${ui.bold}${s.name}${ui.reset} ` +
+                `${ui.dim}${trigger}${ui.reset}\n      ${ui.dim}${oneLine(s.prompt)}${ui.reset}\n`);
+        }
+        return next();
+    },
+];

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,15 @@ 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: '/jobs', desc: '后台任务列表(/jobs log/kill <id前缀>)' },
+        { name: '/schedules', desc: '查看定时计划与调度守护状态' },
+        { name: '/bots', desc: '查看具名 Bot 列表' },
         {
             name: '/memory',
             desc: d('commands.memory'),
@@ -268,64 +274,6 @@ export function themeDescription(name) {
 }
 /** /model 预设后端：同时声明原生协议；旧服务继续走 OpenAI-compatible。 */
 export const MODEL_PRESETS = [
-    {
-        label: 'Anthropic Claude',
-        provider: 'anthropic',
-        baseURL: 'https://api.anthropic.com',
-        model: 'claude-sonnet-4-5',
-        window: 200000,
-        anthropicPromptCache: true,
-    },
-    {
-        label: 'GLM(智谱)',
-        provider: 'openai',
-        baseURL: 'https://open.bigmodel.cn/api/v3',
-        model: 'glm-4.6',
-        window: DEFAULT_CONTEXT_WINDOW_TOKENS,
-        anthropicPromptCache: false,
-    },
-    {
-        label: 'DeepSeek',
-        provider: 'openai',
-        baseURL: 'https://api.deepseek.com',
-        model: 'deepseek-chat',
-        window: DEFAULT_CONTEXT_WINDOW_TOKENS,
-        anthropicPromptCache: false,
-    },
-    {
-        label: 'Qwen(阿里)',
-        provider: 'openai',
-        baseURL: 'https://dashscope.aliyuncs.com/compatible-mode/v1',
-        model: 'qwen-plus',
-        window: DEFAULT_CONTEXT_WINDOW_TOKENS,
-        anthropicPromptCache: false,
-    },
-    // MiniMax OpenAI 兼容端点(https://platform.minimax.io/docs/api-reference/text-openai-api)。
-    // MiniMax-M3 为唯一支持图片/视频输入的模型;M2 系列纯文本(见 llm/capabilities.ts KNOWN_TEXT_ONLY_PREFIXES)。
-    {
-        label: 'MiniMax',
-        provider: 'openai',
-        baseURL: 'https://api.minimax.io/v1',
-        model: 'MiniMax-M3',
-        window: DEFAULT_CONTEXT_WINDOW_TOKENS,
-        anthropicPromptCache: false,
-    },
-    {
-        label: '本地 Ollama',
-        provider: 'openai',
-        baseURL: 'http://localhost:11434/v1',
-        model: 'qwen2.5:7b',
-        window: DEFAULT_CONTEXT_WINDOW_TOKENS,
-        anthropicPromptCache: false,
-    },
-    {
-        label: '本地 vLLM',
-        provider: 'openai',
-        baseURL: 'http://localhost:8000/v1',
-        model: 'default',
-        window: DEFAULT_CONTEXT_WINDOW_TOKENS,
-        anthropicPromptCache: false,
-    },
     {
         label: '自定义 base_url',
         provider: 'openai',