c0de-agent 1.0.0 → 1.1.0

package/dist/core/slash.js

@@ -40,10 +40,9 @@ const compactCommand = {
     name: 'compact',
     description: 'Manually trigger context compaction',
     execute: async () => {
-        return {
-            _tag: 'success',
-            message: 'Compaction queued. Use the agent API to trigger with a summarizer.',
-        };
+        // 仅声明意图：真正的压缩由消费方（loop.compactContext / chat 路由）执行，
+        // 复用 createSummarizer + runCompaction，且不把 /compact 当作 user 消息发给 LLM。
+        return { _tag: 'compact' };
     },
 };
 const modelCommand = {

package/dist/core/title.js

@@ -108,8 +108,9 @@ async function generateSessionTitle(deps, sessionId, firstMessage, chatProvider,
             return;
         await updateSessionTitle(db, sessionId, title);
     }
-    catch {
-        // 标题生成是尽力而为的辅助功能：失败不阻塞主对话流。
+    catch (e) {
+        // 标题生成是尽力而为的辅助功能：失败不阻塞主对话流，但记录以便排查。
+        console.warn('[title] generateSessionTitle failed:', e instanceof Error ? e.message : String(e));
     }
 }
 export { DEFAULT_SESSION_TITLE, generateSessionTitle, isDefaultTitle };

package/dist/core/types.d.ts

@@ -80,6 +80,8 @@ type CommandResult = {
 } | {
     _tag: 'text';
     text: string;
+} | {
+    _tag: 'compact';
 };
 type CommandContext = {
     cwd: string;

package/dist/core/worktree.js

@@ -48,8 +48,9 @@ async function applyPatchToParent(repoRoot, patch, commitMessage) {
     try {
         gitWithInput(repoRoot, ['apply'], patch);
     }
-    catch {
-        // apply 失败：尝试 3-way 合并
+    catch (e) {
+        // apply 失败：记录后尝试 3-way 合并
+        console.warn('[worktree] git apply failed, retrying with --3way:', e instanceof Error ? e.message : String(e));
         gitWithInput(repoRoot, ['apply', '--3way'], patch);
     }
     git(repoRoot, ['add', '-A']);
@@ -61,8 +62,9 @@ function removeWorktree(repoRoot, worktreeDir) {
     try {
         git(repoRoot, ['worktree', 'remove', '--force', worktreeDir]);
     }
-    catch {
-        // 清理失败忽略（可能已删）
+    catch (e) {
+        // 清理失败忽略（可能已删），但记录以便排查残留 worktree
+        console.warn('[worktree] worktree cleanup failed:', e instanceof Error ? e.message : String(e));
     }
 }
 export { applyPatchToParent, captureBaseline, captureDeltaPatch, createWorktree, removeWorktree };

package/dist/dap/session.js

@@ -112,12 +112,12 @@ function createDebugSessionManager() {
             if (!s)
                 return;
             s.session.state = 'stopped';
-            // disconnect 适配器可能已退出；吞错。
+            // disconnect 适配器可能已退出；吞错但记录，便于排查非正常退出。
             try {
                 await s.client.request('disconnect', {});
             }
-            catch {
-                /* adapter gone */
+            catch (e) {
+                console.warn('[dap] disconnect failed:', e instanceof Error ? e.message : String(e));
             }
             s.client.dispose();
             sessions.delete(sessionId);

package/dist/llm/provider.js

@@ -93,7 +93,11 @@ const toStreamChunk = (event) => {
         case 'provider-error':
             return {
                 _tag: 'error',
-                error: { message: event.message, retryable: event.retryable ?? false },
+                error: {
+                    message: event.message,
+                    retryable: event.retryable ?? false,
+                    ...(event.classification !== undefined ? { classification: event.classification } : {}),
+                },
             };
         default:
             return null;

package/dist/plugins/loader.js

@@ -59,8 +59,9 @@ async function discoverPlugins(projectDir) {
             const plugin = await loadPlugin(join(entry.path, 'index.js'));
             results.push({ name: entry.name, path: entry.path, plugin });
         }
-        catch {
-            // Skip plugins that fail to load
+        catch (e) {
+            // Plugin failed to load — skip but warn (otherwise silently inactive)
+            console.warn(`[plugin] failed to load "${entry.name}" from ${entry.path}:`, e instanceof Error ? e.message : String(e));
         }
     }
     return results;

package/dist/server/agent-manager.d.ts

@@ -26,6 +26,8 @@ type AgentManager = {
     children(parentSessionId: string): ActiveRun[];
     /** 查询所有后台任务（jobId 非空的 run）。 */
     backgroundJobs(): ActiveRun[];
+    /** 中止所有活跃 run 并清空（dev 热重载重建前调用）。 */
+    dispose(): void;
 };
 declare function createAgentManager(): AgentManager;
 export type { ActiveRun, AgentManager };

package/dist/server/agent-manager.js

@@ -49,6 +49,14 @@ function createAgentManager() {
         backgroundJobs() {
             return Array.from(runs.values()).filter((r) => r.jobId !== undefined);
         },
+        dispose() {
+            // dev 热重载重建前调用：中止所有活跃 run（loop 在 turn/流边界检测 signal
+            // → unwind → 调用方 finally 持久化 + unregister），然后清空 Map。
+            for (const run of runs.values()) {
+                abortAgent(run.state);
+            }
+            runs.clear();
+        },
     };
 }
 export { createAgentManager };

package/dist/server/app.js

@@ -18,6 +18,7 @@ import { createPermissionsRoute } from './routes/permissions.js';
 import { createProjectRoute } from './routes/project.js';
 import { createProviderRoute } from './routes/provider.js';
 import { createSessionRoute } from './routes/session.js';
+import { createTerminalRoute } from './routes/terminal.js';
 import { createToolRoute } from './routes/tool.js';
 import { createUpdateRoute } from './routes/update.js';
 /** 创建完整的 Hono 应用，挂载所有路由 + 中间件。 */
@@ -44,6 +45,7 @@ function createApp(ctx) {
     app.route('/api/config', createConfigRoute(ctx));
     app.route('/api/permissions', createPermissionsRoute(ctx));
     app.route('/api/files', createFilesRoute(ctx));
+    app.route('/api/terminal', createTerminalRoute(ctx));
     // 根路径
     app.get('/', (c) => c.json({
         name: 'c0de-agent',
@@ -63,6 +65,7 @@ function createApp(ctx) {
             '/api/config',
             '/api/permissions',
             '/api/files',
+            '/api/terminal',
         ],
     }));
     // 静态文件服务（生产环境 dist-web/ 存在时启用）

package/dist/server/context.js

@@ -6,6 +6,7 @@ import { createDefaultRegistry, createDefaultURLRegistry } from '../tools/index.
 import { createUpdateScheduler } from '../update/index.js';
 import { createAgentManager } from './agent-manager.js';
 import { createPermissionStore } from './permission/store.js';
+import { PTYManager } from './terminal/pty-manager.js';
 function createServerContext(opts) {
     // 测试/dev 工厂：补足 urlRegistry + hookRunner + pluginRegistry（空壳，不激活插件），
     // 生产启动走 bootstrapServerContext → initPlugins（激活 builtin + 发现外部插件）。
@@ -41,6 +42,7 @@ function createServerContext(opts) {
             }),
         }),
         cwd: opts.cwd ?? process.cwd(),
+        ptyManager: new PTYManager(),
         ...(opts.chatStream ? { chatStream: opts.chatStream } : {}),
     };
 }

package/dist/server/dev.d.ts

@@ -1,6 +1,9 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Hono } from 'hono';
+import type { ServerContext } from './types.js';
 declare function getDevApp(): Promise<Hono>;
+/** 获取当前 dev ctx（WebSocket 升级等需要直接访问 ptyManager 的场景）。 */
+declare function getDevCtx(): Promise<ServerContext>;
 /** vite dev server 关闭时调用，确保 PGLite WASM 正常 close 并刷写 WAL。 */
 declare function closeDevApp(): Promise<void>;
 /**
@@ -8,4 +11,4 @@ declare function closeDevApp(): Promise<void>;
  * 用 Readable.fromWeb 管道转发 Response body，原生处理背压与分块。
  */
 declare function handleApiRequest(app: Hono, req: IncomingMessage, res: ServerResponse): Promise<void>;
-export { closeDevApp, getDevApp, handleApiRequest };
+export { closeDevApp, getDevApp, getDevCtx, handleApiRequest };

package/dist/server/dev.js

@@ -1,35 +1,92 @@
 // src/server/dev.ts
 import { Readable } from 'node:stream';
 import { createApp } from './app.js';
-import { bootstrapServerContext } from './server.js';
+import { buildServerContext, createDevDb } from './server.js';
 /**
  * 开发环境入口：初始化并返回 Hono app。
  * 供 vite dev server 中间件复用，使前后端共享同一端口。
  *
- * 用 globalThis 缓存而非模块级变量：Vite ssrLoadModule 在 server 端代码变更时会
- * 重新执行本模块，模块级 cachedApp 会重置；这会导致运行中的 AgentManager（含
- * 权限确认 pending）丢失，前端 POST /api/tools/confirm 拿不到 pending 而 404。
- * globalThis 跨模块重载保持单例，避免权限流程中途断裂。
+ * ## 全量重建（B 方案）
+ *
+ * 目标：编辑任意 server/core 代码后热重载，新代码对**新请求**全部生效——与进程重启同语义，
+ * 只是不开新进程。
+ *
+ * 缓存策略分两层：
+ *
+ * 1. **PGLite DB handle** → globalThis（唯一跨重载存活物）。
+ *    PGLite 是单写者 WASM DB，同一 dataDir 不能开第二个连接（WAL 冲突 / Aborted()），
+ *    所以 db 必须跨重载复用。其余一切重建。
+ *
+ * 2. **ctx + app** → 模块级变量。
+ *    Vite 重载本模块时归 null，下次请求触发 rebuild：
+ *      dispose 旧 ctx（abort 活跃 run + settle pending permission + stop scheduler + close handoff）
+ *      → 围绕复用的 db 调 buildServerContext（重建 agentManager/permissionStore/registries/plugins/app）
+ *      → 全部用最新代码。
+ *
+ * ## 与热升级的关系
+ *
+ * 和 `performHotUpdate` 是同一原理，差只在 spawn 新进程 vs 进程内重建。两者都：
+ *   - 保留 durable 状态（DB rows）
+ *   - 丢弃非 durable 状态（in-flight 工具执行、pending Promise resolver、活跃 run 内存态）
+ *   - 活跃 run 从最后持久化消息重启
+ *
+ * 活跃 run 被 abort 后，loop 在 turn/流边界检测 signal → unwind → 调用方 finally 持久化
+ * 状态（标记 interrupted/completed）。前端再发消息时从 DB 历史起新 run，全用新代码。
  */
-const DEV_APP_KEY = '__c0de_dev_app__';
-const DEV_CLOSE_KEY = '__c0de_dev_close__';
-async function getDevApp() {
+const DEV_DB_KEY = '__c0de_dev_db__';
+/** 模块级：随本模块重载而重置。 */
+let ctx = null;
+let app = null;
+let disposeCtx = null;
+async function rebuild() {
+    // 1. dispose 旧 ctx（不 close db）
+    if (disposeCtx) {
+        await disposeCtx();
+        disposeCtx = null;
+        ctx = null;
+        app = null;
+    }
+    // 2. 取/建 devDb（globalThis，PGLite 单写者，只建一次）
     const g = globalThis;
-    if (!g[DEV_APP_KEY]) {
-        const { ctx, close } = await bootstrapServerContext({ cwd: process.cwd() });
-        g[DEV_APP_KEY] = createApp(ctx);
-        g[DEV_CLOSE_KEY] = close;
+    if (!g[DEV_DB_KEY]) {
+        g[DEV_DB_KEY] = await createDevDb(process.cwd());
     }
-    return g[DEV_APP_KEY];
+    const db = g[DEV_DB_KEY];
+    // 3. 围绕复用的 db 重建 ctx（skipHandoff：dev 不跑热升级 handoff）
+    const built = await buildServerContext(db, { cwd: process.cwd(), skipHandoff: true });
+    ctx = built.ctx;
+    disposeCtx = built.dispose;
+    app = createApp(ctx);
+}
+async function getDevApp() {
+    if (app)
+        return app;
+    await rebuild();
+    if (!app)
+        throw new Error('dev app failed to initialize');
+    return app;
+}
+/** 获取当前 dev ctx（WebSocket 升级等需要直接访问 ptyManager 的场景）。 */
+async function getDevCtx() {
+    if (!ctx)
+        await getDevApp();
+    if (!ctx)
+        throw new Error('dev ctx not initialized');
+    return ctx;
 }
 /** vite dev server 关闭时调用，确保 PGLite WASM 正常 close 并刷写 WAL。 */
 async function closeDevApp() {
+    if (disposeCtx) {
+        await disposeCtx();
+        disposeCtx = null;
+        ctx = null;
+        app = null;
+    }
     const g = globalThis;
-    const close = g[DEV_CLOSE_KEY];
-    if (close) {
-        await close();
-        delete g[DEV_APP_KEY];
-        delete g[DEV_CLOSE_KEY];
+    const db = g[DEV_DB_KEY];
+    if (db) {
+        await db.close();
+        delete g[DEV_DB_KEY];
     }
 }
 /**
@@ -49,16 +106,20 @@ async function handleApiRequest(app, req, res) {
     }
     const headers = new Headers();
     for (const [key, value] of Object.entries(req.headers)) {
-        if (value != null) {
-            headers.set(key, Array.isArray(value) ? value.join(', ') : value);
+        if (typeof value === 'string') {
+            headers.set(key, value);
+        }
+        else if (Array.isArray(value)) {
+            for (const v of value)
+                headers.append(key, v);
         }
     }
     const init = {
         method: req.method,
         headers,
-        body: body ?? undefined,
     };
     if (body !== undefined) {
+        init.body = body;
         init.duplex = 'half';
     }
     const request = new Request(url.toString(), init);
@@ -69,15 +130,19 @@ async function handleApiRequest(app, req, res) {
     });
     const responseBody = response.body;
     if (responseBody) {
-        res.flushHeaders();
-        await new Promise((resolve, reject) => {
-            const nodeStream = Readable.fromWeb(responseBody);
-            nodeStream.on('error', reject);
-            nodeStream.pipe(res).on('finish', resolve);
+        // Readable.fromWeb 需要 web stream；Hono Response.body 已是 ReadableStream。
+        // native pipeline handles backpressure + chunked encoding for SSE.
+        Readable.fromWeb(responseBody)
+            .pipe(res)
+            .on('error', (err) => {
+            if (!res.headersSent)
+                res.statusCode = 500;
+            res.end();
+            console.error('[c0de-hono-api] response stream error:', err);
         });
     }
     else {
         res.end();
     }
 }
-export { closeDevApp, getDevApp, handleApiRequest };
+export { closeDevApp, getDevApp, getDevCtx, handleApiRequest };

package/dist/server/permission/store.d.ts

@@ -24,6 +24,8 @@ type PermissionStore = {
     resolve(toolCallId: string, approved: boolean): boolean;
     has(toolCallId: string): boolean;
     size(): number;
+    /** settle 所有 pending 为 deny 并清空（dev 热重载重建前调用）。 */
+    dispose(): void;
 };
 declare function createPermissionStore(opts?: PermissionStoreOptions): PermissionStore;
 export type { PendingPermission, PermissionRequest, PermissionStore, PermissionStoreOptions };

package/dist/server/permission/store.js

@@ -42,6 +42,15 @@ function createPermissionStore(opts = {}) {
         size() {
             return pending.size;
         },
+        dispose() {
+            // dev 热重载重建前调用：所有 pending settle 为 deny（避免悬空 Promise +
+            // timer 泄漏），clearTimeout 后清空 Map。
+            for (const [id, p] of pending) {
+                clearTimeout(p.timer);
+                p.resolve({ _tag: 'deny', reason: 'Server context disposed (hot reload)' });
+                pending.delete(id);
+            }
+        },
     };
 }
 export { createPermissionStore, DEFAULT_PERMISSION_TIMEOUT_MS };

package/dist/server/routes/chat.js

@@ -2,6 +2,7 @@ import { readFile } from 'node:fs/promises';
 import { Hono } from 'hono';
 import { streamSSE } from 'hono/streaming';
 import { createAgent, runAgent } from '../../core/agent.js';
+import { compactContext } from '../../core/loop.js';
 import { createSlashRegistry, parseSlashInput } from '../../core/slash.js';
 import { getProject } from '../../project/project.js';
 import { getLLMSegments, getSession, updateSessionLastRun } from '../../session/session.js';
@@ -63,7 +64,42 @@ function createChatRoute(ctx) {
                 return streamSSE(c, async (stream) => {
                     try {
                         const result = await cmd.execute(parsed.args, commandCtx);
-                        if (result._tag === 'error') {
+                        if (result._tag === 'compact') {
+                            // /compact：手动触发上下文压缩。复用 loop.compactContext（createSummarizer +
+                            // runCompaction），不创建主 agent、不进入 LLM turn 循环（不把 /compact 当作
+                            // user 消息发给模型）。
+                            const provider = body.provider ?? ctx.config.defaultProvider;
+                            const model = body.model ?? ctx.config.defaultModel;
+                            const agentConfig = {
+                                provider,
+                                model,
+                                tools: [],
+                                plugins: ctx.config.plugins.enabled,
+                                agentName: 'default',
+                            };
+                            const compactState = await createAgent(session, agentConfig, commandCtx.deps);
+                            try {
+                                for await (const event of compactContext(compactState, commandCtx.deps)) {
+                                    await stream.writeSSE({
+                                        event: event._tag,
+                                        data: JSON.stringify(event),
+                                    });
+                                }
+                            }
+                            catch (e) {
+                                await stream.writeSSE({
+                                    event: 'error',
+                                    data: JSON.stringify({
+                                        _tag: 'error',
+                                        error: {
+                                            _tag: 'unexpected',
+                                            message: e instanceof Error ? e.message : String(e),
+                                        },
+                                    }),
+                                });
+                            }
+                        }
+                        else if (result._tag === 'error') {
                             await stream.writeSSE({
                                 event: 'error',
                                 data: JSON.stringify({

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, };