mocode-ai 1.2.8 → 1.2.9

package/dist/agent/core.js

@@ -6,7 +6,7 @@
 // spawn.ts 的 spawnAgent = runAgentCore + 静默 hooks(子 agent)。
 import { readFileSync } from 'node:fs';
 import { getNotesMtime } from '../session/notes.js';
-import { chat, estimatePromptTokens, estimateTokens, planChatTools, chatTools, } from '../llm/index.js';
+import { chat, estimatePromptTokens, estimateTokens, isContextLengthError, planChatTools, chatTools, } from '../llm/index.js';
 import { executeToolOutcome, findTool, getToolCapabilities, isFileMutationTool, } from '../tools/registry.js';
 import { checkPermission } from '../permissions/index.js';
 import { validateToolArguments } from '../tools/validation.js';
@@ -313,16 +313,26 @@ export async function runAgentCore(opts) {
                 //  ① 它会被追加到本次请求末尾(见下方 ephemeralReminder),属于本步固定开销,
                 //     必须计入压力线——它不在 history 里,调度器只能由此入参看见(否则最多 5k
                 //     的笔记 + plan 段对 80% 触发线完全不可见,小窗口模型会压不住);
-                //  ② 同一份字符串复用到下方 reminder,避免每步重复读 notes.md。
-                const sessionStateText = opts.suppressSessionState ? '' : buildSessionStateReminder();
+                //  ② 压缩步在压缩成功后重取(P2 固结的 Compaction Snapshot 当步即可见)。
+                let sessionStateText = opts.suppressSessionState ? '' : buildSessionStateReminder();
                 // The scheduler is the only automatic path that may compress old evidence.
                 // Normal tool pushes and lifecycle tracking remain metadata-only.
+                // 压缩**之前**先刷一次状态栏:bar 要显示「本步真实 prompt 撞线」那一刻。
+                // 触发器算的就是 history + 工具 schema + 本段 sessionStateText,此刻三者都已就位,
+                // bar 与触发器完全同口径同一步。若等压缩跑完再刷,那 30+ 秒的 LLM 摘要调用里
+                // bar 一直冻在上一步的值,用户只看到「75% 怎么就压了」。
+                runtimeContextState.ephemeralText = sessionStateText || undefined;
+                onContextUpdate?.();
                 // 步前:五区 Budget Scheduler 在当前完整 history 上决策；开关关闭时退化回 maybeCompact 路径。
                 // 此时 spinner 已停,通知行干净。
                 let historyRebuilt = false;
+                /** 本步是否已因「后端报上下文超长」压过一轮(限一次,防压缩↔重试死循环)。 */
+                let overflowRetried = false;
                 const compactStartedAt = Date.now();
                 if (scheduler) {
-                    historyRebuilt = await scheduler.runStep(history, step, activeTools, sessionStateText ? estimateTokens(sessionStateText) : 0);
+                    historyRebuilt = await scheduler.runStep(history, step, activeTools, sessionStateText ? estimateTokens(sessionStateText) : 0, 
+                    // signal 透传:压缩的 LLM 摘要是几十秒的调用,不串进来 Ctrl+C 掐不断。
+                    signal);
                     if (scheduler.lastRunLog?.compactHistoryCalled) {
                         emitTrace('compact', {
                             source: 'automatic',
@@ -333,7 +343,7 @@ export async function runAgentCore(opts) {
                     }
                 }
                 else {
-                    const compactResult = await maybeCompact(history, undefined, undefined, runtimeContextState, activeTools);
+                    const compactResult = await maybeCompact(history, undefined, undefined, runtimeContextState, activeTools, signal);
                     historyRebuilt = compactResult?.historyRebuilt === true;
                     if (compactResult) {
                         emitTrace('compact', {
@@ -354,6 +364,11 @@ export async function runAgentCore(opts) {
                         runtimeContextState.lifecycleStats = lifecycle.stats();
                     }
                     rehydrateArtifacts(runtimeContextState, history);
+                    // 压缩可能刚把进度快照固结进 notes.md(P2)→ 重取,让本步 requestHistory
+                    // 末尾就带上最新 Compaction Snapshot,不必等下一步。bar 口径对应的
+                    // ephemeralText 仍用触发时旧值(见 buildRequestHistory 注释),仅差这一段。
+                    if (!opts.suppressSessionState)
+                        sessionStateText = buildSessionStateReminder();
                     // 会话状态(活跃 plan + 笔记段)不再回写 history[0]:每步都会在 requestHistory
                     // 末尾注入最新副本(见下方 ephemeralReminder),compact 后自然恢复。
                 }
@@ -377,22 +392,41 @@ export async function runAgentCore(opts) {
                 //  - 会话状态:notes.md 的活跃 plan + 笔记正文(纯读,每步重取,始终最新)。
                 //  .filter(Boolean) 保证空段不产生多余空行;三段全空时不追加任何消息(requestHistory === history)。
                 //  安全保证:只拼进 requestHistory(新建数组),绝不写回 history,故不会跨 step/跨 turn 残留。
-                const ephemeralReminder = [
-                    (!opts.suppressOpeningAnalysis && step === 0)
-                        ? '## Opening analysis\nBegin your FIRST response of this turn with a brief analysis of the request and your planned approach (1-3 sentences, no filler), THEN start tool calls. This opening is the only place where pre-tool prose is expected; after it, work quietly with no narration between tool calls.'
-                        : '',
-                    historyRebuilt
-                        ? '## Post-compaction recovery\nContext was compacted before this request. Re-establish the current objective and unresolved work from retained evidence or the session note, avoid repeating completed investigation, and re-read exact file context before any dependent edit.'
-                        : '',
-                    sessionStateText, // 调度器之前已取(并计入压力线),此处复用同一份,不重复读文件
-                ].filter(Boolean).join('\n\n');
-                const requestHistory = ephemeralReminder
-                    ? [...history, { role: 'system', content: ephemeralReminder }]
-                    : history;
+                // 抽成函数:后端报上下文超长时压缩后要按新 history 重建一次(见下方 catch)。
+                // 不写 contextState.ephemeralText:bar 用的是触发器同口径的 sessionStateText
+                // (步骤顶部已设),而本函数还会额外拼 opening / post-compact 段——那两段触发器
+                // 不计,让 bar 用会让两条线再错开几百 token。
+                const buildRequestHistory = () => {
+                    const ephemeralReminder = [
+                        (!opts.suppressOpeningAnalysis && step === 0)
+                            ? '## Opening analysis\nBegin your FIRST response of this turn with a brief analysis of the request and your planned approach (1-3 sentences, no filler), THEN start tool calls. This opening is the only place where pre-tool prose is expected; after it, work quietly with no narration between tool calls.'
+                            : '',
+                        historyRebuilt
+                            ? '## Post-compaction recovery\n' +
+                                'Context was compacted before this request. Recover before doing anything else, in this order:\n' +
+                                '1. Read the session summary at the top of the history: `## Completed` is already done — do not redo or re-verify it. `## In Progress` / `## Next Steps` tell you exactly where work stopped and what is next.\n' +
+                                '2. Read `## Session state` below (from notes.md, refreshed every step): the active plan is authoritative — `[x]` steps are finished, resume from the first `[ ]`. A `## Compaction Snapshot` section there is the progress checkpoint written at this compaction.\n' +
+                                (sessionStateText
+                                    ? ''
+                                    : '(No active plan or snapshot was found in notes.md — reconstruct what is done purely from the summary and treat its `## Completed` as ground truth.)\n') +
+                                '3. Before any file edit, read_file the target fresh to get the current content hash — never edit from memory of pre-compaction content.\n' +
+                                '4. Before re-running a search/read you think you already did, check the summary and notes first: only repeat it if the result is genuinely missing or the target has changed.'
+                            : '',
+                        sessionStateText, // 调度器之前已取(并计入压力线),此处复用同一份,不重复读文件
+                    ].filter(Boolean).join('\n\n');
+                    return ephemeralReminder
+                        ? [...history, { role: 'system', content: ephemeralReminder }]
+                        : history;
+                };
+                let requestHistory = buildRequestHistory();
+                // 再刷一次:压缩刚跑完(history 已重建),bar 从「撞线 82%」跳到「压后 62%」,
+                // 让用户看到压缩确实起了作用。撞线那一刻的刷新在步骤顶部(trigger 之前),
+                // 那一次才是解释「为什么要压」的。
+                onContextUpdate?.();
                 // 实时用量:当前步 prompt 估算(含校准系数)+ 流式累计 completion 估算,
                 // 叠上已完成步的实测 turnUsage,经 onLiveUsage 推给底栏实时 chip。
                 // turnUsage 在闭包里被 addUsage 原地更新,reportLive 每次调用读最新值。
-                const stepPromptEst = estimatePromptTokens(requestHistory, activeTools, runtimeContextState.correction);
+                let stepPromptEst = estimatePromptTokens(requestHistory, activeTools, runtimeContextState.correction);
                 const reportLive = (p) => {
                     // 当前步 prompt:末尾 usage chunk 到达后用实测,流式期间用估算(含校准)。
                     // 当前步 cache 命中同理:上报即用实测;流式期间按前缀缓存估算 ≈ 上一步实测 prompt
@@ -410,34 +444,44 @@ export async function runAgentCore(opts) {
                     });
                 };
                 reportLive({ completionTokens: 0 }); // 思考阶段先显 ↑ prompt 估算,首 token 到达后 ↓ 开始涨
-                try {
-                    result = await chat(requestHistory, {
-                        onText,
-                        onToolCall,
-                        onProgress: reportLive,
-                        onRetry: (retry) => emitTrace('model_retry', {
+                // 单一 chat 入口:错误侧的 model_end 埋点只写一处(重试也会记,不丢失败轨迹)。
+                const chatHandlers = {
+                    onText,
+                    onToolCall,
+                    onProgress: reportLive,
+                    onRetry: (retry) => emitTrace('model_retry', {
+                        model: requestModel,
+                        provider,
+                        attempt: retry.attempt,
+                        nextAttempt: retry.nextAttempt,
+                        waitMs: retry.waitMs,
+                        code: retry.code,
+                    }),
+                };
+                const runChatOnce = async () => {
+                    try {
+                        return await chat(requestHistory, chatHandlers, signal, activeTools);
+                    }
+                    catch (err) {
+                        const errorValue = err && typeof err === 'object'
+                            ? err
+                            : undefined;
+                        emitTrace('model_end', {
                             model: requestModel,
                             provider,
-                            attempt: retry.attempt,
-                            nextAttempt: retry.nextAttempt,
-                            waitMs: retry.waitMs,
-                            code: retry.code,
-                        }),
-                    }, signal, activeTools);
+                            status: signal?.aborted ? 'aborted' : 'error',
+                            code: typeof errorValue?.status === 'number'
+                                ? `HTTP_${errorValue.status}`
+                                : errorValue?.code ?? errorValue?.name ?? 'MODEL_ERROR',
+                            durationMs: Date.now() - modelStartedAt,
+                        });
+                        throw err;
+                    }
+                };
+                try {
+                    result = await runChatOnce();
                 }
                 catch (e) {
-                    const errorValue = e && typeof e === 'object'
-                        ? e
-                        : undefined;
-                    emitTrace('model_end', {
-                        model: requestModel,
-                        provider,
-                        status: signal?.aborted ? 'aborted' : 'error',
-                        code: typeof errorValue?.status === 'number'
-                            ? `HTTP_${errorValue.status}`
-                            : errorValue?.code ?? errorValue?.name ?? 'MODEL_ERROR',
-                        durationMs: Date.now() - modelStartedAt,
-                    });
                     // 中断(用户运行中 Ctrl+C):chat() 抛 AbortError(signal.aborted)→ 还原 history + 模式 + return(不抛)。
                     // 工具执行现已串 signal:run_command/web_fetch 被 abort 即时杀,循环顶检查兜底(不会留未配对 tool_call_id)。
                     if (signal?.aborted ||
@@ -454,7 +498,46 @@ export async function runAgentCore(opts) {
                             changedFiles: mutation.changedFiles.map((item) => item.path),
                         };
                     }
-                    throw e;
+                    // 后端实测拒绝了 prompt(上下文超长):本地估算对该 provider 系统性偏低时,
+                    // 压力线压不住,这是唯一可信的触发。强压一轮后重试一次;仍失败才抛(限一次,防循环)。
+                    if (!overflowRetried && isContextLengthError(e)) {
+                        overflowRetried = true;
+                        // 估算被后端证伪:raw×correction 明明在压力线以下,真实 prompt 却超了窗。
+                        // 用「实测 = 窗口」这个下限样本喂校准,让压力线对这家 provider 立刻变严——
+                        // 否则每一步都要等后端报错才压,而不是提前压。EWMA α=0.2 + [0.5,2] 夹逼,
+                        // 偶发误判会被后续真实 usage 样本拉回。
+                        const rawEstimate = estimatePromptTokens(requestHistory, activeTools);
+                        if (rawEstimate > 1_000) {
+                            const cal = updateTokenCalibration(requestBaseURL, requestModel, activeTools, rawEstimate, config.contextWindowTokens);
+                            runtimeContextState.correction = cal.correction;
+                            runtimeContextState.calibrationSamples = cal.samples;
+                        }
+                        const overflowResult = await maybeCompact(history, undefined, { manual: true, force: true }, runtimeContextState, activeTools, signal);
+                        emitTrace('compact', {
+                            source: 'overflow_retry',
+                            reason: overflowResult?.reason ?? 'noop',
+                            compacted: overflowResult?.compacted === true,
+                            estimateBefore: overflowResult?.estimateBefore,
+                            estimateAfter: overflowResult?.estimateAfter,
+                            durationMs: Date.now() - modelStartedAt,
+                        });
+                        if (!overflowResult?.compacted)
+                            throw e; // 压不动:没法救,原样抛
+                        if (overflowResult.historyRebuilt) {
+                            historyRebuilt = true;
+                            if (lifecycle) {
+                                lifecycle = createLifecycleEngine(history);
+                                runtimeContextState.lifecycleStats = lifecycle.stats();
+                            }
+                            rehydrateArtifacts(runtimeContextState, history);
+                        }
+                        requestHistory = buildRequestHistory();
+                        stepPromptEst = estimatePromptTokens(requestHistory, activeTools, runtimeContextState.correction);
+                        result = await runChatOnce(); // 仍超长 → 抛出,交给上层报错
+                    }
+                    else {
+                        throw e;
+                    }
                 }
                 emitTrace('model_end', {
                     model: requestModel,

package/dist/config/index.js

@@ -6,6 +6,7 @@ import { getCurrentSessionId } from '../session/state.js';
 import { getNotesFilePath, extractActiveNotesSections } from '../session/notes.js';
 import { buildWorkDisciplineSection, inferModelFamily } from '../agent/work-discipline.js';
 import { buildValidationCommandsSection } from '../verification/prompt.js';
+import { getActivePresetName, readPreset } from './presets.js';
 import { detectLanguage, setLanguage, t, } from '../i18n/index.js';
 /**
  * 按优先级加载配置文件并回填 process.env:
@@ -45,6 +46,16 @@ const LLM_ENV_KEYS = ['LLM_PROVIDER', 'LLM_BASE_URL', 'LLM_API_KEY', 'LLM_MODEL'
 export const DEFAULT_CONTEXT_WINDOW_TOKENS = 256000;
 const llmKeysFromShell = LLM_ENV_KEYS.filter((k) => process.env[k] !== undefined);
 loadEnvFiles();
+/**
+ * 激活预设覆盖:若用户曾用 /model 激活过预设,启动时让上下文窗口等配置**跟随该预设文件**,
+ * 而不是只信 config 文件里上一组裸 LLM 键——这正是"切换后窗口不再退回 256k"的关键。
+ * 逐字段覆盖,且 shell 已显式设置的键**不覆盖**(保持 shell 环境变量最高优先级)。
+ * 不 import repl,无副作用;读失败(指针失效/文件坏)静默回退到 config 文件裸键。
+ */
+const __activePreset = (() => {
+    const n = getActivePresetName();
+    return n ? readPreset(n) : null;
+})();
 setLanguage(detectLanguage(process.env.MOCODE_LANGUAGE));
 export function normalizeLlmProvider(value) {
     return typeof value === 'string' && value.toLowerCase() === 'anthropic' ? 'anthropic' : 'openai';
@@ -479,19 +490,33 @@ export function getPlanModeSuffix() {
     return buildPlanModeSuffix();
 }
 export const config = {
-    provider: normalizeLlmProvider(process.env.LLM_PROVIDER),
-    baseURL: requireEnv('LLM_BASE_URL'),
-    apiKey: requireEnv('LLM_API_KEY'),
-    model: process.env.LLM_MODEL || 'gpt-4o-mini',
+    provider: llmKeysFromShell.includes('LLM_PROVIDER')
+        ? normalizeLlmProvider(process.env.LLM_PROVIDER)
+        : (__activePreset?.provider ?? normalizeLlmProvider(process.env.LLM_PROVIDER)),
+    baseURL: llmKeysFromShell.includes('LLM_BASE_URL')
+        ? requireEnv('LLM_BASE_URL')
+        : (__activePreset?.baseURL ?? requireEnv('LLM_BASE_URL')),
+    apiKey: llmKeysFromShell.includes('LLM_API_KEY')
+        ? requireEnv('LLM_API_KEY')
+        : (__activePreset?.apiKey ?? requireEnv('LLM_API_KEY')),
+    model: llmKeysFromShell.includes('LLM_MODEL')
+        ? (process.env.LLM_MODEL || 'gpt-4o-mini')
+        : (__activePreset?.model ?? process.env.LLM_MODEL ?? 'gpt-4o-mini'),
     maxTokens: process.env.MAX_TOKENS ? Number(process.env.MAX_TOKENS) : undefined,
     // 用 getter 而非 buildBasePrompt() 立即求值:因为本对象字面量求值时 buildBasePrompt 读 config.memoryEnabled,
     // 而 config 还没完成初始化(TDZ)。Getter 让每次访问都现拼,运行时 /memory_switch 立即生效。
     get systemPrompt() {
         return buildBasePrompt();
     },
-    contextWindowTokens: Number(process.env.CONTEXT_WINDOW_TOKENS) || DEFAULT_CONTEXT_WINDOW_TOKENS,
+    contextWindowTokens: llmKeysFromShell.includes('CONTEXT_WINDOW_TOKENS')
+        ? (Number(process.env.CONTEXT_WINDOW_TOKENS) || DEFAULT_CONTEXT_WINDOW_TOKENS)
+        : (__activePreset?.contextWindow
+            ?? Number(process.env.CONTEXT_WINDOW_TOKENS)
+            ?? DEFAULT_CONTEXT_WINDOW_TOKENS),
     includeUsage: process.env.LLM_STREAM_USAGE !== 'false',
-    anthropicPromptCache: process.env.ANTHROPIC_PROMPT_CACHE !== 'false',
+    anthropicPromptCache: llmKeysFromShell.includes('ANTHROPIC_PROMPT_CACHE')
+        ? process.env.ANTHROPIC_PROMPT_CACHE !== 'false'
+        : (__activePreset?.anthropicPromptCache ?? process.env.ANTHROPIC_PROMPT_CACHE !== 'false'),
     autoCompact: process.env.AUTO_COMPACT !== 'false',
     contextOptimize: process.env.MOCODE_CONTEXT_OPTIMIZE === 'true',
     contextRelprune: process.env.MOCODE_CONTEXT_RELPRUNE === 'true',

package/dist/config/presets.js

@@ -19,6 +19,32 @@ import path from 'node:path';
  */
 /** 预设目录:`~/.mocode/models/`(按需创建)。 */
 export const MODELS_DIR = path.join(os.homedir(), '.mocode', 'models');
+/**
+ * 激活预设指针文件:`~/.mocode/models/.active`,内容为一行预设名。
+ * 激活预设是"上下文窗口等配置跟随模型"的真相来源:启动与它窗切换都以此覆盖 LLM 四键。
+ * 与 <name>.json 区分:`.active` 不以 .json 结尾、且 '.' 非法首字符,listPresets 天然跳过。
+ */
+export const ACTIVE_PRESET_PATH = path.join(MODELS_DIR, '.active');
+/** 读激活预设名;不存在/空返回 null(供启动回退到 config 文件的裸 LLM 键)。 */
+export function getActivePresetName() {
+    try {
+        const name = fs.readFileSync(ACTIVE_PRESET_PATH, 'utf8').trim();
+        return isValidPresetName(name) ? name : null;
+    }
+    catch {
+        return null; // 不存在或不可读:无激活预设
+    }
+}
+/** 写激活预设指针(原子:写 tmp 再 rename)。name 必须在预设目录里存在,防止指向空指针。 */
+export function setActivePresetName(name) {
+    if (!isValidPresetName(name)) {
+        throw new Error(`非法预设名: ${JSON.stringify(name)}`);
+    }
+    fs.mkdirSync(MODELS_DIR, { recursive: true });
+    const tmp = `${ACTIVE_PRESET_PATH}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmp, `${name}\n`, 'utf8');
+    fs.renameSync(tmp, ACTIVE_PRESET_PATH);
+}
 const NAME_RE = /^[a-zA-Z0-9_-]{1,32}$/;
 /** 名字是否合法(调用方复用,避免在多处重复同一正则)。 */
 export function isValidPresetName(name) {
@@ -95,10 +121,16 @@ export function savePreset(preset) {
     fs.writeFileSync(tmp, JSON.stringify(normalized, null, 2), 'utf8');
     fs.renameSync(tmp, dest);
 }
-/** 删除一个预设;不存在返回 false,成功返回 true。 */
+/** 删除一个预设;不存在返回 false,成功返回 true。若删的是激活预设,顺带清掉指针。 */
 export function deletePreset(name) {
     try {
         fs.unlinkSync(filePathFor(name));
+        if (getActivePresetName() === name) {
+            try {
+                fs.unlinkSync(ACTIVE_PRESET_PATH);
+            }
+            catch { /* 指针已不在,忽略 */ }
+        }
         return true;
     }
     catch (e) {
@@ -136,6 +168,9 @@ export function renamePreset(oldName, newName) {
     const p = parsePreset(fs.readFileSync(newPath, 'utf8'));
     if (p.name !== newName)
         savePreset({ ...p, name: newName });
+    // 激活预设被重命名 → 指针跟随新名,否则下次启动回退裸 config 丢窗口。
+    if (getActivePresetName() === oldName)
+        setActivePresetName(newName);
     return true;
 }
 /** 列出全部预设(按 name 升序);目录不存在返回空数组。 */

package/dist/context/budget.js

@@ -152,21 +152,6 @@ export function evaluateBudget(history, window, step = 0, correction = 1, active
  * Per-layer overages are diagnostics, never independent rewrite triggers. */
 export function scheduleActions(report) {
     const actions = [];
-    const { layers } = report;
-    if (layers.system.overBudget) {
-        const { prompt, toolSchemas, ephemeralInjection } = report.systemCosts;
-        const { actual, budget } = layers.system;
-        const excess = actual - budget;
-        const percent = ((actual / Math.max(budget, 1)) * 100).toFixed(0);
-        actions.push({
-            kind: 'warn',
-            layer: 'system',
-            reason: `固定开销 ${actual}/${budget} (+${excess}, ${percent}%)；`
-                + `提示 ${prompt} + 工具 ${toolSchemas}`
-                + (ephemeralInjection > 0 ? ` + 尾部注入 ${ephemeralInjection}` : '')
-                + `，×${report.correction.toFixed(2)}。`,
-        });
-    }
     const pressureLine = DEFAULT_BUDGET_POLICY.pressureTriggerRatio * report.window;
     if (Math.max(report.rawTotal, report.total) >= pressureLine) {
         actions.push({ kind: 'compact_history' });

package/dist/llm/index.js

@@ -111,6 +111,39 @@ export function isRetryableError(err, signal) {
     }
     return false;
 }
+/**
+ * 判定一次失败是否是「请求上下文超长」(后端实测拒绝了我们的 prompt)。
+ *
+ * 与压力线(本地启发式估算)的区别:这是**实测**信号。估算对某些 provider 会系统性偏低
+ * (CJK 分词、多模态、特殊 schema),压力线压不住时,后端这声 400 是唯一可信的兜底触发。
+ * agent/core 捕获后强压一轮再重试一次(限一次,防循环)。
+ *
+ * 判定刻意保守:只在 status 明确(400/413/422)或 status 缺失(代理把错误折叠成普通
+ * Error)时才认语义;5xx / 429 一律不算——那种重试压缩也救不回来。
+ */
+export function isContextLengthError(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const e = err;
+    if (e.code === 'context_length_exceeded' || e.type === 'context_length_exceeded')
+        return true;
+    if (e.code === 'string_above_max_length')
+        return true;
+    if (typeof e.status === 'number' && e.status >= 500)
+        return false;
+    if (typeof e.status === 'number' && e.status !== 400 && e.status !== 413 && e.status !== 422) {
+        return false;
+    }
+    // 413 是网关/代理对「请求体过大」的直白判决,不带 message 也认。
+    if (e.status === 413)
+        return true;
+    const msg = typeof e.message === 'string' ? e.message.toLowerCase() : '';
+    if (!msg)
+        return false;
+    return (/context[_ ]length|context window|maximum context|too many tokens|string_above_max_length/.test(msg) ||
+        /(input|prompt|context|request).{0,20}too (long|large)|exceeds? the (model|maximum|context)/.test(msg) ||
+        /reduce the length|上下文(长度)?(超|过)|超出.*上下文|请求过长|长度超过|token 数?超过/.test(msg));
+}
 /** 从 OpenAI APIError.headers 解析 Retry-After(秒);不支持或缺失返回 undefined。封顶 RETRY_MAX_MS。 */
 export function getRetryAfterMs(err) {
     const headers = err?.headers;

package/dist/repl/index.js

@@ -5,7 +5,7 @@ import { config, updateModelConfig, isModelConfigured, updateMemoryConfig, isMem
 import { getLanguage, normalizeLanguage, t, } from '../i18n/index.js';
 import { DEFAULT_BUDGET_POLICY } from '../context/budget.js';
 import { updateConfigKey, writeConfigKeys, CONFIG_PATH } from '../config/file.js';
-import { deletePreset, getPreset, isValidPresetName, listPresets, migrateCurrentToPreset, savePreset, } from '../config/presets.js';
+import { deletePreset, getPreset, isValidPresetName, listPresets, migrateCurrentToPreset, savePreset, setActivePresetName, } from '../config/presets.js';
 import { runAgent } from '../agent/index.js';
 import { getAgentMode, setAgentMode, onModeChange } from '../agent/mode.js';
 import { togglePet, killPetProcess, listSkins, setSkin, sendState } from '../pet/bridge.js';
@@ -19,7 +19,7 @@ import { promptWithSlashMenu, promptTurnPicker, promptSessionPicker, promptTheme
 import { promptIntervention } from '../ui/intervention.js';
 import { registerToolsExtension } from '../tools/registry.js';
 import { initializeAllMcp, getMcpTools, closeAllMcp } from '../mcp/index.js';
-import { estimateMessagesTokens, reconfigureClient, refreshChatTools, chatTools, } from '../llm/index.js';
+import { estimateMessagesTokens, reconfigureClient, refreshChatTools, chatTools, estimatePromptTokens, estimateTokens, } from '../llm/index.js';
 import { loadImageAttachment, renderChip, MAX_INLINE_BYTES_DEFAULT, } from '../attachments/image.js';
 import { modelSupportsVision } from '../llm/capabilities.js';
 import { computePruneStats } from '../context/relevance.js';
@@ -244,11 +244,21 @@ function renderContextBar(history) {
     return `${ui.gray}[${pctCol}${bar}${ui.reset}] ${Math.round(pct * 100)}%  ${k(est)}/${k(win)} tokens · ${t('status.messages', { count: history.length })} (${src})${ui.reset}${artifactLine}${lifecycleLine}${archiveLine}`;
 }
 /** 状态行用量条(精简版,进底栏):[bar] pct% k/k。
- * 只计算对话内容(不含 system prompt),让用户感知"我发了多少、agent 回复了多少"占用 context。 */
+ * 必须**用全 prompt 估算**(消息 + 工具 schema + 尾部 ephemeral 注入),与压缩触发器
+ * evaluateBudget 的 system+history+toolOld+toolRecent 总账对齐——任何一段漏算都会让
+ * bar 与触发器口径不一致、看着没到 80% 实际已经在压。
+ * 触发器用 `Math.max(rawTotal, total) >= 0.8 * window`,bar 也照搬:校正后和校正前
+ * 哪个大取哪个,确保不会因 correction<1 而低估。ephemeral 文本由 agent/core 每步写入
+ * contextState.ephemeralText(避免在 bar 里再读一次 notes.md)。
+ *
+ * /context 命令仍是 dialog-only(见 renderContextBar):它的设计意图是"我说了多少"而非
+ * "还剩多少空间",两条职责分开。 */
 function renderContextBarInline(history) {
-    // 过滤掉 system 消息,只算对话内容
-    const dialog = history.filter(m => m.role !== 'system');
-    const est = estimateMessagesTokens(dialog);
+    const baseRaw = estimatePromptTokens(history, chatTools, 1);
+    const baseAdj = estimatePromptTokens(history, chatTools, contextState.correction);
+    const ephemeral = contextState.ephemeralText ? estimateTokens(contextState.ephemeralText) : 0;
+    // 与触发器同样的「取大」语义:correction<1 时 raw 更大,bar 不会假装很安全。
+    const est = Math.max(baseRaw, baseAdj) + ephemeral;
     const win = config.contextWindowTokens;
     const pct = Math.min(1, est / win);
     const W = 10;
@@ -1108,6 +1118,7 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             rebuildFromHistory(history);
         contextState.lastUsage = undefined;
         contextState.lifecycleStats = undefined;
+        contextState.ephemeralText = undefined;
         lastTurnUsage = undefined; // 续接:旧会话的 token 累计已无意义,清空等下轮覆写
         layout.clearContent();
         renderHistory(history);
@@ -1365,6 +1376,7 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             turnCount = 0; // 反思 cadence 重新计数
             contextState.lastUsage = undefined;
             contextState.lifecycleStats = undefined;
+            contextState.ephemeralText = undefined;
             lastTurnUsage = undefined; // 清空旧轮的 token 累计
             pendingAttachments = []; // 一并清空待发图片
             layout.clearContent();
@@ -1549,7 +1561,26 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
             // 走调度器路径:与自动每步压缩完全一致——五区按 ROI 压(cold tools 优先 → history 摘要最后)。
             // focus 透传到 compact_history action 的 LLM 摘要 prompt。
             // 返回 SchedulerRunLog 给 UI 显示决策;退化路径(开关关时)在 manualCompact 内部走 compactHistory。
-            const log = await manualCompact(history, focus, { force });
+            const log = await (async () => {
+                // /compact 的摘要是几十秒的 LLM 调用:包一层运行态监听让 Ctrl+C 能掐断它
+                // (信号透传 manualCompact → maybeCompact → compactHistory → chat)。
+                const signal = startRunningListener(t('running.compacting'));
+                try {
+                    return await manualCompact(history, focus, { force, signal });
+                }
+                finally {
+                    stopRunningListener();
+                }
+            })().catch((e) => {
+                // 中断:history 未被改动(重建在摘要成功之后),直接提示并回到输入态。
+                if (e instanceof Error && (e.name === 'AbortError' || e.name === 'APIUserAbortError')) {
+                    layout.contentWrite(`${ui.dim}(已取消压缩)${ui.reset}\n`);
+                    return null;
+                }
+                throw e;
+            });
+            if (!log)
+                continue;
             // 会话状态(plan + 笔记段)不在此处回写 history[0]:agent/core 每步都在 requestHistory
             // 末尾注入最新副本(buildSessionStateReminder),压缩后下一步自然恢复,且系统提示保持
             // 逐字节稳定以命中 prompt 缓存。
@@ -1737,6 +1768,11 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
                     ANTHROPIC_PROMPT_CACHE: target.anthropicPromptCache ? 'true' : 'false',
                 });
                 reconfigureClient();
+                // 记为激活预设:让上下文窗口等配置从此跟随该预设文件(下次启动也用它,不再回退 config 裸键)。
+                try {
+                    setActivePresetName(target.name);
+                }
+                catch { /* 指针写失败不阻断切换 */ }
                 refreshStatusBase(history);
                 layout.clearContent();
                 if (history.some((m) => m.role === 'user')) {
@@ -1748,9 +1784,9 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
                 const cacheLabel = target.provider === 'anthropic'
                     ? ` · Prompt Cache ${target.anthropicPromptCache ? 'on' : 'off'}`
                     : '';
-                layout.contentWrite(`${ui.dim}(已切换到预设 “${target.name}” → ${target.model} · ${target.provider}${cacheLabel} @ ${target.baseURL})${ui.reset}\n`);
+                layout.contentWrite(`${ui.dim}(已切换到预设 “${target.name}” → ${target.model} · ${target.provider}${cacheLabel} · 窗口 ${target.contextWindow} @ ${target.baseURL})${ui.reset}\n`);
                 if (config.llmKeysFromShell.length > 0) {
-                    layout.contentWrite(`${ui.dim}(shell 环境变量已设 ${config.llmKeysFromShell.join(' / ')},文件写入下次启动被其覆盖)${ui.reset}\n`);
+                    layout.contentWrite(`${ui.dim}(shell 环境变量已设 ${config.llmKeysFromShell.join(' / ')},优先级最高,下次启动会盖掉预设的对应字段;预设仍记为激活,取消 shell 设置后恢复跟随)${ui.reset}\n`);
                 }
             };
             // 决定自动存的预设名:协议、缓存配置和连接四元组都一致时不重复存。
@@ -1809,10 +1845,11 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
                     allowCustom: false, // 纯切换,不需要「其他」干扰
                 });
                 if (choice.action === 'selected' && choice.value) {
-                    // value 含 ANSI 序列(labelFor 用了 ui.dim);按 preset.name 前缀匹配。
-                    const idx = presets.findIndex((p) => choice.value.startsWith(p.name));
-                    const target = idx >= 0 ? presets[idx] : presets[0];
-                    applyPresetAndPersist(target);
+                    // 精确匹配 labelFor 生成的完整选项串,避免 name 前缀误命中
+                    // (如 'qwen3-8-27b' 是 'qwen3-8-27b-2' 的前缀,排序在前会抢中,应用错 contextWindow)。
+                    const target = presets.find((p) => labelFor(p) === choice.value);
+                    if (target)
+                        applyPresetAndPersist(target);
                 }
                 continue;
             }
@@ -2078,6 +2115,13 @@ export async function startRepl(initialHistory, sessionId, sandboxRootOverride,
                     });
                     savedName = finalName;
                 }
+                // 记为激活预设(新存或复用同名都记),让窗口跟随该预设文件。
+                if (savedName) {
+                    try {
+                        setActivePresetName(savedName);
+                    }
+                    catch { /* 指针写失败不阻断 */ }
+                }
             }
             catch (e) {
                 layout.contentWrite(`${ui.red}保存预设失败: ${e.message}${ui.reset}\n`);