c0de-agent 1.11.0 → 1.12.0

package/dist/server/routes/provider.js

@@ -1,6 +1,10 @@
 import { Hono } from 'hono';
+import { loadConfigScopes, mergeConfig } from '../../core/config.js';
 import { decryptSecret } from '../../core/secret.js';
+import { resolveRoute } from '../../llm/registry.js';
+import { getProject } from '../../project/project.js';
 import { apiError } from '../middleware/error.js';
+import { buildRegistryFromConfig } from '../registry-config.js';
 /**
  * 用给定 baseURL/apiKey 探测 OpenAI 兼容的 /models 端点。
  * baseURL 应自行包含版本路径（如 https://api.openai.com/v1）。
@@ -39,15 +43,56 @@ async function probeModels(baseURL, apiKey) {
 }
 function createProviderRoute(ctx) {
     const app = new Hono();
+    /** P1-1：解析目标项目配置与注册表（?projectId= 提供时按该项目合并配置）。
+     *  项目配置从磁盘实时读取（配置体量小）；注册表优先用会话聊天路径缓存的。 */
+    const resolveForProject = async (c) => {
+        const projectId = c.req.query('projectId');
+        if (!projectId)
+            return { config: ctx.config, registry: ctx.llmRegistry };
+        const project = await getProject(ctx.db, projectId);
+        if (!project)
+            return null;
+        const scopes = loadConfigScopes(project.worktree);
+        const config = mergeConfig(scopes.global, scopes.project);
+        const registry = config.providers.length > 0 ? buildRegistryFromConfig(config) : ctx.llmRegistry;
+        return { config, registry };
+    };
     // 列出已配置 providers（apiKey 脱敏，不含明文）
-    app.get('/', (c) => {
-        const providers = ctx.config.providers.map((p) => ({
+    app.get('/', async (c) => {
+        const resolved = await resolveForProject(c);
+        if (!resolved)
+            return apiError(c, 404, 'PROJECT_NOT_FOUND', '项目不存在');
+        const providers = resolved.config.providers.map((p) => ({
             name: p.name || p._tag || '',
             protocol: p.protocol,
             baseURL: p.baseURL ?? '',
             hasKey: !!p.apiKey,
         }));
-        return c.json({ providers, defaultProvider: ctx.config.defaultProvider });
+        return c.json({ providers, defaultProvider: resolved.config.defaultProvider });
+    });
+    // 模型能力查询：前端据此控制多模态入口（supportsVision）等
+    app.get('/capabilities', async (c) => {
+        const provider = c.req.query('provider');
+        const model = c.req.query('model');
+        if (!provider || !model) {
+            return apiError(c, 400, 'BAD_REQUEST', 'provider and model are required');
+        }
+        const project = await resolveForProject(c);
+        if (!project)
+            return apiError(c, 404, 'PROJECT_NOT_FOUND', '项目不存在');
+        try {
+            const route = resolveRoute(project.registry, provider, model);
+            return c.json({
+                provider,
+                model,
+                supportsVision: route.capabilities.supportsVision,
+                supportsThinking: route.capabilities.supportsThinking,
+                contextWindow: route.capabilities.contextWindow,
+            });
+        }
+        catch {
+            return apiError(c, 404, 'NOT_FOUND', 'provider/model not registered');
+        }
     });
     // 连接测试：用请求体里的凭据探测 /models，不污染 registry
     app.post('/test', async (c) => {

package/dist/server/routes/session.js

@@ -1,19 +1,77 @@
+import { existsSync } from 'node:fs';
+import { eq } from 'drizzle-orm';
 import { Hono } from 'hono';
 import { createSummarizer, runCompaction } from '../../core/compact.js';
+import { loadConfigScopes, mergeConfig } from '../../core/config.js';
+import { sessions } from '../../db/schema.js';
+import { buildFallbackChain } from '../../llm/routing.js';
 import { fromDirectory } from '../../project/index.js';
-import { archiveOriginalEntries } from '../../session/archive.js';
+import { getProject } from '../../project/project.js';
+import { archiveOriginalEntries, listArchives } from '../../session/archive.js';
 import { BranchPointOutOfRangeError, forkSession, getBranches, getTree, } from '../../session/branch.js';
-import { deleteEntriesByIds, getMessages, insertEntry } from '../../session/message.js';
-import { createSession, getLLMSegments, getSession, listDeletedSessions, listSessions, listSessionsByProject, restoreSession, softDeleteSession, touchLastOpened, } from '../../session/session.js';
+import { importSessionData } from '../../session/import.js';
+import { deleteEntriesByIds, getMessages, getSteeringAsMessages, insertEntry, } from '../../session/message.js';
+import { createSession, emptyTrash, getLLMSegments, getSession, listDeletedSessions, listOrphanDeletedSessions, listSessions, listSessionsByProject, permanentlyDeleteSession, rebindSession, restoreSessionCore, searchSessions, softDeleteSession, touchLastOpened, touchTrashSeen, updateSessionTitle, } 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';
+import { buildRegistryFromConfig } from '../registry-config.js';
+import { resolveAgentCwd } from './chat.js';
 function createSessionRoute(ctx) {
     const app = new Hono();
+    // 会话导入：GET /:id/export 的逆操作（数据备份/迁移闭环）。
+    // 消息/归档重新生成 id（保留内容与时间戳），同库复制、重复导入均安全。
+    // 绑定 projectId 后立即出现在对应项目视图。
+    // P1-2：projectId 必填——无归属会话在任何项目视图都不可见，导入即孤儿。
+    app.post('/import', async (c) => {
+        const body = (await c.req.json().catch(() => null));
+        if (body?.version !== 1 || !body?.session || !Array.isArray(body?.messages)) {
+            return apiError(c, 400, 'INVALID_EXPORT', '无效的会话导出 JSON：需要 version/session/messages 字段');
+        }
+        const projectId = typeof body.projectId === 'string' && body.projectId ? body.projectId : '';
+        if (!projectId) {
+            return apiError(c, 400, 'PROJECT_REQUIRED', '导入会话必须指定目标项目（projectId）');
+        }
+        const project = await getProject(ctx.db, projectId);
+        if (!project) {
+            return apiError(c, 404, 'PROJECT_NOT_FOUND', '目标项目不存在');
+        }
+        const title = typeof body.session.title === 'string' && body.session.title
+            ? body.session.title
+            : '导入的会话';
+        // P0：权限态仅当调用方显式确认（importPermissions=true）时随迁。
+        // 默认剥离——用户在导出会话中建立的授权信任不应跨机器静默生效。
+        const importPermissions = body.importPermissions === true;
+        const metadata = {};
+        if (importPermissions) {
+            const srcMeta = body.session.metadata;
+            if (srcMeta && typeof srcMeta === 'object' && !Array.isArray(srcMeta)) {
+                const m = srcMeta;
+                if (m.permissionMode === 'auto' || m.permissionMode === 'default') {
+                    metadata.permissionMode = m.permissionMode;
+                }
+                if (Array.isArray(m.alwaysAllow)) {
+                    metadata.alwaysAllow = m.alwaysAllow.filter((x) => typeof x === 'string');
+                }
+            }
+        }
+        // P2：导出含分支树结构（parentId），导入为独立根会话——告知前端提示扁平化。
+        const flattened = typeof body.session.parentId === 'string' && body.session.parentId.length > 0;
+        const result = await importSessionData(ctx.db, {
+            title,
+            projectId,
+            messages: body.messages,
+            archives: Array.isArray(body.archives)
+                ? body.archives
+                : [],
+            metadata,
+        });
+        return c.json({ ok: true, ...result, flattened, permissionsMigrated: importPermissions });
+    });
     // 创建会话
     app.post('/', async (c) => {
-        const body = await c.req.json().catch(() => ({}));
+        const body = (await c.req.json().catch(() => ({})));
         const title = body.title ?? 'New Session';
         const directory = body.directory;
         const explicitProjectId = body.projectId;
@@ -25,6 +83,11 @@ function createSessionRoute(ctx) {
         else if (explicitProjectId) {
             projectId = explicitProjectId;
         }
+        // P2 修复：projectId 必填——无归属 web 会话在任何项目视图都不可见，
+        // 且非删除孤儿无任何 UI 入口，API 直调会创建不可达会话。
+        if (!projectId) {
+            return apiError(c, 400, 'PROJECT_REQUIRED', '创建会话必须指定项目：传 directory（自动解析）或 projectId');
+        }
         const session = await createSession(ctx.db, title, projectId);
         return c.json(session, 201);
     });
@@ -41,17 +104,53 @@ function createSessionRoute(ctx) {
         const tree = await getTree(ctx.db);
         return c.json(tree);
     });
-    // 回收站：已软删除的会话列表（必须注册在 /:id 之前，避免被参数路由吞掉）
+    // 跨会话搜索（P2-6）：标题 + 消息内容匹配；?q= 关键词，?projectId= 限定项目。
+    // P3：?includeDeleted=1 搜索回收站（配合回收站搜索框）。
+    // 注册在 /:id 之前避免被参数路由吞掉。
+    app.get('/search', async (c) => {
+        const q = c.req.query('q') ?? '';
+        const projectId = c.req.query('projectId');
+        const includeDeleted = c.req.query('includeDeleted') === '1' || c.req.query('includeDeleted') === 'true';
+        if (!q.trim())
+            return c.json({ results: [] });
+        const results = await searchSessions(ctx.db, q, projectId, { includeDeleted });
+        return c.json({ results });
+    });
+    // 回收站：已软删除的会话列表（必须注册在 /:id 之前，避免被参数路由吞掉）。
+    // ?projectId= 过滤本项目（P1-7：回收站此前全库共享，跨项目可见可清空）。
+    // ?orphan=1 → 仅列出未归属项目的已删会话（删除项目后 FK set null 导致的孤儿，F1）。
+    // A3：孤儿列表查询不再自动标记「已看到」——标记改为用户展开分组时显式调用
+    // POST /deleted/orphans/seen，避免打开任意项目回收站连带启动无关孤儿倒计时。
     app.get('/deleted', async (c) => {
-        const sessions = await listDeletedSessions(ctx.db);
-        return c.json(sessions);
+        const projectId = c.req.query('projectId');
+        if (c.req.query('orphan') === '1') {
+            return c.json(await listOrphanDeletedSessions(ctx.db));
+        }
+        await touchTrashSeen(ctx.db, projectId ? { projectId } : {});
+        return c.json(await listDeletedSessions(ctx.db, projectId));
+    });
+    // A3：孤儿条目计数（不标记 seen；分组折叠时展示「N 条」用）。
+    app.get('/deleted/orphans/count', async (c) => {
+        const orphans = await listOrphanDeletedSessions(ctx.db);
+        return c.json({ count: orphans.length });
+    });
+    // A3：用户展开「未归属项目」分组时显式标记孤儿已看到（保留期自此刻起算）。
+    app.post('/deleted/orphans/seen', async (c) => {
+        const touched = await touchTrashSeen(ctx.db, { orphan: true });
+        return c.json({ ok: true, touched });
+    });
+    // 清空回收站：物理删除所有软删除会话（不可恢复）。?projectId= 仅清空该项目。
+    app.delete('/deleted', async (c) => {
+        const projectId = c.req.query('projectId');
+        const count = await emptyTrash(ctx.db, projectId);
+        return c.json({ ok: true, deleted: count });
     });
     // 获取会话详情
     app.get('/:id', async (c) => {
         try {
             const session = await getSession(ctx.db, c.req.param('id'));
-            if (!session) {
-                return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+            if (!session || session.deletedAt) {
+                return apiError(c, 404, 'NOT_FOUND', '会话不存在或已删除');
             }
             return c.json(session);
         }
@@ -59,9 +158,29 @@ function createSessionRoute(ctx) {
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
         }
     });
+    // P2-5：会话重命名（此前标题只能由 LLM 自动生成，用户无法修改）
+    app.patch('/:id', async (c) => {
+        const id = c.req.param('id');
+        const body = (await c.req.json().catch(() => ({})));
+        const title = typeof body.title === 'string' ? body.title.trim() : '';
+        if (!title)
+            return apiError(c, 400, 'BAD_REQUEST', 'title is required');
+        if (title.length > 120) {
+            return apiError(c, 400, 'BAD_REQUEST', 'title must be at most 120 characters');
+        }
+        const session = await getSession(ctx.db, id);
+        if (!session)
+            return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        await updateSessionTitle(ctx.db, id, title);
+        return c.json({ ok: true, title });
+    });
     // 分支会话：未指定 messageIndex 时默认在最新一条消息处分叉（fork=完整副本语义）
     app.post('/:id/fork', async (c) => {
         const id = c.req.param('id');
+        // P3：fork 复制消息树，与正在写库的活跃 run 存在竞态——先拒绝。
+        if (ctx.agentManager.get(id)) {
+            return apiError(c, 409, 'RUN_ACTIVE', '该会话已有进行中的对话，请等待完成或中止后再分支');
+        }
         const body = await c.req.json().catch(() => ({}));
         let messageIndex = body.messageIndex;
         if (messageIndex === undefined || !Number.isFinite(messageIndex)) {
@@ -83,24 +202,151 @@ function createSessionRoute(ctx) {
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
         }
     });
-    // 删除会话（软删除：级联其 fork 后代进入回收站，30 天后物理清除）
+    // 删除会话（软删除：级联其 fork 后代进入回收站，30 天后物理清除）。
+    // P2 修复：删除运行中的会话前先中止其活跃 run（含子 agent）——
+    // 否则 run 继续向已删除会话写入消息，用户以为已删除而 agent 仍在执行。
     app.delete('/:id', async (c) => {
-        const ok = await softDeleteSession(ctx.db, c.req.param('id'));
+        const id = c.req.param('id');
+        ctx.agentManager.abort(id);
+        for (const child of ctx.agentManager.children(id)) {
+            ctx.agentManager.abort(child.sessionId);
+        }
+        const ok = await softDeleteSession(ctx.db, id);
         if (!ok)
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
         return c.body(null, 204);
     });
-    // 恢复会话（从回收站还原；仅还原该会话本身）
+    // 彻底删除回收站会话（不可恢复）：会话 + 全部后代物理清除
+    app.delete('/:id/forever', async (c) => {
+        let count;
+        try {
+            count = await permanentlyDeleteSession(ctx.db, c.req.param('id'));
+        }
+        catch {
+            return apiError(c, 404, 'NOT_FOUND', '会话不存在或不在回收站');
+        }
+        if (count === 0)
+            return apiError(c, 404, 'NOT_FOUND', '会话不存在或不在回收站');
+        return c.json({ ok: true, deleted: count });
+    });
+    // 会话归档列表（compaction/squash/shake/clear 的原始内容）；?q= 搜索归档文本
+    app.get('/:id/archives', 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 q = c.req.query('q');
+        const archives = await listArchives(ctx.db, id, q);
+        return c.json({ archives });
+    });
+    // 会话导出：元数据 + 消息 + 全部归档（JSON 下载，数据可迁移）
+    app.get('/:id/export', 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);
+        const archives = await listArchives(ctx.db, id);
+        return c.json({
+            version: 1,
+            exportedAt: new Date().toISOString(),
+            session,
+            messages,
+            archives,
+        });
+    });
+    // 恢复会话（从回收站还原；仅还原该会话本身）。
+    // P1 可达性修复：会话所属项目已被删除时（FK set null），按 worktreePath 重建
+    // 项目记录并重新归属——否则恢复成功但会话不属于任何项目视图，UI 不可达。
+    // P1-2：body.projectId 提供时（当前项目视图），目录失效无法重建归属的孤儿
+    // 会话直接归属到该请求项目，恢复即可达。
     app.post('/:id/restore', async (c) => {
-        const ok = await restoreSession(ctx.db, c.req.param('id'));
-        if (!ok)
+        const id = c.req.param('id');
+        const body = (await c.req.json().catch(() => ({})));
+        const requestProjectId = typeof body.projectId === 'string' && body.projectId ? body.projectId : undefined;
+        const result = await restoreSessionCore(ctx.db, id);
+        if (!result.restored)
             return apiError(c, 404, 'NOT_FOUND', '会话不存在或未删除');
-        return c.json({ ok: true });
+        const session = await getSession(ctx.db, id);
+        let rebound = false;
+        let orphaned = false;
+        if (session && !session.projectId) {
+            const wt = session.worktreePath;
+            if (wt && existsSync(wt)) {
+                try {
+                    const project = await fromDirectory(ctx.db, wt);
+                    await ctx.db.db.update(sessions).set({ projectId: project.id }).where(eq(sessions.id, id));
+                    rebound = true;
+                }
+                catch {
+                    orphaned = true;
+                }
+            }
+            else {
+                orphaned = true;
+            }
+            // P1-2：目录失效且请求方提供了项目上下文 → 归属到该请求项目
+            if (orphaned && requestProjectId) {
+                const project = await getProject(ctx.db, requestProjectId);
+                if (project) {
+                    await rebindSession(ctx.db, id, project);
+                    orphaned = false;
+                    rebound = true;
+                }
+            }
+        }
+        return c.json({
+            ok: true,
+            rebound,
+            orphaned,
+            restoredAncestorCount: result.restoredAncestorCount,
+            crossedBatchAncestor: result.crossedBatchAncestor,
+            // A2：批次不同的已删后代滞留在回收站，显式告知数量供前端提示单独恢复。
+            leftBehindDescendantCount: result.leftBehindDescendantCount,
+        });
     });
-    // 获取消息列表
+    // 会话归属变更（P1-2）：孤儿会话归属到指定项目，恢复后即可达。
+    app.post('/:id/rebind', async (c) => {
+        const id = c.req.param('id');
+        const body = (await c.req.json().catch(() => ({})));
+        const projectId = typeof body.projectId === 'string' && body.projectId ? body.projectId : '';
+        if (!projectId)
+            return apiError(c, 400, 'PROJECT_REQUIRED', 'projectId is required');
+        const project = await getProject(ctx.db, projectId);
+        if (!project)
+            return apiError(c, 404, 'PROJECT_NOT_FOUND', '目标项目不存在');
+        const ok = await rebindSession(ctx.db, id, project);
+        if (!ok)
+            return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        return c.json({ ok: true, projectId: project.id });
+    });
+    // 获取消息列表（含 steering 条目：P0 追加指令持久化后需在时间线可见）
     app.get('/:id/messages', async (c) => {
-        const messages = await getMessages(ctx.db, c.req.param('id'));
-        return c.json(messages);
+        const id = c.req.param('id');
+        const session = await getSession(ctx.db, id);
+        if (!session || session.deletedAt) {
+            return apiError(c, 404, 'NOT_FOUND', '会话不存在或已删除');
+        }
+        const [messages, steering] = await Promise.all([
+            getMessages(ctx.db, id),
+            getSteeringAsMessages(ctx.db, id),
+        ]);
+        if (steering.length === 0)
+            return c.json(messages);
+        // 按 createdAt 交错合并（steering 与消息时间序一致）
+        return c.json([...messages, ...steering].sort((a, b) => a.createdAt - b.createdAt));
     });
     // 获取 LLM 调用分段（段首快照 + 段内轻量 calls）：优先取活跃 run 的内存记录（实时），回退 DB 持久化
     app.get('/:id/llm-details', async (c) => {
@@ -111,8 +357,13 @@ function createSessionRoute(ctx) {
         return c.json(persisted);
     });
     // 手动触发会话压缩（段切换确认弹窗「顺便压缩」调用）。用末段的 provider/model 构建摘要器。
+    // P1 多项目：keepRecentTokens 按会话项目配置解析（此前用启动目录配置）。
     app.post('/:id/compact', async (c) => {
         const id = c.req.param('id');
+        // P3：压缩改写消息树，与活跃 run 的并发写入存在竞态——先拒绝。
+        if (ctx.agentManager.get(id)) {
+            return apiError(c, 409, 'RUN_ACTIVE', '该会话已有进行中的对话，请等待完成或中止后再压缩');
+        }
         let session;
         try {
             session = await getSession(ctx.db, id);
@@ -122,14 +373,35 @@ function createSessionRoute(ctx) {
         }
         if (!session)
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        let sessionConfig = ctx.config;
+        let sessionRegistry = ctx.llmRegistry;
+        try {
+            const sessionCwd = await resolveAgentCwd(ctx, session);
+            if (sessionCwd !== ctx.cwd) {
+                const projectScope = loadConfigScopes(sessionCwd).project;
+                if (projectScope) {
+                    sessionConfig = mergeConfig(ctx.config, projectScope);
+                    // P1-1：压缩摘要同样需要项目级 provider 注册表。
+                    if (sessionConfig.providers.length > 0) {
+                        sessionRegistry = buildRegistryFromConfig(sessionConfig);
+                    }
+                }
+            }
+        }
+        catch {
+            // cwd 解析失败不阻塞压缩：回退服务级配置（压缩优于报错）
+        }
         const segs = await getLLMSegments(ctx.db, id);
         const lastSeg = segs[segs.length - 1];
-        const provider = lastSeg?.provider ?? ctx.config.defaultProvider;
-        const model = lastSeg?.model ?? ctx.config.defaultModel;
+        const provider = lastSeg?.provider ?? sessionConfig.defaultProvider;
+        const model = lastSeg?.model ?? sessionConfig.defaultModel;
         try {
-            const summarizer = createSummarizer(ctx.llmRegistry, provider, model, {});
+            const fallback = buildFallbackChain(sessionConfig, provider, model);
+            const summarizer = createSummarizer(sessionRegistry, provider, model, {
+                ...(fallback ? { fallback } : {}),
+            });
             const result = await runCompaction(ctx.db, id, summarizer, {
-                keepRecentTokens: ctx.config.compaction.keepRecentTokens,
+                keepRecentTokens: sessionConfig.compaction.keepRecentTokens,
             });
             return c.json(result);
         }
@@ -175,6 +447,10 @@ function createSessionRoute(ctx) {
     // shake apply：归档原始内容 + 原位替换
     app.post('/:id/shake/apply', async (c) => {
         const id = c.req.param('id');
+        // P3：shake 原位改写消息，与活跃 run 的并发写入存在竞态——先拒绝。
+        if (ctx.agentManager.get(id)) {
+            return apiError(c, 409, 'RUN_ACTIVE', '该会话已有进行中的对话，请等待完成或中止后再 Shake');
+        }
         let session;
         try {
             session = await getSession(ctx.db, id);

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

@@ -5,11 +5,17 @@ import type { ServerContext } from '../types.js';
  * 路由本身不触发 npm registry 请求；调度器周期性 checkNow 写入缓存，
  * 路由读缓存（避免每个前端轮询都打外网）。
  *
- * POST /api/update/apply — 手动触发热更新（spec §18.2）：
- *   序列化当前会话 → performHotUpdate（npm install -g + spawn 新实例 + handoffPort）。
- *   旧实例通过 handoff 端点优雅退出，新实例 restore 快照并接管端口。
- *   响应立即返回（不阻塞 spawn），实际接管由 handoff IPC 异步完成。
- *   dev（vite）模式无 handoff server，返回 409——热更新仅在独立 serve 进程可用。
+ * POST /api/update/apply — 手动触发热更新（spec §18.2），P0 修复后顺序：
+ *   1. checkNow 确认有更新；
+ *   2. performInstall（仅安装新版本）——失败时**尚未暂停任何会话**，
+ *      直接返回可操作错误（409 + 手动更新命令），用户工作零损失；
+ *   3. 安装成功 → pauseAll 暂停活跃 run 至安全点（原子操作完成）；
+ *   4. serializeSessions → performHandoff（写快照 + spawn 新实例）；
+ *   5. spawn 失败 → resumeAll 回滚暂停的会话，返回明确错误。
+ *
+ * 旧实例通过 handoff 端点优雅退出，新实例 restore 快照并接管端口。
+ * 响应立即返回（不阻塞 spawn），实际接管由 handoff IPC 异步完成。
+ * dev（vite）模式无 handoff server，返回 409——热更新仅在独立 serve 进程可用。
  */
 declare function createUpdateRoute(ctx: ServerContext): Hono;
 export { createUpdateRoute };