mocode-ai 1.1.7 → 1.1.9

package/dist/runtime/dev-server-manager.js

@@ -0,0 +1,354 @@
+// 常驻后台进程管理器(dev server 等)。
+//
+// 与 run_command 的关键区别:run_command 是前台命令,超时或本轮 abort 即 killTree;
+// 这里的进程必须**跨工具调用存活**,所以生命周期只由显式 stop 或进程退出 / 全局 shutdown 决定。
+// 传入的 signal 只用于取消「启动 + 就绪等待」,绝不用于杀已就绪的服务 —— 否则用户下一次
+// Ctrl+C 会顺手把 dev server 干掉。
+//
+// 非安全边界:命令仍是任意 shell 命令(与 run_command 同级风险),故工具层声明 dangerous 风险,
+// 由权限系统在执行前向用户确认。
+import { spawn, spawnSync } from 'node:child_process';
+import { closeSync, openSync, writeSync } from 'node:fs';
+import { mkdir, open, stat } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { filterEnv, getSandboxRoot, isCommandDenied, jailResolve } from '../sandbox/index.js';
+export class DevServerManagerError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'DevServerManagerError';
+    }
+}
+const servers = new Map();
+const DEFAULT_READY_TIMEOUT_MS = 30_000;
+const MAX_READY_TIMEOUT_MS = 180_000;
+const READY_POLL_INTERVAL_MS = 250;
+const PROBE_TIMEOUT_MS = 2_000;
+const STOP_GRACE_MS = 1_500;
+const DEFAULT_LOG_BYTES = 8_000;
+const MAX_LOG_BYTES = 64_000;
+const RECENT_LOG_CHARS = 4_000;
+const IS_WINDOWS = process.platform === 'win32';
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** 进程是否仍存活;EPERM 说明 pid 存在但不属于当前用户。 */
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+function snapshot(record) {
+    return {
+        id: record.id,
+        pid: record.pid,
+        state: record.state,
+        exitCode: record.exitCode,
+        signal: record.signal,
+        command: record.command,
+        cwd: record.cwd,
+        logPath: record.logPath,
+        startedAt: record.startedAt,
+    };
+}
+function requireRecord(id) {
+    const record = servers.get(id);
+    if (!record) {
+        const known = [...servers.keys()];
+        throw new DevServerManagerError('INVALID_ARGUMENTS', known.length
+            ? `Unknown dev server id "${id}". Known ids: ${known.join(', ')}.`
+            : `Unknown dev server id "${id}". No dev server has been started in this session.`);
+    }
+    return record;
+}
+/** 只允许回环地址:防止 agent 借就绪探测去扫内网 / 打外网。 */
+function validateReadyUrl(input) {
+    let url;
+    try {
+        url = new URL(input);
+    }
+    catch {
+        throw new DevServerManagerError('INVALID_ARGUMENTS', `Invalid readyUrl: ${input}`);
+    }
+    const host = url.hostname.toLowerCase().replace(/^\[|\]$/g, '');
+    const loopback = host === 'localhost' || host === '127.0.0.1' || host === '::1';
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        throw new DevServerManagerError('INVALID_ARGUMENTS', 'readyUrl must use http or https.');
+    }
+    if (!loopback || url.username || url.password) {
+        throw new DevServerManagerError('INVALID_ARGUMENTS', 'readyUrl must target localhost, 127.0.0.1, or ::1 without credentials.');
+    }
+    return url;
+}
+function compileReadyPattern(input) {
+    try {
+        return new RegExp(input, 'i');
+    }
+    catch (error) {
+        throw new DevServerManagerError('INVALID_ARGUMENTS', `Invalid readyPattern: ${errorMessage(error)}`);
+    }
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            clearTimeout(timer);
+            reject(new DevServerManagerError('ABORTED', 'Dev server startup wait was aborted.'));
+        };
+        if (signal?.aborted) {
+            abort();
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', abort);
+            resolve();
+        }, ms);
+        signal?.addEventListener('abort', abort, { once: true });
+    });
+}
+/** 任意 HTTP 响应都算就绪:dev server 常在 / 返回 404 但端口已可用。 */
+async function probeReady(url) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+    try {
+        await fetch(url, { signal: controller.signal, redirect: 'manual' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function killTree(pid) {
+    try {
+        if (IS_WINDOWS) {
+            spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' });
+        }
+        else {
+            process.kill(pid, 'SIGTERM');
+        }
+    }
+    catch {
+        // 已退出或无权限:best-effort。
+    }
+}
+function finalizeExit(record, code, signalCode) {
+    record.state = record.stopRequested ? 'stopped' : 'exited';
+    record.exitCode = code;
+    record.signal = signalCode;
+    if (record.logFd !== null) {
+        try {
+            closeSync(record.logFd);
+        }
+        catch {
+            // 忽略:进程收尾期文件句柄可能已失效。
+        }
+        record.logFd = null;
+    }
+}
+/** 进程可能在事件回调之外被外部杀掉,读状态时顺带对账。 */
+function reconcile(record) {
+    if (record.state === 'running' && !isAlive(record.pid)) {
+        finalizeExit(record, record.child.exitCode, record.child.signalCode);
+    }
+    return record;
+}
+export async function startDevServer(opts) {
+    const command = opts.command.trim();
+    if (!command) {
+        throw new DevServerManagerError('INVALID_ARGUMENTS', 'command is required to start a dev server.');
+    }
+    const denied = isCommandDenied(command);
+    if (denied) {
+        throw new DevServerManagerError('SANDBOX_DENIED', denied);
+    }
+    const root = getSandboxRoot() ?? process.cwd();
+    let cwd = root;
+    if (opts.cwd) {
+        try {
+            cwd = jailResolve(opts.cwd);
+        }
+        catch (error) {
+            throw new DevServerManagerError('SANDBOX_DENIED', errorMessage(error));
+        }
+    }
+    const readyUrl = opts.readyUrl ? validateReadyUrl(opts.readyUrl) : null;
+    const readyPattern = opts.readyPattern ? compileReadyPattern(opts.readyPattern) : null;
+    const timeoutMs = Math.min(Math.max(Number(opts.timeoutMs ?? DEFAULT_READY_TIMEOUT_MS), 1_000), MAX_READY_TIMEOUT_MS);
+    const id = `srv-${randomBytes(3).toString('hex')}`;
+    const logPath = jailResolve(join('.mocode', 'dev-servers', `${id}.log`));
+    await mkdir(dirname(logPath), { recursive: true });
+    let logFd;
+    try {
+        logFd = openSync(logPath, 'a');
+    }
+    catch (error) {
+        throw new DevServerManagerError('EXECUTION_ERROR', `Unable to open log file: ${errorMessage(error)}`);
+    }
+    let child;
+    try {
+        child = spawn(IS_WINDOWS ? 'cmd.exe' : 'bash', IS_WINDOWS ? ['/d', '/s', '/c', command] : ['-c', command], {
+            cwd,
+            env: filterEnv(process.env),
+            windowsVerbatimArguments: IS_WINDOWS,
+            windowsHide: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    }
+    catch (error) {
+        closeSync(logFd);
+        throw new DevServerManagerError('EXECUTION_ERROR', `Unable to spawn dev server: ${errorMessage(error)}`);
+    }
+    if (child.pid === undefined) {
+        closeSync(logFd);
+        throw new DevServerManagerError('EXECUTION_ERROR', 'Dev server process did not report a pid.');
+    }
+    const record = {
+        id,
+        pid: child.pid,
+        state: 'running',
+        exitCode: null,
+        signal: null,
+        command,
+        cwd,
+        logPath,
+        startedAt: new Date().toISOString(),
+        child,
+        logFd,
+        stopRequested: false,
+        recentLog: '',
+    };
+    servers.set(id, record);
+    const onChunk = (chunk) => {
+        const text = chunk.toString('utf8');
+        record.recentLog = (record.recentLog + text).slice(-RECENT_LOG_CHARS);
+        if (record.logFd === null)
+            return;
+        try {
+            writeSync(record.logFd, text);
+        }
+        catch {
+            // 日志写失败不影响进程本身。
+        }
+    };
+    child.stdout?.on('data', onChunk);
+    child.stderr?.on('data', onChunk);
+    child.on('error', (error) => onChunk(Buffer.from(`\n[spawn error] ${error.message}\n`)));
+    child.on('close', (code, signalCode) => finalizeExit(record, code, signalCode));
+    const deadline = Date.now() + timeoutMs;
+    const wantsReadySignal = Boolean(readyUrl || readyPattern);
+    let ready = false;
+    try {
+        while (wantsReadySignal && Date.now() < deadline) {
+            if (record.state !== 'running') {
+                throw new DevServerManagerError('PROCESS_FAILED', `Dev server exited before becoming ready (exitCode=${record.exitCode ?? 'null'}). Recent output:\n${record.recentLog.trim() || '(no output)'}`);
+            }
+            if (readyPattern?.test(record.recentLog)) {
+                ready = true;
+                break;
+            }
+            if (readyUrl && await probeReady(readyUrl)) {
+                ready = true;
+                break;
+            }
+            await sleep(READY_POLL_INTERVAL_MS, opts.signal);
+        }
+    }
+    catch (error) {
+        // 启动失败 / 被中断:不留孤儿进程。
+        record.stopRequested = true;
+        killTree(record.pid);
+        finalizeExit(record, record.child.exitCode, record.child.signalCode);
+        throw error;
+    }
+    if (wantsReadySignal && !ready) {
+        record.stopRequested = true;
+        killTree(record.pid);
+        finalizeExit(record, record.child.exitCode, record.child.signalCode);
+        throw new DevServerManagerError('TIMEOUT', `Dev server did not become ready within ${timeoutMs}ms and was stopped. Recent output:\n${record.recentLog.trim() || '(no output)'}`);
+    }
+    return {
+        ...snapshot(reconcile(record)),
+        ready,
+        ...(opts.readyUrl ? { readyUrl: opts.readyUrl } : {}),
+        ...(opts.readyPattern ? { readyPattern: opts.readyPattern } : {}),
+        ...(record.recentLog.trim() ? { logTail: record.recentLog.trim().slice(-1_000) } : {}),
+    };
+}
+export function listDevServers() {
+    return [...servers.values()].map((record) => snapshot(reconcile(record)));
+}
+export function getDevServerStatus(id) {
+    if (!id)
+        return listDevServers();
+    return [snapshot(reconcile(requireRecord(id)))];
+}
+export async function readDevServerLogs(id, opts = {}) {
+    const record = reconcile(requireRecord(id));
+    const size = (await stat(record.logPath).catch(() => null))?.size ?? 0;
+    const limit = Math.min(Math.max(Number(opts.limit ?? DEFAULT_LOG_BYTES), 1), MAX_LOG_BYTES);
+    // 缺省读尾部(最新输出);显式 offset 支持增量轮询。
+    const requested = opts.offset === undefined ? Math.max(0, size - limit) : Math.max(0, Number(opts.offset));
+    const start = Math.min(requested, size);
+    const length = Math.min(limit, size - start);
+    let content = '';
+    if (length > 0) {
+        const handle = await open(record.logPath, 'r');
+        try {
+            const buffer = Buffer.alloc(length);
+            await handle.read(buffer, 0, length, start);
+            content = buffer.toString('utf8');
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    return {
+        id: record.id,
+        state: record.state,
+        offset: start,
+        nextOffset: start + length,
+        size,
+        hasMore: start + length < size,
+        content,
+    };
+}
+export async function stopDevServer(id) {
+    const record = reconcile(requireRecord(id));
+    if (record.state !== 'running') {
+        return { ...snapshot(record), alreadyStopped: true };
+    }
+    record.stopRequested = true;
+    killTree(record.pid);
+    const deadline = Date.now() + STOP_GRACE_MS;
+    while (Date.now() < deadline && isAlive(record.pid)) {
+        await sleep(50);
+    }
+    if (isAlive(record.pid) && !IS_WINDOWS) {
+        try {
+            process.kill(record.pid, 'SIGKILL');
+        }
+        catch {
+            // 已退出。
+        }
+    }
+    finalizeExit(record, record.child.exitCode, record.child.signalCode);
+    return { ...snapshot(record), alreadyStopped: false };
+}
+/** 全局退出清理:同步树杀所有仍存活的后台进程。可重复调用。 */
+export function stopAllDevServersSync() {
+    for (const record of servers.values()) {
+        if (record.state !== 'running')
+            continue;
+        record.stopRequested = true;
+        killTree(record.pid);
+        finalizeExit(record, record.child.exitCode, record.child.signalCode);
+    }
+}

package/dist/runtime/shutdown.js

@@ -0,0 +1,26 @@
+// 常驻资源的统一退出清理。
+//
+// 后台 dev server 是我们自己 spawn 的子进程,进程退出不会自动带走(Windows 尤其),必须显式树杀;
+// Playwright 浏览器进程在正常路径 await close(),硬退出路径依赖 Playwright 自身的 exit 处理。
+// 两个入口都必须幂等:normal exit / SIGINT / uncaughtException 可能重复触发。
+import { stopAllDevServersSync } from './dev-server-manager.js';
+let asyncDone = false;
+/** 正常退出路径:可 await,尽量优雅关闭。 */
+export async function shutdownRuntime() {
+    if (asyncDone)
+        return;
+    asyncDone = true;
+    stopAllDevServersSync();
+    try {
+        // 动态 import:未用过 browser 工具时不该把 playwright 拉进进程。
+        const { closeAllBrowsers } = await import('./browser-manager.js');
+        await closeAllBrowsers();
+    }
+    catch {
+        // 浏览器从未启动或已崩溃:忽略。
+    }
+}
+/** 同步兜底(process exit / 信号 / 未捕获异常):只做同步树杀,不留孤儿 dev server。 */
+export function shutdownRuntimeSync() {
+    stopAllDevServersSync();
+}

package/dist/session/compact.js

@@ -187,6 +187,39 @@ function flattenGroups(groups) {
     }
     return out;
 }
+/** 微压缩单个 group(原地):① tool 结果 content ② assistant tool_calls.arguments(provenance stub)
+ * ③ assistant 正文。只裁模型/工具产物,不动 user 原话;保 tool_call_id 配对。返回是否有改动。 */
+function microcompactGroup(g) {
+    let done = false;
+    for (const t of g.tools) {
+        const c = t.content;
+        if (typeof c === 'string' && c.length > MAX_OLD_TOOL_STUB) {
+            t.content = truncateMid(c, MAX_OLD_TOOL_STUB);
+            done = true;
+        }
+    }
+    const as = g.assistant;
+    if (as && as.role === 'assistant') {
+        if (typeof as.content === 'string' && as.content.length > MAX_OLD_TOOL_STUB) {
+            as.content = truncateMid(as.content, MAX_OLD_TOOL_STUB);
+            done = true;
+        }
+        // tool_calls 参数:整体超长才进,provenance stub 大字段(保 path + JSON 合法)。
+        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;
+                    done = true;
+                }
+            }
+        }
+    }
+    return done;
+}
 // ── 默认摘要器:复用 chat(),空 handlers 不打印 ──────────────────────────
 async function defaultSummarize(older, focus) {
     // 摘要前剥离多模态 user 消息里的图片(base64 会撑爆摘要 prompt;image 对摘要无信息量)。
@@ -256,7 +289,14 @@ export async function compactHistory(history, opts) {
         kept.unshift(g);
         keptTokens = nextTokens;
     }
-    const oldGroups = groups.slice(0, groups.length - kept.length);
+    let oldGroups = groups.slice(0, groups.length - kept.length);
+    // force(硬闸/手动强压):保护区不豁免——常规切分无旧区时只保最后一组,
+    // 其余全部进可压区(首轮/当前轮也一样)。仍按 group 边界切,不破坏 tool_call 配对。
+    if (oldGroups.length === 0 && opts.force && groups.length >= 2) {
+        kept.length = 0;
+        kept.push(groups[groups.length - 1]);
+        oldGroups = groups.slice(0, groups.length - 1);
+    }
     const noop = {
         compacted: false,
         summarized: false,
@@ -269,65 +309,27 @@ export async function compactHistory(history, opts) {
     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;
-                            }
-                        }
-                    }
-                }
+        if (opts.force && groups.length === 1) {
+            // force 但只剩单组(如首轮的单个 assistant+tools 组):原地微压缩、不动结构。
+            // 纯 user 原话组无可压项(不能毁掉用户请求),落到下方 noop 提示。
+            const single = groups[0];
+            const userOnly = single.tools.length === 0
+                && single.assistant?.role === 'user';
+            if (!userOnly && microcompactGroup(single)) {
+                const estimateAfter = estimatePromptTokens(history, activeTools, state.correction);
+                state.lastEstimate = estimateAfter;
+                state.lastUsage = undefined;
+                layout.contentWrite(`  ${ui.bold}${ui.accent}●${ui.reset} ${ui.accent}强制微压缩(单组)${ui.reset}  ${ui.dim}${estimateBefore} → ${estimateAfter} tokens${ui.reset}\n`);
+                return {
+                    compacted: true,
+                    summarized: false,
+                    estimateBefore,
+                    estimateAfter,
+                    reason: 'microcompact',
+                    protectedRatio,
+                    oldGroupCount: 0,
+                };
             }
-            const refs = collectArtifactRefs(older);
-            const summaryMsg = {
-                role: 'system',
-                content: older.length > 0
-                    ? `# 会话摘要(force)\n被跳过的早期对话 ${older.length} 条已微压缩(token 数减少)。${refs.length > 0 ? `\n[artifact refs: ${refs.join(', ')}]` : ''}`
-                    : `# 会话摘要(force)\n无内容。`,
-            };
-            const rebuilt = [history[0], summaryMsg, ...keptAfter];
-            history.length = 0;
-            history.push(...rebuilt);
-            pruneAfterCompaction(history);
-            const estimateAfter = estimatePromptTokens(history, activeTools, state.correction);
-            state.lastEstimate = estimateAfter;
-            state.lastUsage = undefined;
-            layout.contentWrite(`  ${ui.bold}${ui.accent}●${ui.reset} ${ui.accent}强制压缩(focus on early history)${ui.reset}  ${ui.dim}${estimateBefore} → ${estimateAfter} tokens${ui.reset}\n`);
-            return {
-                compacted: true,
-                summarized: false,
-                historyRebuilt: true,
-                estimateBefore,
-                estimateAfter,
-                reason: microcompactDone2 ? 'microcompact' : 'summarize',
-                protectedRatio,
-                oldGroupCount: 0,
-            };
         }
         // 细分 noop 类型,供 repl 文案
         const isEmpty = history.length <= 1; // 只有 system 提示
@@ -350,35 +352,8 @@ export async function compactHistory(history, opts) {
     //   ③ 旧 assistant 正文 content(模型长解释,回看价值低)。
     let microcompactDone = false;
     for (const g of oldGroups) {
-        for (const t of g.tools) {
-            const c = t.content;
-            if (typeof c === 'string' && c.length > MAX_OLD_TOOL_STUB) {
-                t.content = truncateMid(c, MAX_OLD_TOOL_STUB);
-                microcompactDone = true;
-            }
-        }
-        const as = g.assistant;
-        if (as && as.role === 'assistant') {
-            // ③ 旧正文 content
-            if (typeof as.content === 'string' && as.content.length > MAX_OLD_TOOL_STUB) {
-                as.content = truncateMid(as.content, MAX_OLD_TOOL_STUB);
-                microcompactDone = true;
-            }
-            // ② tool_calls 参数:整体超长才进,provenance stub 大字段(保 path + JSON 合法)。
-            //   stubToolCallArguments:大字符串字段 → "<N 字符,已省略>";path 永不省(/rollback 依赖)。
-            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;
-                        microcompactDone = true;
-                    }
-                }
-            }
-        }
+        if (microcompactGroup(g))
+            microcompactDone = true;
     }
     // 第二层:摘要——把旧区(微压缩后)压成一条 system 摘要
     const older = flattenGroups(oldGroups);
@@ -450,14 +425,14 @@ export async function compactHistory(history, opts) {
  * 自动压缩门槛: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 解不开时才触发。
+ * The shared 80% pressure threshold is the only automatic trigger. Raw estimates
+ * participate so correction<1 cannot hide an oversized provider request.
+ *
+ * Budget Scheduler 模式在同一次 80% pressure 事件中先完成已启用的
+ * superseded / stale artifact / logs-search 清理，然后无条件继续压缩历史。
  *
- * 不传 report 时退化为原行为:仅看总占用是否超 `compactThreshold * window`——
- * 兼容老调用方(子 agent / 测试直接调时),零行为变化。
+ * 不传 report 时使用同一个共享阈值，供子 agent 和关闭 scheduler 时 fallback；
+ * 不再维护独立的自动压缩触发线。
  *
  * manual 选项(repl /compact 用):true 时旁路 autoCompact 开关与 ROI 阈,
  * 强制走 compactHistory(manual/force 参数透传)。返 CompactResult 给 caller 文案展示。
@@ -467,28 +442,37 @@ export async function maybeCompact(history, report, manualOpts, state = contextS
     const est = estimatePromptTokens(history, activeTools, state.correction);
     state.lastEstimate = est;
     const isManual = manualOpts?.manual === true;
+    // Hard guard: the scheduler has already attempted pressure cleanup; if raw
+    // content remains near the provider limit, compact even when correction < 1.
+    let hardCap = typeof report?.rawTotal === 'number'
+        && typeof report?.window === 'number'
+        && report.rawTotal >= DEFAULT_BUDGET_POLICY.pressureTriggerRatio * report.window;
     // 手动路径:旁路 autoCompact / report / 总阈三重门
     if (!isManual) {
-        if (!config.autoCompact)
+        if (!hardCap && !config.autoCompact)
             return;
         if (report) {
-            // 调度模式:只压 history 层超或兜底总超
-            const needsCompact = report.layers.history.overBudget || report.totalOver;
+            // Scheduler mode: the shared pressure report is the sole automatic trigger.
+            const needsCompact = hardCap || report.totalOver;
             if (!needsCompact)
                 return;
         }
         else {
-            // 老路径:总占用超阈才压
-            if (est < config.compactThreshold * config.contextWindowTokens)
+            // Fallback mode uses the same threshold; there is no second compact gate.
+            const raw = estimatePromptTokens(history, activeTools, 1);
+            hardCap = raw >= DEFAULT_BUDGET_POLICY.pressureTriggerRatio * config.contextWindowTokens;
+            const pressureLine = DEFAULT_BUDGET_POLICY.pressureTriggerRatio * config.contextWindowTokens;
+            if (!hardCap && est < pressureLine)
                 return;
         }
     }
     const r = await compactHistory(history, {
         window: config.contextWindowTokens,
-        threshold: config.compactThreshold,
+        threshold: DEFAULT_BUDGET_POLICY.pressureTriggerRatio,
         focus: manualOpts?.focus,
         manual: isManual,
-        force: manualOpts?.force,
+        // 硬闸触发时 force 直通保护区:首轮/当前轮不豁免。
+        force: manualOpts?.force === true || hardCap,
         tools: activeTools,
         contextState: state,
     });

package/dist/session/index.js

@@ -10,7 +10,6 @@ export { compactHistory, maybeCompact, capToolResultForHistory, truncateMid, con
 // 只执行可落地的 warn / 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';
 export { appendCurrentSessionTrace, appendCurrentSessionTraceEvent, appendCurrentSessionRuntimeEvent, createTraceEvent, } from './trace.js';
 export { reduceTraceMetrics, readTraceEvents, readTraceMetrics } from './trace-metrics.js';