c0de-agent 1.0.0 → 1.1.0

package/dist/server/server.js

@@ -3,6 +3,7 @@ import { existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { connect as tcpConnect } from 'node:net';
 import { join } from 'node:path';
 import { serve } from '@hono/node-server';
+import { WebSocketServer } from 'ws';
 import { BUILTIN_AGENTS, createAgentRegistry } from '../core/agents/index.js';
 import { loadConfig } from '../core/config.js';
 import { decryptSecret } from '../core/secret.js';
@@ -12,6 +13,7 @@ import { initPlugins } from '../plugins/index.js';
 import { createDefaultRegistry, createDefaultURLRegistry } from '../tools/index.js';
 import { checkForUpdate, createHandoffServer, createUpdateScheduler, requestHandoff, restoreSessions, } from '../update/index.js';
 import { createAgentManager } from './agent-manager.js';
+import { PTYManager } from './terminal/pty-manager.js';
 import { createApp } from './app.js';
 import { createPermissionStore } from './permission/store.js';
 /** 把 config.providers 注册到新建的 LLM registry（修复此前空 registry 的遗漏）。 */
@@ -54,33 +56,15 @@ function resolveDbDir(cwd) {
         return envDir;
     return join(cwd, '.c0de', 'pglite');
 }
-/** 初始化 DB + 配置 + 注册表，返回 ServerContext + 清理函数（dev 与独立后端共用）。 */
-async function bootstrapServerContext(opts = {}) {
+/**
+ * 围绕已有 DB handle 组装 ServerContext（不建/不关闭 DB）。
+ *
+ * dev 热重载重建复用此函数：PGLite 单写者约束下 DB handle 必须跨重载存活，
+ * 但 ctx 其余资源（agentManager/permissionStore/registries/plugins）全部重建为新实例。
+ * 返回的 dispose 清理 ctx 资源但**不 close db**——db 由调用方持有。
+ */
+async function buildServerContext(db, opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
-    const ownsDb = !opts.db;
-    // 持久化 PGLite 数据：默认 <cwd>/.c0de/pglite（与 .c0de/cache、.c0de/config.json 同约定），
-    // 可用 C0DE_DB_DIR 覆盖。此前默认 in-memory，进程重启即丢全部会话/消息/调用详情。
-    // 测试注入 opts.db 时跳过（保持 in-memory 隔离）。
-    let db;
-    if (opts.db) {
-        db = opts.db;
-    }
-    else {
-        const dataDir = resolveDbDir(cwd);
-        if (!existsSync(dataDir))
-            mkdirSync(dataDir, { recursive: true });
-        db = await createDB({ driver: 'pglite', dataDir });
-    }
-    // migrateDB 失败时必须 close db，否则 PGLite WASM 实例泄漏并锁住 dataDir，
-    // 导致后续重试全部 abort（RuntimeError: Aborted()）。
-    try {
-        await migrateDB(db);
-    }
-    catch (err) {
-        if (ownsDb)
-            await db.close().catch(() => { });
-        throw err;
-    }
     if (opts.restoreFrom) {
         const snapshot = JSON.parse(readFileSync(opts.restoreFrom, 'utf8'));
         await restoreSessions(db, snapshot);
@@ -120,6 +104,7 @@ async function bootstrapServerContext(opts = {}) {
             initialDelayMs: config.update.initialDelayMs,
         }),
         cwd,
+        ptyManager: new PTYManager(),
     };
     // spec §18.3 handoff server：旧实例监听随机端口，收到 POST /handoff 时
     // 序列化当前会话状态 + 优雅关闭，让新实例接管。config.update.enabled=false
@@ -136,10 +121,63 @@ async function bootstrapServerContext(opts = {}) {
     }
     return {
         ctx,
-        close: async () => {
+        dispose: async () => {
+            // dev 重建前调用：中止活跃 run + settle pending permission +
+            // 停 scheduler + 关 handoff。**不 close db**（调用方持有）。
+            ctx.agentManager.dispose();
+            ctx.permissionStore.dispose();
             ctx.updateScheduler.stop();
+            ctx.ptyManager.dispose();
             if (handoffServer)
                 await handoffServer.close();
+        },
+    };
+}
+/** dev 专用：创建 + migrate PGLite，跨热重载复用（单写者，只建一次）。 */
+async function createDevDb(cwd) {
+    const dataDir = resolveDbDir(cwd);
+    if (!existsSync(dataDir))
+        mkdirSync(dataDir, { recursive: true });
+    const db = await createDB({ driver: 'pglite', dataDir });
+    // migrateDB 失败必须 close，否则 WASM 实例泄漏锁住 dataDir。
+    try {
+        await migrateDB(db);
+    }
+    catch (err) {
+        await db.close().catch(() => { });
+        throw err;
+    }
+    return db;
+}
+/** 初始化 DB + 配置 + 注册表，返回 ServerContext + 清理函数（dev 与独立后端共用）。 */
+async function bootstrapServerContext(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const ownsDb = !opts.db;
+    // 持久化 PGLite 数据：默认 <cwd>/.c0de/pglite（与 .c0de/cache、.c0de/config.json 同约定），
+    // 可用 C0DE_DB_DIR 覆盖。此前默认 in-memory，进程重启即丢全部会话/消息/调用详情。
+    // 测试注入 opts.db 时跳过（保持 in-memory 隔离）。
+    let db;
+    if (opts.db) {
+        db = opts.db;
+        // 注入 db 仍需 migrate（测试可能注入全新 in-memory db）。
+        // migrateDB 失败时若 ownsDb 才 close（注入的由调用方管）。
+        try {
+            await migrateDB(db);
+        }
+        catch (err) {
+            if (ownsDb)
+                await db.close().catch(() => { });
+            throw err;
+        }
+    }
+    else {
+        db = await createDevDb(cwd);
+    }
+    const { ctx, dispose } = await buildServerContext(db, opts);
+    return {
+        ctx,
+        close: async () => {
+            await dispose();
             if (ownsDb)
                 await db.close();
         },
@@ -184,14 +222,48 @@ async function startServer(opts = {}) {
     if (ctx.config.update.enabled)
         ctx.updateScheduler.start();
     const server = serve({ fetch: app.fetch, port });
+    // WebSocket：终端双向流。Hono v2 无原生 WS，用 ws 包直接挂载到 HTTP server。
+    // 匹配 /api/terminal/:id/ws → ptyManager.attachWebSocket
+    const wss = new WebSocketServer({ noServer: true });
+    const expectedToken = ctx.config.security.authEnabled ? ctx.config.security.token : undefined;
+    server.on('upgrade', (req, socket, head) => {
+        const url = new URL(req.url ?? '', `http://${req.headers.host ?? 'localhost'}`);
+        const match = url.pathname.match(/^\/api\/terminal\/([^/]+)\/ws$/);
+        if (!match) {
+            socket.destroy();
+            return;
+        }
+        // 认证：token 通过 query 参数传递（浏览器 WS 无法设置 Authorization header）
+        if (expectedToken) {
+            const token = url.searchParams.get('token');
+            if (token !== expectedToken) {
+                socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+                socket.destroy();
+                return;
+            }
+        }
+        const ptyId = match[1];
+        if (!ptyId) {
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            const attached = ctx.ptyManager.attachWebSocket(ptyId, ws);
+            if (!attached) {
+                ws.send(JSON.stringify({ type: 'error', message: 'Terminal not found' }));
+                ws.close(1008, 'Terminal not found');
+            }
+        });
+    });
     let closed = false;
     const close = async () => {
         if (closed)
             return;
         closed = true;
+        wss.close();
         server.close();
         await closeCtx();
     };
     return { app, port, close };
 }
-export { bootstrapServerContext, buildRegistryFromConfig, startServer, syncRegistryFromConfig };
+export { bootstrapServerContext, buildRegistryFromConfig, buildServerContext, createDevDb, startServer, syncRegistryFromConfig, };

package/dist/server/terminal/pty-manager.d.ts

@@ -0,0 +1,53 @@
+import type { WebSocket } from 'ws';
+/** PTY 会话信息（返回给前端）。 */
+export interface PTYInfo {
+    id: string;
+    pid: number;
+    title: string;
+    cols: number;
+    rows: number;
+    cwd: string;
+    /** shell 程序路径。 */
+    shell: string;
+}
+export interface CreatePTYOptions {
+    cwd: string;
+    cols?: number;
+    rows?: number;
+    title?: string;
+    /** 覆盖默认 shell；不传则自动检测。 */
+    shell?: string;
+}
+/**
+ * PTY 生命周期管理器。
+ *
+ * 负责 spawn / write / resize / kill 伪终端进程，并将 PTY 输出
+ * 通过 WebSocket 推送到前端。一个 PTY 可同时挂多个 WebSocket
+ * （多标签共享同一终端），任一 WS 断开不影响进程。
+ */
+export declare class PTYManager {
+    private entries;
+    /** 创建新 PTY 会话。 */
+    create(opts: CreatePTYOptions): PTYInfo;
+    /** 向 PTY stdin 写入数据。 */
+    write(id: string, data: string): void;
+    /** 调整 PTY 尺寸。 */
+    resize(id: string, cols: number, rows: number): void;
+    /** 更新 PTY 标题。 */
+    setTitle(id: string, title: string): void;
+    /** 终止 PTY 进程。 */
+    kill(id: string): void;
+    /** 获取 PTY 信息。 */
+    get(id: string): PTYInfo | undefined;
+    /** 列出所有活跃 PTY。 */
+    list(): PTYInfo[];
+    /**
+     * 将 WebSocket 挂载到 PTY，建立双向数据流：
+     * - PTY onData → WS send（终端输出）
+     * - WS onMessage → PTY write（用户输入）
+     * - WS onClose → 摘除连接（PTY 保持存活）
+     */
+    attachWebSocket(id: string, ws: WebSocket): boolean;
+    /** 终止所有 PTY 进程（服务器关闭时调用）。 */
+    dispose(): void;
+}

package/dist/server/terminal/pty-manager.js

@@ -0,0 +1,160 @@
+// src/server/terminal/pty-manager.ts
+import { spawn } from 'node-pty';
+import { randomUUID } from 'node:crypto';
+/** 检测当前平台默认 shell。 */
+function detectShell() {
+    if (process.platform === 'win32') {
+        return process.env.COMSPEC ?? 'cmd.exe';
+    }
+    return process.env.SHELL ?? '/bin/bash';
+}
+const DEFAULT_COLS = 80;
+const DEFAULT_ROWS = 24;
+const MAX_TITLE_LEN = 100;
+function truncateTitle(title) {
+    const clean = title.replace(/[\r\n]/g, ' ').trim();
+    return clean.length > MAX_TITLE_LEN ? `${clean.slice(0, MAX_TITLE_LEN)}…` : clean;
+}
+/**
+ * PTY 生命周期管理器。
+ *
+ * 负责 spawn / write / resize / kill 伪终端进程，并将 PTY 输出
+ * 通过 WebSocket 推送到前端。一个 PTY 可同时挂多个 WebSocket
+ * （多标签共享同一终端），任一 WS 断开不影响进程。
+ */
+export class PTYManager {
+    entries = new Map();
+    /** 创建新 PTY 会话。 */
+    create(opts) {
+        const id = `pty_${randomUUID()}`;
+        const cols = opts.cols ?? DEFAULT_COLS;
+        const rows = opts.rows ?? DEFAULT_ROWS;
+        const shell = opts.shell ?? detectShell();
+        const pty = spawn(shell, [], {
+            name: 'xterm-256color',
+            cols,
+            rows,
+            cwd: opts.cwd,
+            env: {
+                ...process.env,
+                TERM: 'xterm-256color',
+                COLORTERM: 'truecolor',
+            },
+        });
+        const info = {
+            id,
+            pid: pty.pid,
+            title: truncateTitle(opts.title ?? shell),
+            cols,
+            rows,
+            cwd: opts.cwd,
+            shell,
+        };
+        const entry = { pty, info, sockets: new Set() };
+        // PTY 输出 → 广播到所有挂载的 WebSocket
+        pty.onData((data) => {
+            for (const ws of entry.sockets) {
+                if (ws.readyState === ws.OPEN) {
+                    ws.send(data);
+                }
+            }
+        });
+        // PTY 退出 → 通知所有 WS 并清理
+        pty.onExit(({ exitCode }) => {
+            for (const ws of entry.sockets) {
+                if (ws.readyState === ws.OPEN) {
+                    ws.send(JSON.stringify({ type: 'exit', exitCode }));
+                    ws.close(1000, 'pty exited');
+                }
+            }
+            this.entries.delete(id);
+        });
+        this.entries.set(id, entry);
+        return info;
+    }
+    /** 向 PTY stdin 写入数据。 */
+    write(id, data) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            throw new Error(`PTY not found: ${id}`);
+        entry.pty.write(data);
+    }
+    /** 调整 PTY 尺寸。 */
+    resize(id, cols, rows) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            throw new Error(`PTY not found: ${id}`);
+        entry.pty.resize(Math.max(1, cols), Math.max(1, rows));
+        entry.info.cols = cols;
+        entry.info.rows = rows;
+    }
+    /** 更新 PTY 标题。 */
+    setTitle(id, title) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            throw new Error(`PTY not found: ${id}`);
+        entry.info.title = truncateTitle(title);
+    }
+    /** 终止 PTY 进程。 */
+    kill(id) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            return;
+        // 通知所有 WS
+        for (const ws of entry.sockets) {
+            if (ws.readyState === ws.OPEN) {
+                ws.send(JSON.stringify({ type: 'exit', exitCode: 0 }));
+                ws.close(1000, 'pty killed');
+            }
+        }
+        try {
+            entry.pty.kill();
+        }
+        catch {
+            // 进程可能已退出
+        }
+        this.entries.delete(id);
+    }
+    /** 获取 PTY 信息。 */
+    get(id) {
+        return this.entries.get(id)?.info;
+    }
+    /** 列出所有活跃 PTY。 */
+    list() {
+        return [...this.entries.values()].map((e) => ({ ...e.info }));
+    }
+    /**
+     * 将 WebSocket 挂载到 PTY，建立双向数据流：
+     * - PTY onData → WS send（终端输出）
+     * - WS onMessage → PTY write（用户输入）
+     * - WS onClose → 摘除连接（PTY 保持存活）
+     */
+    attachWebSocket(id, ws) {
+        const entry = this.entries.get(id);
+        if (!entry)
+            return false;
+        entry.sockets.add(ws);
+        ws.on('message', (data) => {
+            const text = typeof data === 'string' ? data : data.toString('utf8');
+            try {
+                entry.pty.write(text);
+            }
+            catch {
+                // PTY 可能已退出
+            }
+        });
+        ws.on('close', () => {
+            entry.sockets.delete(ws);
+        });
+        ws.on('error', () => {
+            entry.sockets.delete(ws);
+        });
+        return true;
+    }
+    /** 终止所有 PTY 进程（服务器关闭时调用）。 */
+    dispose() {
+        for (const id of this.entries.keys()) {
+            this.kill(id);
+        }
+    }
+}

package/dist/server/types.d.ts

@@ -8,6 +8,7 @@ import type { Config as SharedConfig } from '../shared/types/config.js';
 import type { URLRegistry } from '../shared/types/tool.js';
 import type { ToolRegistry } from '../tools/types.js';
 import type { HandoffServer, UpdateScheduler } from '../update/index.js';
+import type { PTYManager } from './terminal/pty-manager.js';
 import type { AgentManager } from './agent-manager.js';
 import type { PermissionStore } from './permission/store.js';
 /** 持有所有服务依赖的不可变上下文（config 字段可变用于 PATCH 更新）。 */
@@ -37,6 +38,8 @@ type ServerContext = {
         server: HandoffServer;
     };
     cwd: string;
+    /** 终端 PTY 管理器（Web 终端面板用）。 */
+    ptyManager: PTYManager;
     /** 测试注入：覆盖 LLM chat stream。生产环境为 undefined。 */
     chatStream?: typeof chatStreamFn;
 };

package/dist/session/archive.d.ts

@@ -1,7 +1,7 @@
 import type { DB } from '../db/client.js';
 import type { ArchiveRef, CompactionArchive, SessionEntry } from './types.js';
 /** Archive original entries before compaction/squash. Returns the archive id. */
-declare function archiveOriginalEntries(handle: DB, sessionId: string, entries: SessionEntry[], archiveType: 'compaction' | 'squash', summary: string, compactionId: string): Promise<string>;
+declare function archiveOriginalEntries(handle: DB, sessionId: string, entries: SessionEntry[], archiveType: 'compaction' | 'squash' | 'shake', summary: string, compactionId: string): Promise<string>;
 /** Get an archive by id. Returns null for invalid or non-existent ids. */
 declare function getArchive(handle: DB, id: string): Promise<CompactionArchive | null>;
 /** Get the original entries stored in an archive. */

package/dist/session/compaction.d.ts

@@ -9,8 +9,14 @@ import type { CompactionConfig, CompactionResult, HotFile, Summarizer } from './
 declare function findSafeCutPoint(messages: Message[], preferredCut: number): number;
 /** Extract frequently-accessed files (read ≥ 2 times) from message history. */
 declare function extractHotFiles(messages: Message[]): HotFile[];
-/** Build the LLM summarization prompt for a set of messages. */
-declare function buildCompactionPrompt(messages: Message[]): string;
+/**
+ * Build the LLM summarization prompt for a set of messages.
+ *
+ * 当存在 previousSummary（上一次压缩生成的摘要）时，prompt 头部改为增量更新指令，
+ * 引导模型在已有摘要上叠加新事实、剔除过时信息，从而避免连续多次压缩导致的
+ * 信息逐次丢失。无 previousSummary 时退回原始的从零压缩指令。
+ */
+declare function buildCompactionPrompt(messages: Message[], previousSummary?: string): string;
 /**
  * Compact a session: summarize old messages, archive them, keep recent ones.
  *

package/dist/session/compaction.js

@@ -1,6 +1,6 @@
 import { generateId } from '../shared/index.js';
 import { archiveOriginalEntries } from './archive.js';
-import { deleteEntriesByIds, getMessages, insertEntry } from './message.js';
+import { deleteEntriesByIds, getEntries, getMessages, insertEntry } from './message.js';
 import { upsertFileSnapshot } from './snapshot.js';
 import { estimateMessageTokens, estimateTokens } from './token.js';
 /**
@@ -51,30 +51,80 @@ function extractHotFiles(messages) {
     }
     return hot.sort((a, b) => b.accessCount - a.accessCount).slice(0, 10);
 }
-/** Build the LLM summarization prompt for a set of messages. */
-function buildCompactionPrompt(messages) {
+/** 工具输出在压缩 prompt 中保留的最大字符数（参考 opencode）。 */
+const TOOL_OUTPUT_MAX_CHARS = 2000;
+/** 截断超长字符串：head 60% + "[truncated]" + tail 40%，而非硬切。 */
+function truncateToolOutput(s) {
+    if (s.length <= TOOL_OUTPUT_MAX_CHARS)
+        return s;
+    const head = Math.floor(TOOL_OUTPUT_MAX_CHARS * 0.6);
+    const tail = TOOL_OUTPUT_MAX_CHARS - head;
+    return `${s.slice(0, head)}[truncated]${s.slice(-tail)}`;
+}
+/** 序列化单个 content part：text/thinking 保持原样，tool 输出超长时截断。 */
+function serializePart(p) {
+    if (p._tag === 'text' || p._tag === 'thinking')
+        return p.text;
+    if (p._tag === 'tool_call') {
+        const input = truncateToolOutput(JSON.stringify(p.input));
+        return JSON.stringify({ _tag: p._tag, id: p.id, tool: p.tool, input });
+    }
+    if (p._tag === 'tool_result') {
+        const output = truncateToolOutput(JSON.stringify(p.output));
+        return JSON.stringify({ _tag: p._tag, id: p.id, tool: p.tool, output });
+    }
+    return JSON.stringify(p);
+}
+/**
+ * Build the LLM summarization prompt for a set of messages.
+ *
+ * 当存在 previousSummary（上一次压缩生成的摘要）时，prompt 头部改为增量更新指令，
+ * 引导模型在已有摘要上叠加新事实、剔除过时信息，从而避免连续多次压缩导致的
+ * 信息逐次丢失。无 previousSummary 时退回原始的从零压缩指令。
+ */
+function buildCompactionPrompt(messages, previousSummary) {
     const history = messages
-        .map((m) => `[${m.role}] ${m.content.map((p) => (p._tag === 'text' ? p.text : JSON.stringify(p))).join(' ')}`)
+        .map((m) => `[${m.role}] ${m.content.map((p) => serializePart(p)).join(' ')}`)
         .join('\n');
-    return `将以下对话历史压缩为结构化摘要。保留关键信息，丢弃冗余细节。
+    const sections = `## Agenda
+逐条列出对话中出现的议题/任务，按处理顺序排列。每条格式：
+- **[议题标题]** — ✅已解决 / ⏳进行中 / 🔒阻塞 / 📋待办
+  - ✅/🔒 → 一行：最终结论或卡点
+  - ⏳/📋 → 完整保留：目标、约束、已尝试方向、相关文件路径、关键决策、待确认问题
 
 ## Goal
-用户的目标是什么
+用户此次会话的总体目标（若 Agenda 已涵盖，写"见 Agenda"）
 
-## Progress
-已完成的工作
+## Constraints & Preferences
+用户约束、偏好、规范要求（或"(none)"）
 
-## Decisions
-做出的关键决策
-
-## Next Steps
-接下来要做什么
+## Key Decisions
+做出的关键决策及原因
 
 ## Critical Context
-必须记住的上下文（文件路径、变量名、错误信息等）
+必须记住的技术事实（文件路径、变量名、命令、错误信息、未解决问题）
 
 ## Modified Files
-修改过的文件列表及变更摘要
+修改过的文件路径及变更摘要
+
+## Relevant Files
+对任务重要的文件/目录路径及原因`;
+    const header = previousSummary
+        ? `更新以下已有【议题驱动】摘要。重点：
+- 已解决的议题：状态更新为✅并压缩为一行结论；
+- 新增议题：补入 Agenda 并完整保留其描述与约束；
+- 尚未解决的议题：保持其原有描述与约束不变，只叠加本轮新进展。
+
+<previous-summary>
+${previousSummary}
+</previous-summary>`
+        : `将以下对话历史压缩为一份【议题驱动】的结构化摘要。
+核心原则——非对称保留：已解决的议题只留一行结论；尚未解决/待办的议题
+必须完整保留其描述、约束、已尝试方向、相关文件与待确认问题，它们是后续
+工作的蓝图，绝不可被稀释。`;
+    return `${header}
+
+${sections}
 
 ---
 对话历史：
@@ -115,6 +165,22 @@ function findKeepRecentStart(messages, keepRecentTokens) {
     // Always retain at least the most recent message.
     return Math.min(start, messages.length - 1);
 }
+/**
+ * 查找 session 最新的 compaction 摘要，用于增量摘要（P0-2）。
+ *
+ * 从全部 entries 中筛选 tag='compaction' 的记录，取最后一条（时间序最晚）的
+ * summary。无历史摘要时返回 undefined，buildCompactionPrompt 据此退回从零压缩模式。
+ */
+async function findPreviousSummary(handle, sessionId) {
+    const entries = await getEntries(handle, sessionId);
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry && '_tag' in entry && entry._tag === 'compaction') {
+            return entry.summary;
+        }
+    }
+    return undefined;
+}
 /**
  * Compact a session: summarize old messages, archive them, keep recent ones.
  *
@@ -144,7 +210,10 @@ async function compactSession(handle, sessionId, summarizer, config) {
     if (compactMessages.length === 0) {
         return { compacted: false, reason: 'nothing_to_compact' };
     }
-    const prompt = buildCompactionPrompt(compactMessages);
+    // 查询当前 session 最新的 compaction 摘要，作为增量更新的基线（P0-2）。
+    // 这样连续多次压缩时，新摘要会基于已有摘要叠加而非从零重建，避免早期信息逐次丢失。
+    const previousSummary = await findPreviousSummary(handle, sessionId);
+    const prompt = buildCompactionPrompt(compactMessages, previousSummary);
     // Run the (slow, network) summarizer OUTSIDE the transaction so we don't
     // hold a DB transaction open across an LLM call.
     const summary = await summarizer(prompt);

package/dist/session/shake.d.ts

@@ -0,0 +1,66 @@
+import type { Message } from '../shared/types/message.js';
+export interface ShakeConfig {
+    /** 保护最近 N token 的上下文不被 shake。 */
+    protectTokens: number;
+    /** 总节省 token < minSavings 时不 shake（preview 路径用）。 */
+    minSavings: number;
+    /** fenced/XML block 的最小 token 阈值。 */
+    fenceMinTokens: number;
+    /** 受保护的工具名列表（其 tool_result 不被 shake）。 */
+    protectedTools: string[];
+}
+/** Auto-shake 默认配置：保护活跃尾部，保守阈值。 */
+export declare const DEFAULT_SHAKE_CONFIG: ShakeConfig;
+export type ShakeRegion = {
+    kind: 'toolResult';
+    id: string;
+    messageId: string;
+    messageIndex: number;
+    partIndex: number;
+    tokens: number;
+    originalText: string;
+    label: string;
+    /** tool_call_id（tool_result part.id），前端用于跨消息合并后匹配渲染块。 */
+    toolCallId: string;
+} | {
+    kind: 'block';
+    id: string;
+    messageId: string;
+    messageIndex: number;
+    partIndex: number;
+    start: number;
+    end: number;
+    tokens: number;
+    originalText: string;
+    label: string;
+};
+/** API 返回给前端的区域视图。 */
+export type ShakeRegionView = {
+    id: string;
+    kind: 'toolResult' | 'block';
+    messageId: string;
+    messageIndex: number;
+    partIndex: number;
+    tokens: number;
+    label: string;
+    preview: string;
+    placeholder: string;
+    isAfterProtectWindow: boolean;
+    /** tool_result 的 tool_call_id（仅 toolResult 类别），前端跨消息合并后匹配渲染块。 */
+    toolCallId?: string;
+};
+/**
+ * 定位 fenced 代码块和顶层 XML 元素 span。返回字符偏移 [start, end) 数组，
+ * 覆盖完整块（含围栏/标签行，不含尾换行）。围栏内抑制 XML 检测。
+ * 未闭合围栏/标签不产生 range（保守策略）。
+ */
+export declare function scanTextForBlockRanges(text: string): Array<{
+    start: number;
+    end: number;
+}>;
+/** 收集可 shake 的区域。纯函数，不修改输入。 */
+export declare function collectShakeRegions(messages: Message[], config: ShakeConfig): ShakeRegion[];
+/** 原位替换选中区域。返回新数组，不修改原数组。 */
+export declare function applyShakeRegions(messages: Message[], regions: ShakeRegion[]): Message[];
+/** 区域转 API 视图。protectWindow 窗口内的标记 isAfterProtectWindow=false。 */
+export declare function toRegionViews(regions: ShakeRegion[], config: ShakeConfig, messages: Message[]): ShakeRegionView[];