mocode-ai 0.3.0 → 0.4.1

package/dist/llm/index.js

@@ -17,6 +17,14 @@ const RETRY_MAX_ATTEMPTS = 4;
 const RETRY_BASE_MS = 1000;
 const RETRY_MAX_MS = 30000;
 const RETRY_JITTER = 0.2;
+/**
+ * 流式响应里出现的推理模型自创 `think` 标签(DeepSeek R1 / Qwen3 / 部分自训模型):
+ * 与 OpenAI 兼容协议的独立 `reasoning_content` 字段不同,这些模型把 thinking 直接嵌进 content
+ * 字符串,期间不调 onText(spinner 持续转 ⠹ 思考中…),也不写入可见 content(history 不被思考段污染)。
+ */
+// 用 \u003c 表示 <,绕开本工具对 < 的处理(直接写 '<\u003cthink\u003e' 里 < 会被吃掉)。
+const THINK_OPEN = '<think>';
+const THINK_CLOSE = '</think>';
 let client = new OpenAI({
     baseURL: config.baseURL,
     apiKey: config.apiKey,
@@ -199,8 +207,13 @@ async function chatOnce(messages, handlers, signal, toolsOverride) {
         ...(config.maxTokens ? { max_tokens: config.maxTokens } : {}),
         ...(config.includeUsage ? { stream_options: { include_usage: true } } : {}),
     }, signal ? { signal } : undefined);
-    let content = '';
-    let hasContent = false;
+    // 流式  start end 标签过滤(见模块顶部 THINK_OPEN/CLOSE)。
+    // 跨 chunk 切分防御:buf 累积跨 chunk 边界,indexOf 扫描;为避免把跨 chunk 标签误判为
+    // 普通字符,buf 末尾为当前态保留 (label.length - 1) 个字符给下一 chunk 看。
+    let visibleContent = '';
+    let consumedAny = false;
+    let inThink = false;
+    let buf = '';
     let usage;
     const toolAcc = new Map();
     for await (const chunk of stream) {
@@ -216,9 +229,57 @@ async function chatOnce(messages, handlers, signal, toolsOverride) {
         if (!delta)
             continue; // 末尾 usage-only chunk 等无 delta
         if (delta.content) {
-            content += delta.content;
-            hasContent = true;
-            handlers.onText?.(delta.content);
+            // 状态机切分 delta.content:inThink 外输出到 visibleContent + onText;
+            // inThink 内丢弃;标签起始/闭合用 indexOf 在 buf 里扫描。
+            // 末尾预留 (label.length - 1) 字符给下一 chunk 防切分误判。
+            buf += delta.content;
+            let i = 0;
+            while (true) {
+                if (inThink) {
+                    // 思考段内,扫描 THINK_CLOSE;末尾预留 THINK_CLOSE.length - 1 防跨 chunk 切分
+                    const endIdx = buf.indexOf(THINK_CLOSE, i);
+                    if (endIdx === -1) {
+                        // 思考段内未找到闭合;buf 短到不可能包含 </think> 时全丢(都是思考段内容),
+                        // 否则留 (THINK_CLOSE.length - 1) 给下一 chunk 防跨边界切分。
+                        const safeLen = buf.length >= THINK_CLOSE.length
+                            ? buf.length - (THINK_CLOSE.length - 1)
+                            : buf.length;
+                        i = safeLen;
+                        break;
+                    }
+                    inThink = false;
+                    i = endIdx + THINK_CLOSE.length;
+                }
+                else {
+                    // 普通段,扫描 THINK_OPEN;末尾预留 THINK_OPEN.length - 1 防跨 chunk 切分
+                    const startIdx = buf.indexOf(THINK_OPEN, i);
+                    if (startIdx === -1) {
+                        // buf 短到不可能包含 <think> 时全输出(无 think 标签的普通模型不受影响);
+                        // 否则留 (THINK_OPEN.length - 1) 给下一 chunk 防跨边界切分误判。
+                        const safeLen = buf.length >= THINK_OPEN.length
+                            ? buf.length - (THINK_OPEN.length - 1)
+                            : buf.length;
+                        const seg = buf.slice(i, safeLen);
+                        if (seg) {
+                            visibleContent += seg;
+                            handlers.onText?.(seg);
+                            consumedAny = true;
+                        }
+                        i = safeLen;
+                        break;
+                    }
+                    // THINK_OPEN 之前的普通段:输出
+                    if (startIdx > i) {
+                        const seg = buf.slice(i, startIdx);
+                        visibleContent += seg;
+                        handlers.onText?.(seg);
+                        consumedAny = true;
+                    }
+                    inThink = true;
+                    i = startIdx + THINK_OPEN.length;
+                }
+            }
+            buf = buf.slice(i);
         }
         if (delta.tool_calls) {
             for (const tc of delta.tool_calls) {
@@ -241,6 +302,16 @@ async function chatOnce(messages, handlers, signal, toolsOverride) {
             }
         }
     }
+    // 防御:循环内 buf.slice 已把可确认部分消费;此处覆盖流末尾的"安全尾":
+    //  - 普通段(stream 已结束,标签不会再出现):作为可见内容追加到 visibleContent(不再调 onText)
+    //  - 思考段未闭合:丢弃,防 thinking 文本泄漏到 history
+    if (buf) {
+        if (!inThink) {
+            visibleContent += buf;
+            consumedAny = true;
+        }
+        buf = '';
+    }
     const toolCalls = [...toolAcc.entries()]
         .sort((a, b) => a[0] - b[0])
         .map(([, e]) => ({
@@ -249,7 +320,7 @@ async function chatOnce(messages, handlers, signal, toolsOverride) {
         arguments: e.arguments,
     }));
     return {
-        content: hasContent ? content : null,
+        content: consumedAny ? visibleContent : null,
         toolCalls,
         usage,
     };

package/dist/repl/index.js

@@ -16,7 +16,7 @@ import { promptIntervention } from '../ui/intervention.js';
 import { tools } from '../tools/registry.js';
 import { estimateMessagesTokens, reconfigureClient, } from '../llm/index.js';
 import { loadImageAttachment, renderChip, MAX_INLINE_BYTES_DEFAULT, } from '../attachments/image.js';
-import { compactHistory, contextState, newSessionId, saveSession, loadSession, listSessions, } from '../session/index.js';
+import { manualCompact, contextState, newSessionId, saveSession, loadSession, listSessions, } from '../session/index.js';
 import { listTurns, planRollback, applyRollback, persistSnapshots, loadSnapshots, rebuildFromHistory, resetState, } from '../rollback/index.js';
 import { listSkills, effectiveSystemPrompt, } from '../skills/index.js';
 import { buildMemorySection, buildMemoryIndexSection, kickoffReflection, drainMemoryBackground, getLastReflectResult, clearLastReflectResult, snapshotTranscript, formatReflectResult, loadAll, } from '../memory/index.js';
@@ -867,16 +867,69 @@ export async function startRepl(initialHistory, sessionId, updateNotice = null,
             continue;
         }
         if (line === '/compact' || line.startsWith('/compact ')) {
-            const focus = line.startsWith('/compact ')
-                ? line.slice('/compact '.length).trim()
-                : undefined;
-            const r = await compactHistory(history, {
-                window: config.contextWindowTokens,
-                threshold: config.compactThreshold,
-                focus,
-            });
-            if (r.reason === 'noop') {
-                layout.contentWrite(`${ui.dim}(无需压缩:没有可压缩的旧消息)${ui.reset}\n`);
+            // /compact 可选语法:/compact [focus]  或  /compact --force [focus]
+            // --force:即便 oldGroups 空(history 全在保护区)也强行把早期消息降级压一次。
+            const rest = line.slice('/compact'.length).trim();
+            let force = false;
+            let focus;
+            if (rest === '--force')
+                force = true;
+            else if (rest.startsWith('--force ')) {
+                force = true;
+                focus = rest.slice('--force '.length).trim() || undefined;
+            }
+            else if (rest)
+                focus = rest;
+            // 走调度器路径:与自动每步压缩完全一致——五区按 ROI 压(cold tools 优先 → history 摘要最后)。
+            // focus 透传到 compact_history action 的 LLM 摘要 prompt。
+            // 返回 SchedulerRunLog 给 UI 显示决策;退化路径(开关关时)在 manualCompact 内部走 compactHistory。
+            const log = await manualCompact(history, focus, { force });
+            const d = log.compactDetail;
+            if (!d) {
+                // 兜底(旧调用):只显示 old 文案
+                if (!log.compactHistoryCalled) {
+                    layout.contentWrite(`${ui.dim}(无需压缩:没有可压缩的旧消息)${ui.reset}\n`);
+                }
+                else if (focus) {
+                    layout.contentWrite(`${ui.dim}(带焦点压缩:${focus})${ui.reset}\n`);
+                }
+                continue;
+            }
+            // 详细文案:按 reason 分类
+            const reason = d.reason;
+            const before = d.estimateBefore;
+            const after = d.estimateAfter;
+            const proto = d.protectedRatio !== undefined ? `保护区占比 ${(d.protectedRatio * 100).toFixed(0)}%` : '';
+            const oldCt = d.oldGroupCount !== undefined ? `旧区组数 ${d.oldGroupCount}` : '';
+            const focusNote = focus ? `焦点:${focus}` : '';
+            const stats = [proto, oldCt].filter(Boolean).join(' · ');
+            if (reason === 'microcompact') {
+                layout.contentWrite(`${ui.cyan}✓ 微压缩:${ui.reset} ${before} → ${after} tokens${stats ? `  (${ui.dim}${stats}${ui.reset})` : ''}\n`);
+            }
+            else if (reason === 'summarize') {
+                layout.contentWrite(`${ui.cyan}✓ LLM 摘要:${ui.reset} ${before} → ${after} tokens${focusNote ? `  (${ui.dim}${focusNote}${ui.reset})` : ''}\n`);
+            }
+            else if (reason === 'noop-empty') {
+                layout.contentWrite(`${ui.dim}(history 太短,只有 system 提示,无可压旧区)${ui.reset}\n`);
+            }
+            else if (reason === 'noop-protected') {
+                layout.contentWrite(`${ui.dim}(无可压旧区:全部在保护区 system + 当前轮)${ui.reset}${stats ? `  ${ui.dim}(${stats})${ui.reset}` : ''}\n`);
+                layout.contentWrite(`${ui.dim}提示:/compact --force 强行把早期对话压成摘要${ui.reset}\n`);
+            }
+            else if (reason === 'noop-ml-only') {
+                layout.contentWrite(`${ui.dim}(LLM 摘要失败,且无超大单条可微压;可能是后端不可用)${ui.reset}\n`);
+                layout.contentWrite(`${ui.dim}回退:只跑了 keep-current 结构,history 未变${ui.reset}\n`);
+            }
+            else if (reason === 'noop-shrunk-too-large') {
+                layout.contentWrite(`${ui.yellow}● 上下文已超阈但无可压缩项(全在保护区),建议 /clear 或缩短输入。${ui.reset}\n`);
+                if (stats)
+                    layout.contentWrite(`${ui.dim}(${stats})${ui.reset}\n`);
+            }
+            else if (reason === 'noop-noold-noop') {
+                layout.contentWrite(`${ui.dim}(无需压缩:没有可压缩的旧消息,且不在手动触发)${ui.reset}\n`);
+            }
+            else {
+                layout.contentWrite(`${ui.dim}(reason=${reason},${before} → ${after} tokens)${ui.reset}\n`);
             }
             continue;
         }

package/dist/session/compact.js

@@ -5,7 +5,8 @@ import { ui } from '../ui/theme.js';
 import { Spinner } from '../ui/spinner.js';
 import * as layout from '../ui/layout.js';
 import { pruneAfterCompaction } from '../rollback/index.js';
-/** 跨模块共享的上下文状态:agent 写 lastUsage,compact 写 lastEstimate,repl 的 /context 读。 */
+/** 跨模块共享的上下文状态:agent 写 lastUsage,compact 写 lastEstimate,repl 的 /context 读。
+ *  scheduler.ts 写最近一次调度日志(可选,repl 可读不到时 no-op)。 */
 export const contextState = {
     lastEstimate: 0,
 };
@@ -268,15 +269,83 @@ export async function compactHistory(history, opts) {
         summarized: false,
         estimateBefore,
         estimateAfter: estimateBefore,
-        reason: 'noop',
+        reason: 'noop-noold-noop',
+        protectedRatio: history.length > 0 ? kept.length / history.length : 0,
+        oldGroupCount: oldGroups.length,
     };
     if (oldGroups.length === 0) {
         // 没有旧区可压缩
+        const protectedRatio = history.length > 0 ? kept.length / history.length : 0;
+        if (opts.force && history.length > 2) {
+            // 真·强制压:把降 keepBudget 当 old group 强行创建一组可压区
+            // 取最早的 user/assistant/tool 当 old,后一段当 kept
+            const mid = Math.max(1, Math.floor(history.length / 2));
+            const older = history.slice(1, mid);
+            const keptAfter = history.slice(mid);
+            // 走仅微压缩(LLM 可能不可用,不强行 summarize)
+            let microcompactDone2 = false;
+            for (const m of older) {
+                const c = m.content;
+                if (typeof c === 'string' && c.length > MAX_OLD_TOOL_STUB) {
+                    m.content = truncateMid(c, MAX_OLD_TOOL_STUB);
+                    microcompactDone2 = true;
+                }
+                const as = m;
+                if (as.role === 'assistant') {
+                    if (typeof as.content === 'string' && as.content.length > MAX_OLD_TOOL_STUB) {
+                        as.content = truncateMid(as.content, MAX_OLD_TOOL_STUB);
+                        microcompactDone2 = true;
+                    }
+                    if (Array.isArray(as.tool_calls)) {
+                        for (const tc of as.tool_calls) {
+                            const args = tc?.function?.arguments;
+                            if (typeof args !== 'string' || args.length <= MAX_OLD_TOOL_STUB)
+                                continue;
+                            const stubbed = stubToolCallArguments(args);
+                            if (stubbed !== args) {
+                                tc.function.arguments = stubbed;
+                                microcompactDone2 = true;
+                            }
+                        }
+                    }
+                }
+            }
+            const summaryMsg = {
+                role: 'system',
+                content: older.length > 0
+                    ? `# 会话摘要(force)\n被跳过的早期对话 ${older.length} 条已微压缩(token 数减少)。`
+                    : `# 会话摘要(force)\n无内容。`,
+            };
+            const rebuilt = [history[0], summaryMsg, ...keptAfter];
+            history.length = 0;
+            history.push(...rebuilt);
+            pruneAfterCompaction(history);
+            const estimateAfter = estimateMessagesTokens(history) + schemaTokens;
+            contextState.lastEstimate = estimateAfter;
+            contextState.lastUsage = undefined;
+            layout.contentWrite(`  ${ui.brightMagenta}●${ui.reset} ${ui.cyan}强制压缩(focus on early history)${ui.reset}  ${ui.dim}${estimateBefore} → ${estimateAfter} tokens${ui.reset}\n`);
+            return {
+                compacted: true,
+                summarized: false,
+                estimateBefore,
+                estimateAfter,
+                reason: microcompactDone2 ? 'microcompact' : 'summarize',
+                protectedRatio,
+                oldGroupCount: 0,
+            };
+        }
+        // 细分 noop 类型,供 repl 文案
+        const isEmpty = history.length <= 1; // 只有 system 提示
+        if (isEmpty) {
+            // 整段 history 太短,没有可压内容
+            return { ...noop, reason: 'noop-empty', protectedRatio };
+        }
+        // history 有内容但全在保护区(系统 + 当前轮)
         if (estimateBefore >= opts.threshold * opts.window) {
-            layout.contentWrite(`  ${ui.yellow}●${ui.reset} ${ui.yellow}上下文已超阈但无可压缩项,建议 /clear 或缩短输入。${ui.reset}\n`);
-            return { ...noop, reason: 'too-large' };
+            layout.contentWrite(`  ${ui.yellow}●${ui.reset} ${ui.yellow}上下文已超阈但无可压缩项(全在保护区),建议 /clear 或缩短输入。${ui.reset}\n`);
+            return { ...noop, reason: 'noop-shrunk-too-large', protectedRatio };
         }
-        return noop;
+        return { ...noop, reason: 'noop-protected', protectedRatio };
     }
     // 第一层:微压缩——旧区原地截短(保 tool_call_id,无 LLM 调用)
     // 覆盖三类大字段,均只裁模型/工具产物,不动 user 原话与 system(摘要):
@@ -365,24 +434,63 @@ export async function compactHistory(history, opts) {
             estimateBefore,
             estimateAfter,
             reason: 'microcompact',
+            protectedRatio: history.length > 0 ? kept.length / history.length : 0,
+            oldGroupCount: oldGroups.length,
         };
     }
-    return noop;
+    // 摘要失败 + 无超大单条可微压 = 真 noop
+    return {
+        ...noop,
+        reason: 'noop-ml-only',
+        protectedRatio: history.length > 0 ? kept.length / history.length : 0,
+        oldGroupCount: oldGroups.length,
+    };
 }
 /**
  * 自动压缩门槛:agent 每步调 chat() 前调用。
  * 用全量启发式估算(始终可用、安全侧、无 stale-usage 问题);超阈则压缩。
+ *
+ * 升级到 Budget Scheduler:可传 `report: BudgetReport`。传了就**按 ROI 调度**:
+ *   - 只有当 `report.layers.history.overBudget` 或 `report.totalOver` 时才压;
+ *   - 冷工具超(Cold Tool ROI 最低)→ 不压 history,留给调度器的 cold tools 路径处理。
+ * 这样 cold tools 路径(L1 中截 / L2 relevance / L3 age stub)能先动,history
+ * 摘要(最贵)只在 cold tools 解不开时才触发。
+ *
+ * 不传 report 时退化为原行为:仅看总占用是否超 `compactThreshold * window`——
+ * 兼容老调用方(子 agent / 测试直接调时),零行为变化。
+ *
+ * manual 选项(repl /compact 用):true 时旁路 autoCompact 开关与 ROI 阈,
+ * 强制走 compactHistory(manual/force 参数透传)。返 CompactResult 给 caller 文案展示。
+ * 默认 manual=false 自动路径完全不变。
  */
-export async function maybeCompact(history) {
+export async function maybeCompact(history, report, manualOpts) {
     const schemaTokens = estimateToolSchemaTokens();
     const est = estimateMessagesTokens(history) + schemaTokens;
     contextState.lastEstimate = est;
-    if (!config.autoCompact)
-        return;
-    if (est < config.compactThreshold * config.contextWindowTokens)
-        return;
-    await compactHistory(history, {
+    const isManual = manualOpts?.manual === true;
+    // 手动路径:旁路 autoCompact / report / 总阈三重门
+    if (!isManual) {
+        if (!config.autoCompact)
+            return;
+        if (report) {
+            // 调度模式:只压 history 层超或兜底总超
+            const needsCompact = report.layers.history.overBudget || report.totalOver;
+            if (!needsCompact)
+                return;
+        }
+        else {
+            // 老路径:总占用超阈才压
+            if (est < config.compactThreshold * config.contextWindowTokens)
+                return;
+        }
+    }
+    const r = await compactHistory(history, {
         window: config.contextWindowTokens,
         threshold: config.compactThreshold,
+        focus: manualOpts?.focus,
+        manual: isManual,
+        force: manualOpts?.force,
     });
+    if (isManual)
+        return r;
 }

package/dist/session/index.js

@@ -5,5 +5,10 @@
  * 依赖方向:session → {llm(摘要复用 chat), config, ui};llm 不反向依赖 session。
  */
 export { compactHistory, maybeCompact, capToolResultForHistory, truncateMid, contextState, } from './compact.js';
+// ── Context Budget Scheduler 接缝 ────────────────────────────────────────
+// agent/core.ts 步前调 runScheduler(history, step):评估五区预算 → 按 ROI 调度
+// shrink_cold_tools / cap_hot_tools / compact_history。开关关闭时退化为 maybeCompact。
+// repl /compact 命令调 manualCompact(history, focus?):与自动路径完全一致,focus 透传摘要 prompt。
+export { runScheduler, manualCompact, createBudgetScheduler, } from './scheduler.js';
 export { dropContextFromHistory, formatDropResult, } from './drop.js';
 export { newSessionId, saveSession, loadSession, listSessions, sessionDir, } from './persist.js';

package/dist/session/scheduler.js

@@ -0,0 +1,172 @@
+// Context Budget Scheduler(执行层):把 scheduleActions() 产生的动作落到既有闸上。
+//
+// 关系图:
+//
+//   agent/core.ts (步前)              repl /compact 命令(手动)
+//     ↓ runScheduler(history, step)    ↓ manualCompact(history, focus?)
+//   session/scheduler.ts(本文件)
+//     ├─ evaluateBudget(history, window, step) → BudgetReport
+//     │     ↓
+//     ├─ scheduleActions(report) → ScheduleAction[]
+//     │     ↓
+//     └─ 执行 actions:
+//          - warn:                  仅写日志
+//          - shrink_cold_tools L1:  由 push-time cap.ts(MAX_HISTORY_RESULT)自动处理;此处 no-op
+//          - shrink_cold_tools L2:  由 pruner.observePush(relevance.ts)自动处理;此处 no-op
+//          - shrink_cold_tools L3:  由 lifecycle.pushTool(lifecycle.ts)自动处理;此处 no-op
+//          - cap_hot_tools:         Hot 区只 cap,实际仍由 push-time cap 走;此处 no-op + 记日志
+//          - compact_history:       调 maybeCompact(history, report)── report 路由到 ROI 调度
+//
+// 设计意图:
+//   - **L1/L2/L3 不重复实现**——push-time 已经自动跑过这三级。再在调度器做一遍是 Double-Action
+//     且破坏「调度器永不抛错 + 幂等」契约。调度器只负责"决策时点",push-time 闸负责"执行"。
+//   - **hotBoundary** 仍由调度器算出来供 lifecycle 内部用(将来可演进成「仅 Cold 区跑 age stub」)——
+//     现版本先全面暴露给 report,暂不传参给 lifecycle。
+//   - **actionLog**:每次执行的决策落进 contextState.schedulerLog,供 /context 命令与调试用。
+//   - **manualCompact**:手动入口(用户敲 /compact),与 runScheduler 共享决策路径;唯一差别是
+//     即使 history 不超预算也强制产 compact_history(focus 透传)。对齐用户拍板的方案 A。
+//
+// 开关:
+//   - config.contextBudget !== false(默认 true):agent 调 runScheduler
+//   - 关时 agent 仍走原 maybeCompact(history)无 report 路径,零行为变化
+//   - 手动 /compact 走 manualCompact;关时退化直接调 compactHistory(history, { focus })
+import { evaluateBudget, scheduleActions, formatReport, } from '../context/budget.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';
+/** 创建 runAgentCore 闭包持有的 scheduler(每次 agent 启动一个新实例)。
+ *  observePush 当前只是占位:真正 L1/L2/L3 已由 cap / pruner / lifecycle 在 push 时跑;
+ *  保留接口为后续「调度器注入 hotBoundary 给 lifecycle」演进留接缝。 */
+export function createBudgetScheduler() {
+    const obs = {
+        lastRunLog: null,
+        observePush(_history, _idx) {
+            // 占位:push-time 三闸(cap / pruner / lifecycle)已自动跑;此接缝供将来演进。
+        },
+        async runStep(history, step) {
+            const report = evaluateBudget(history, config.contextWindowTokens, step);
+            const actions = scheduleActions(report);
+            let compactHistoryCalled = false;
+            for (const a of actions) {
+                if (a.kind === 'warn') {
+                    // system 超:写一行提示(配置漂移应由用户处理,不是调度器压)
+                    layout.contentWrite(`  ${ui.yellow}●${ui.reset} ${ui.yellow}调度器警告:${a.layer} ${a.reason}${ui.reset}\n`);
+                }
+                else if (a.kind === 'compact_history') {
+                    // 路由到 maybeCompact(history, report)——按 ROI 调度(只有 history 超 / totalOver 才真压)
+                    await maybeCompact(history, report);
+                    compactHistoryCalled = true;
+                }
+                // shrink_cold_tools L1/L2/L3 与 cap_hot_tools:已由 push-time 闸在每次 push 自动跑
+                // (cap = MAX_HISTORY_RESULT;pruner = same-path 新旧替换;lifecycle = age stub)。
+                // 调度器不重复,只把决策记录下来供调试。
+            }
+            const log = {
+                step,
+                report,
+                actions,
+                compactHistoryCalled,
+                ts: Date.now(),
+            };
+            obs.lastRunLog = log;
+            // 暴露给 /context 共享读(repl / context 命令)
+            contextState.schedulerLog = log;
+        },
+    };
+    return obs;
+}
+/** 便捷:agent/core.ts 不需要每次 createBudgetScheduler,直接 runScheduler(history, step)。 */
+export async function runScheduler(history, step) {
+    const s = createBudgetScheduler();
+    await s.runStep(history, step);
+}
+/** 手动 /compact 入口(repl):与自动路径完全一致——五区 ROI 调度,但 history 摘要强制执行。
+ *  即便 layers.history.overBudget=false 或 totalOver=false,manual 仍产 compact_history action
+ *  把 focus 透传给 LLM 摘要 prompt。其它 ROI 决策(cold tools / cap hot / warn)按 scheduleActions 走。
+ *
+ *  关系:runScheduler 是「自动触发」,manualCompact 是「用户显式触发」,二者共享 scheduleActions。
+ *
+ *  force=true:即便 oldGroups 空(history 全在保护区)也强行把早期消息降级压一次。
+ *  适合"history 太长,自动阈值从未触发,但用户想强制压"的场景。
+ *
+ *  退化:config.contextBudget === false 时直接调 compactHistory(history, { focus }),与改造前等价。
+ *  返回 SchedulerRunLog + compactDetail 字段,供 repl 文案展示"为什么没压"。 */
+export async function manualCompact(history, focus, opts) {
+    if (config.contextBudget === false) {
+        // 退化:不经调度器,直压 history(等价于改造前,但带 manual/force 透传)
+        const r = await import('./compact.js').then(({ compactHistory }) => compactHistory(history, {
+            window: config.contextWindowTokens,
+            threshold: config.compactThreshold,
+            focus,
+            manual: true,
+            force: opts?.force,
+        }));
+        return {
+            step: -1,
+            report: evaluateBudget(history, config.contextWindowTokens, -1),
+            actions: [{ kind: 'compact_history', focus }],
+            compactHistoryCalled: true,
+            ts: Date.now(),
+            compactDetail: {
+                reason: r.reason,
+                estimateBefore: r.estimateBefore,
+                estimateAfter: r.estimateAfter,
+                protectedRatio: r.protectedRatio,
+                oldGroupCount: r.oldGroupCount,
+                focus,
+            },
+        };
+    }
+    const report = evaluateBudget(history, config.contextWindowTokens, -1);
+    let actions = scheduleActions(report);
+    // 用户显式说「要压」:即使 report 不含 history 触发,仍追加 compact_history
+    const hasCompact = actions.some(a => a.kind === 'compact_history');
+    if (!hasCompact) {
+        actions = [...actions, { kind: 'compact_history', focus }];
+    }
+    else if (focus) {
+        // 已有 compact_history(action 由 scheduleActions 产,无 focus)— 注入 focus
+        actions = actions.map(a => a.kind === 'compact_history' ? { ...a, focus } : a);
+    }
+    const s = createBudgetScheduler();
+    // 直接驱动 runStep 的执行逻辑(action list 我们已自己生成)
+    let compactHistoryCalled = false;
+    let compactDetail;
+    for (const a of actions) {
+        if (a.kind === 'warn') {
+            // 复用现有 contentWrite 路径(经 scheduler.runStep);这里略,只记录到 log
+        }
+        else if (a.kind === 'compact_history') {
+            const r = await maybeCompact(history, report, {
+                manual: true,
+                force: opts?.force,
+                focus: a.focus,
+            });
+            compactHistoryCalled = true;
+            if (r) {
+                compactDetail = {
+                    reason: r.reason,
+                    estimateBefore: r.estimateBefore,
+                    estimateAfter: r.estimateAfter,
+                    protectedRatio: r.protectedRatio,
+                    oldGroupCount: r.oldGroupCount,
+                    focus: a.focus,
+                };
+            }
+        }
+    }
+    const log = {
+        step: -1,
+        report,
+        actions,
+        compactHistoryCalled,
+        ts: Date.now(),
+        compactDetail,
+    };
+    s.lastRunLog = log;
+    contextState.schedulerLog = log;
+    return log;
+}
+// ── 调试导出:用于 scripts/check-budget.ts 把报告打到 stdout 调试 ────────
+export { evaluateBudget, scheduleActions, formatReport };

package/dist/tools/builtins/ask-human.js

@@ -1,5 +1,43 @@
 import { promptIntervention } from '../../ui/intervention.js';
 import { sendState } from '../../pet/bridge.js';
+/** 公开以便 check-ask-human-options.ts 单元测试。 */
+export function coerceOptions(raw) {
+    // 路径 1:本身就是数组,map 成字符串。
+    if (Array.isArray(raw)) {
+        // 子路径 1a:LLM 把真数组包成字符串塞在单元素里(本次 bug 现场)
+        if (raw.length === 1 && typeof raw[0] === 'string') {
+            const t = raw[0].trim();
+            if (t.startsWith('[') && t.endsWith(']')) {
+                try {
+                    const parsed = JSON.parse(t);
+                    if (Array.isArray(parsed))
+                        return parsed.map((o) => String(o));
+                }
+                catch {
+                    // 不是合法 JSON 数组,降级原值
+                }
+            }
+        }
+        return raw.map((o) => (typeof o === 'string' ? o : String(o)));
+    }
+    // 路径 2:LLM 直接把整个数组 stringify 成单字符串塞 options 字段(JSON.parse 出来是字符串)
+    // 例如 GLM 系经常这么做,arg h['options']='["A","B"]' → args.options='["A","B"]'
+    // 这里解开成真数组再转。
+    if (typeof raw === 'string') {
+        const t = raw.trim();
+        if (t.startsWith('[') && t.endsWith(']')) {
+            try {
+                const parsed = JSON.parse(t);
+                if (Array.isArray(parsed))
+                    return parsed.map((o) => String(o));
+            }
+            catch {
+                // 不是合法 JSON,保留为单元素数组(对应 input 模式)
+            }
+        }
+    }
+    return [];
+}
 // ---------- ask_human ----------
 export const askHumanTool = {
     name: 'ask_human',
@@ -30,9 +68,10 @@ export const askHumanTool = {
     },
     async execute(args) {
         const question = String(args.question ?? '');
-        const options = Array.isArray(args.options)
-            ? args.options.map((o) => String(o))
-            : [];
+        // 容错:部分 LLM(尤其 GLM 系)把数组/对象 stringify 后塞进来,这里识别「长得很像 JSON
+        // 数组的单字符串元素」并解开,避免菜单只剩一行 [object Object]、逼用户手动输入。
+        // 任何一步失败 / 解出非数组:降级 input,与原代码语义一致。
+        const options = coerceOptions(args.options);
         const context = args.context ? String(args.context) : undefined;
         // 桌宠:面板弹出期间广播 waiting_human(红灯闪烁,提示需要人工介入);拿到响应后 sendState 会被
         // 下一个 hook 事件(如 onToolDone→tool_call)覆盖,这里不用手动切回——与其它工具状态转移逻辑一致。