c0de-agent 1.0.0 → 1.2.0

package/dist/server/routes/session.js

@@ -1,9 +1,13 @@
 import { Hono } from 'hono';
 import { createSummarizer, runCompaction } from '../../core/compact.js';
 import { fromDirectory } from '../../project/index.js';
+import { archiveOriginalEntries } from '../../session/archive.js';
 import { forkSession, getBranches, getTree } from '../../session/branch.js';
-import { getMessages } from '../../session/message.js';
+import { deleteEntriesByIds, getMessages, insertEntry } from '../../session/message.js';
 import { createSession, deleteSession, getLLMSegments, getSession, listSessions, listSessionsByProject, } from '../../session/session.js';
+import { applyShakeRegions, collectShakeRegions, DEFAULT_SHAKE_CONFIG, toRegionViews, } from '../../session/shake.js';
+import { estimateMessageTokens } from '../../session/token.js';
+import { generateId } from '../../shared/index.js';
 import { apiError } from '../middleware/error.js';
 function createSessionRoute(ctx) {
     const app = new Hono();
@@ -120,6 +124,76 @@ function createSessionRoute(ctx) {
         }
         return c.json({ _tag: 'idle' });
     });
+    // shake preview：返回可 shake 的区域列表
+    app.post('/:id/shake/preview', async (c) => {
+        const id = c.req.param('id');
+        let session;
+        try {
+            session = await getSession(ctx.db, id);
+        }
+        catch {
+            return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        }
+        if (!session)
+            return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        const messages = await getMessages(ctx.db, id);
+        // Manual shake: show ALL candidates (protectTokens=0, minSavings=0).
+        // toRegionViews still marks isAfterProtectWindow using the real config.
+        const manualConfig = { ...DEFAULT_SHAKE_CONFIG, protectTokens: 0, minSavings: 0 };
+        const regions = collectShakeRegions(messages, manualConfig);
+        const views = toRegionViews(regions, DEFAULT_SHAKE_CONFIG, messages);
+        return c.json({ regions: views });
+    });
+    // shake apply：归档原始内容 + 原位替换
+    app.post('/:id/shake/apply', async (c) => {
+        const id = c.req.param('id');
+        let session;
+        try {
+            session = await getSession(ctx.db, id);
+        }
+        catch {
+            return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        }
+        if (!session)
+            return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        const body = await c.req.json().catch(() => ({}));
+        const regionIds = body.regionIds ?? [];
+        const messages = await getMessages(ctx.db, id);
+        const manualConfig = { ...DEFAULT_SHAKE_CONFIG, protectTokens: 0, minSavings: 0 };
+        const regions = collectShakeRegions(messages, manualConfig);
+        // 校验：所有 regionIds 必须命中当前 preview 结果（原子性）
+        const availableIds = new Set(regions.map((r) => r.id));
+        const unknownIds = regionIds.filter((rid) => !availableIds.has(rid));
+        if (unknownIds.length > 0) {
+            return apiError(c, 400, 'INVALID_REGIONS', '消息已变化，请重新预览');
+        }
+        const selectedSet = new Set(regionIds);
+        const selected = regions.filter((r) => selectedSet.has(r.id));
+        if (selected.length === 0) {
+            return c.json({ shaken: 0, archiveId: '' });
+        }
+        const affectedIds = [...new Set(selected.map((r) => r.messageId))];
+        const originalMessages = messages.filter((m) => affectedIds.includes(m.id));
+        const archiveId = generateId();
+        const totalTokens = selected.reduce((sum, r) => sum + r.tokens, 0);
+        await archiveOriginalEntries(ctx.db, id, originalMessages, 'shake', `Shaken ${selected.length} regions, saved ${totalTokens} tokens`, archiveId);
+        const shakenMessages = applyShakeRegions(messages, selected);
+        await deleteEntriesByIds(ctx.db, affectedIds);
+        for (const msg of shakenMessages) {
+            if (!affectedIds.includes(msg.id))
+                continue;
+            await insertEntry(ctx.db, {
+                id: msg.id,
+                sessionId: id,
+                tag: 'message',
+                role: msg.role,
+                content: msg.content,
+                tokenCount: estimateMessageTokens(msg.content),
+                createdAt: new Date(msg.createdAt),
+            });
+        }
+        return c.json({ shaken: selected.length, archiveId });
+    });
     // 获取分支
     app.get('/:id/branches', async (c) => {
         const branches = await getBranches(ctx.db, c.req.param('id'));

package/dist/server/routes/terminal.d.ts

@@ -0,0 +1,5 @@
+import { Hono } from 'hono';
+import type { ServerContext } from '../types.js';
+/** 创建终端路由（REST 部分；WebSocket 升级在 server.ts 中处理）。 */
+declare function createTerminalRoute(ctx: ServerContext): Hono;
+export { createTerminalRoute };

package/dist/server/routes/terminal.js

@@ -0,0 +1,66 @@
+// src/server/routes/terminal.ts
+import { Hono } from 'hono';
+import { apiError } from '../middleware/error.js';
+/** 创建终端路由（REST 部分；WebSocket 升级在 server.ts 中处理）。 */
+function createTerminalRoute(ctx) {
+    const app = new Hono();
+    const mgr = ctx.ptyManager;
+    // 列出所有活跃 PTY
+    app.get('/', (c) => {
+        return c.json({ terminals: mgr.list() });
+    });
+    // 创建新 PTY 会话
+    app.post('/', async (c) => {
+        const body = await c.req.json().catch(() => ({}));
+        const cwd = typeof body.cwd === 'string' && body.cwd.length > 0 ? body.cwd : ctx.cwd;
+        const cols = Number.isFinite(body.cols) ? Number(body.cols) : undefined;
+        const rows = Number.isFinite(body.rows) ? Number(body.rows) : undefined;
+        const title = typeof body.title === 'string' ? body.title : undefined;
+        const shell = typeof body.shell === 'string' && body.shell.length > 0 ? body.shell : undefined;
+        try {
+            const info = mgr.create({ cwd, cols, rows, title, shell });
+            return c.json(info, 201);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'Failed to create terminal';
+            return apiError(c, 500, 'PTY_CREATE_FAILED', message);
+        }
+    });
+    // 获取单个 PTY 信息
+    app.get('/:id', (c) => {
+        const info = mgr.get(c.req.param('id'));
+        if (!info)
+            return apiError(c, 404, 'PTY_NOT_FOUND', 'Terminal not found');
+        return c.json(info);
+    });
+    // 调整尺寸 / 更新标题
+    app.put('/:id', async (c) => {
+        const id = c.req.param('id');
+        const info = mgr.get(id);
+        if (!info)
+            return apiError(c, 404, 'PTY_NOT_FOUND', 'Terminal not found');
+        const body = await c.req.json().catch(() => ({}));
+        if (body.cols != null && body.rows != null) {
+            const cols = Number(body.cols);
+            const rows = Number(body.rows);
+            if (!Number.isFinite(cols) || !Number.isFinite(rows)) {
+                return apiError(c, 400, 'INVALID_SIZE', 'cols and rows must be numbers');
+            }
+            mgr.resize(id, cols, rows);
+        }
+        if (typeof body.title === 'string') {
+            mgr.setTitle(id, body.title);
+        }
+        return c.json(mgr.get(id));
+    });
+    // 终止 PTY
+    app.delete('/:id', (c) => {
+        const id = c.req.param('id');
+        if (!mgr.get(id))
+            return apiError(c, 404, 'PTY_NOT_FOUND', 'Terminal not found');
+        mgr.kill(id);
+        return c.json({ ok: true });
+    });
+    return app;
+}
+export { createTerminalRoute };

package/dist/server/server.d.ts

@@ -36,8 +36,21 @@ declare function buildRegistryFromConfig(config: Config): Registry;
  * 使运行中的 ServerContext 立即生效，无需重启。
  */
 declare function syncRegistryFromConfig(registry: Registry, config: Config): void;
+/**
+ * 围绕已有 DB handle 组装 ServerContext（不建/不关闭 DB）。
+ *
+ * dev 热重载重建复用此函数：PGLite 单写者约束下 DB handle 必须跨重载存活，
+ * 但 ctx 其余资源（agentManager/permissionStore/registries/plugins）全部重建为新实例。
+ * 返回的 dispose 清理 ctx 资源但**不 close db**——db 由调用方持有。
+ */
+declare function buildServerContext(db: DB, opts?: StartServerOptions): Promise<{
+    ctx: ServerContext;
+    dispose: () => Promise<void>;
+}>;
+/** dev 专用：创建 + migrate PGLite，跨热重载复用（单写者，只建一次）。 */
+declare function createDevDb(cwd: string): Promise<DB>;
 /** 初始化 DB + 配置 + 注册表，返回 ServerContext + 清理函数（dev 与独立后端共用）。 */
 declare function bootstrapServerContext(opts?: StartServerOptions): Promise<BootstrappedServer>;
 declare function startServer(opts?: StartServerOptions): Promise<RunningServer>;
 export type { BootstrappedServer, RunningServer, StartServerOptions };
-export { bootstrapServerContext, buildRegistryFromConfig, startServer, syncRegistryFromConfig };
+export { bootstrapServerContext, buildRegistryFromConfig, buildServerContext, createDevDb, startServer, syncRegistryFromConfig, };

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.
  *