c0de-agent 1.8.0 → 1.10.0

package/dist/server/routes/chat.js

@@ -1,4 +1,4 @@
-import { readFile } from 'node:fs/promises';
+import { readFile, stat } from 'node:fs/promises';
 import { Hono } from 'hono';
 import { streamSSE } from 'hono/streaming';
 import { createAgent, runAgent } from '../../core/agent.js';
@@ -9,8 +9,8 @@ import { buildWorkflowNotice, containsWorkflow } from '../../core/workflow.js';
 import { getProject } from '../../project/project.js';
 import { getLLMSegments, getSession, updateSessionLastRun } from '../../session/session.js';
 import { upsertFileSnapshot } from '../../session/snapshot.js';
+import { resolveEnabledToolNames } from '../../tools/index.js';
 import { autoAllowChecker } from '../../tools/permission.js';
-import { listTools } from '../../tools/registry.js';
 import { apiError } from '../middleware/error.js';
 import { createInteractivePermissionChecker } from '../permission/interactive.js';
 import { safeResolve } from '../util/safe-path.js';
@@ -160,6 +160,7 @@ function createChatRoute(ctx) {
             }
         }
         // @文件上下文：读取文件内容写入快照，后续 getSessionContext→injectSnapshots 自动注入。
+        // 快照记录文件 mtime——注入前比对磁盘，过期自动刷新（P1-5）。
         // 路径越界或读取失败静默跳过，不阻塞主对话流。
         const files = body.files;
         if (files?.length) {
@@ -168,8 +169,13 @@ function createChatRoute(ctx) {
                 if (!resolved)
                     continue;
                 try {
+                    // 先 stat 再 readFile（与 session/context.ts 刷新路径一致）：若先读后
+                    // stat，文件恰在两次调用间被写会存「旧内容 + 新 mtime」，注入前的
+                    // mtime 相等判定使旧内容被永久钉住；先 stat 后读最坏存「新内容 +
+                    // 旧 mtime」，下次注入仍会触发刷新，可自愈。
+                    const st = await stat(resolved);
                     const content = await readFile(resolved, 'utf-8');
-                    await upsertFileSnapshot(ctx.db, sessionId, p, content);
+                    await upsertFileSnapshot(ctx.db, sessionId, p, content, st.mtimeMs);
                 }
                 catch {
                     // 文件读取失败静默跳过
@@ -178,169 +184,230 @@ function createChatRoute(ctx) {
         }
         const provider = body.provider ?? ctx.config.defaultProvider;
         const model = body.model ?? ctx.config.defaultModel;
-        // 前端 ToolToggle 全选时不传 tools（undefined），语义为「启用全部注册工具」。
-        // 显式传 [] 才是禁用全部。config.tools.enabled 仅 CLI 模式使用，此处不回退它，
-        // 避免配置里 enabled:[] 把 Web 全选误降级为无工具（LLM 无法 function call）。
-        const tools = body.tools ??
-            listTools(ctx.toolRegistry, { config: {}, cwd }).map((t) => t.name);
-        // primary agent 解析（spec: agent-frontend-switching §4.3）
-        const agentName = body.agent ?? 'default';
-        const agentDef = ctx.agentRegistry.get(agentName);
-        if (!agentDef || agentDef.mode === 'subagent') {
-            return apiError(c, 400, 'INVALID_AGENT', `Unknown or non-primary agent: ${agentName}`);
+        // 并发守卫（P0-4）：同步原子占位 tryAcquire（Map has+set 一气呵成、无 await）。
+        // 旧实现先 get 检查、真正 register 在 SSE 回调内，两者之间隔多个 await
+        // （getLLMSegments、createAgent 等）：双发 POST 在窗口内均通过守卫，后注册
+        // 覆盖前者（agentManager runs.set），且 A 结束时 unregister 把仍在跑的 B
+        // 删掉，abort/steer/pause 对 B 全部失效。占位失败说明该会话已被占用
+        // （活跃 run 或另一请求的占位），立即 409。
+        if (!ctx.agentManager.tryAcquire(sessionId)) {
+            return apiError(c, 409, 'RUN_ACTIVE', '该会话已有进行中的对话');
         }
-        // agent def 覆盖：tools（plan 限只读）、model（可选）
-        const resolvedTools = agentDef.tools ?? tools;
-        const resolvedModel = agentDef.model ?? model;
-        // 分段预检：切换 provider/model/tools 将开新段（前缀失效→缓存 miss），
-        // 需用户显式确认（confirmSegmentBreak）。首轮无活跃段时跳过。
-        const existingRun = ctx.agentManager.get(sessionId);
-        const segs = existingRun ? existingRun.state.segments : await getLLMSegments(ctx.db, sessionId);
-        const active = segs[segs.length - 1];
-        if (active) {
-            const reqTools = new Set(resolvedTools);
-            const segTools = new Set(active.tools.map((t) => t.name));
-            const toolsDiffer = reqTools.size !== segTools.size || [...reqTools].some((t) => !segTools.has(t));
-            const modelDiffer = active.provider !== provider || active.model !== resolvedModel;
-            // 旧段 agentName undefined 视为 'default'
-            const agentDiffer = (active.agentName ?? 'default') !== agentName;
-            const confirmed = body.confirmSegmentBreak === true;
-            if ((modelDiffer || toolsDiffer || agentDiffer) && !confirmed) {
-                return apiError(c, 409, 'SEGMENT_BREAK_REQUIRED', '切换模型/工具将开始新的上下文段（缓存失效），需用户确认', {
-                    activeSegment: {
-                        provider: active.provider,
-                        model: active.model,
-                        tools: active.tools.map((t) => t.name),
-                    },
-                });
-            }
-        }
-        return streamSSE(c, async (stream) => {
-            // 权限检查器：ask 权限通过 SSE 通知前端，阻塞等待确认
-            const permissionChecker = createInteractivePermissionChecker(ctx.permissionStore, {
-                getMode: () => ctx.permissionMode,
-                onPermissionRequired: async (req) => {
-                    await stream.writeSSE({
-                        event: 'permission_required',
-                        data: JSON.stringify({ _tag: 'permission_required', ...req }),
-                    });
-                },
-            });
-            // cwd 已在斜杠拦截前解析，此处直接复用
-            // 构建 agent 依赖（注入测试用 chatStream）
-            const deps = {
-                db: ctx.db,
-                llmRegistry: ctx.llmRegistry,
-                toolRegistry: ctx.toolRegistry,
-                urlRegistry: ctx.urlRegistry,
-                hookRunner: ctx.hookRunner,
-                permission: permissionChecker,
-                config: ctx.config,
-                agentRegistry: ctx.agentRegistry,
-                cwd,
-                ...(ctx.chatStream ? { chatStream: ctx.chatStream } : {}),
-            };
-            const agentConfig = {
-                provider,
-                model: resolvedModel,
-                tools: resolvedTools,
-                plugins: ctx.config.plugins.enabled,
-                agentName,
-                ...(agentDef.systemPrompt ? { agentRolePrompt: agentDef.systemPrompt } : {}),
-            };
-            const state = await createAgent(session, agentConfig, deps);
-            // 持久化 run 状态：status='running' 写入 DB。服务重启后此字段仍为 'running'
-            // 而进程无活跃 run → 检测为 interrupted。finally 中标记 'completed'。
-            const runStartedAt = Date.now();
-            await updateSessionLastRun(ctx.db, sessionId, {
-                status: 'running',
-                ...(agentName !== 'default' ? { agentName } : {}),
-                provider,
-                model: resolvedModel,
-                startedAt: runStartedAt,
-            });
-            ctx.agentManager.register({ sessionId, state, deps });
-            // workflowz 关键词检测：用户消息包含独立关键词时注入工作流通知（steering），
-            // 引导模型用 task 工具批量 fan-out 做确定性多子 agent 分解。
-            if (containsWorkflow(message)) {
-                const wfList = ctx.workflowRegistry
-                    ? ctx.workflowRegistry.list().map((w) => ({
-                        name: w.meta.name,
-                        description: w.meta.description,
-                    }))
-                    : [];
-                injectSteering(state, buildWorkflowNotice(wfList));
+        // 占位持有期（tryAcquire → SSE 回调 register）内的任何提前返回或抛错都必须
+        // 释放占位，否则该会话被永久 409 锁死。handedOff 标记所有权已移交 SSE 回调
+        // （其 finally 负责幂等释放），移交前的全部路径在 finally 统一兜底释放。
+        let handedOff = false;
+        try {
+            // 工具解析（P1-1）：config.tools.enabled 非空时作为默认集；空 = 全部注册工具。
+            // disabled 已在 registry 层过滤（createDefaultRegistry），此处兜底。
+            const tools = resolveEnabledToolNames(ctx.toolRegistry, ctx.config, body.tools);
+            // primary agent 解析（spec: agent-frontend-switching §4.3）
+            const agentName = body.agent ?? 'default';
+            const agentDef = ctx.agentRegistry.get(agentName);
+            if (!agentDef || agentDef.mode === 'subagent') {
+                return apiError(c, 400, 'INVALID_AGENT', `Unknown or non-primary agent: ${agentName}`);
             }
-            // 客户端断开时中止 agent
-            stream.onAbort(() => {
-                ctx.agentManager.abort(sessionId);
-            });
-            // 跟踪 done 事件是否已发送：agentLoop 正常完成时 yield done；
-            // 但 error/abort/max_turns 等路径不 yield done，需在 finally 补发。
-            // 否则前端 isStreaming 永远不会变 false，按钮卡在「终止」态。
-            let doneSent = false;
-            try {
-                for await (const event of runAgent(state, userContent, deps)) {
-                    if (event._tag === 'done')
-                        doneSent = true;
-                    await stream.writeSSE({
-                        event: event._tag,
-                        data: JSON.stringify(event),
+            // agent def 覆盖：tools（plan 限只读）、model（可选）
+            const resolvedTools = agentDef.tools ?? tools;
+            const resolvedModel = agentDef.model ?? model;
+            // 分段预检：切换 provider/model/tools 将开新段（前缀失效→缓存 miss），
+            // 需用户显式确认（confirmSegmentBreak）。首轮无活跃段时跳过。
+            // 守卫 409 短路后 agentManager.get 恒为 undefined，原 existingRun 三元
+            // 恒走 else 分支（死代码，已删除）。
+            const segs = await getLLMSegments(ctx.db, sessionId);
+            const active = segs[segs.length - 1];
+            if (active) {
+                const reqTools = new Set(resolvedTools);
+                const segTools = new Set(active.tools.map((t) => t.name));
+                const toolsDiffer = reqTools.size !== segTools.size || [...reqTools].some((t) => !segTools.has(t));
+                const modelDiffer = active.provider !== provider || active.model !== resolvedModel;
+                // 旧段 agentName undefined 视为 'default'
+                const agentDiffer = (active.agentName ?? 'default') !== agentName;
+                const confirmed = body.confirmSegmentBreak === true;
+                if ((modelDiffer || toolsDiffer || agentDiffer) && !confirmed) {
+                    return apiError(c, 409, 'SEGMENT_BREAK_REQUIRED', '切换模型/工具将开始新的上下文段（缓存失效），需用户确认', {
+                        activeSegment: {
+                            provider: active.provider,
+                            model: active.model,
+                            tools: active.tools.map((t) => t.name),
+                        },
                     });
                 }
             }
-            catch (err) {
-                const message = err instanceof Error
-                    ? err.message
-                    : typeof err === 'object' && err !== null && 'message' in err
-                        ? String(err.message)
-                        : String(err);
-                await stream.writeSSE({
-                    event: 'error',
-                    data: JSON.stringify({
-                        _tag: 'error',
-                        error: {
-                            _tag: 'unexpected',
-                            message,
+            const response = streamSSE(c, async (stream) => {
+                // P0-4：回调从首行起全部纳入 try/finally——createAgent、updateSessionLastRun
+                // 等启动阶段失败同样必须释放占位并补发 error/done（hono 的 stream 包装器
+                // 只 console.error 不善后），不得泄漏占位或让前端卡在 streaming 态。
+                let doneSent = false;
+                let runStartedAt;
+                try {
+                    // 权限检查器：ask 权限通过 SSE 通知前端，阻塞等待确认
+                    const permissionChecker = createInteractivePermissionChecker(ctx.permissionStore, {
+                        getMode: () => ctx.permissionMode,
+                        onPermissionRequired: async (req) => {
+                            await stream.writeSSE({
+                                event: 'permission_required',
+                                data: JSON.stringify({ _tag: 'permission_required', ...req }),
+                            });
                         },
-                    }),
-                });
-            }
-            finally {
-                // agentLoop 的 error/abort/max_turns 路径不 yield done，在此补发。
-                // 正常完成路径已在循环中 yield done，doneSent=true 时跳过避免重复。
-                if (!doneSent) {
-                    await stream.writeSSE({ event: 'done', data: JSON.stringify({ _tag: 'done' }) });
+                    });
+                    // cwd 已在斜杠拦截前解析，此处直接复用
+                    // 构建 agent 依赖（注入测试用 chatStream）
+                    const deps = {
+                        db: ctx.db,
+                        llmRegistry: ctx.llmRegistry,
+                        toolRegistry: ctx.toolRegistry,
+                        urlRegistry: ctx.urlRegistry,
+                        hookRunner: ctx.hookRunner,
+                        permission: permissionChecker,
+                        config: ctx.config,
+                        agentRegistry: ctx.agentRegistry,
+                        cwd,
+                        ...(ctx.chatStream ? { chatStream: ctx.chatStream } : {}),
+                    };
+                    const agentConfig = {
+                        provider,
+                        model: resolvedModel,
+                        tools: resolvedTools,
+                        plugins: ctx.config.plugins.enabled,
+                        agentName,
+                        ...(agentDef.systemPrompt ? { agentRolePrompt: agentDef.systemPrompt } : {}),
+                    };
+                    const state = await createAgent(session, agentConfig, deps);
+                    // 持久化 run 状态：status='running' 写入 DB。服务重启后此字段仍为 'running'
+                    // 而进程无活跃 run → 检测为 interrupted。finally 中标记 'completed'。
+                    runStartedAt = Date.now();
+                    await updateSessionLastRun(ctx.db, sessionId, {
+                        status: 'running',
+                        ...(agentName !== 'default' ? { agentName } : {}),
+                        provider,
+                        model: resolvedModel,
+                        startedAt: runStartedAt,
+                    });
+                    // 填充 tryAcquire 留下的占位（原 register 语义：按 sessionId 覆盖写入）
+                    ctx.agentManager.register({ sessionId, state, deps });
+                    // workflowz 关键词检测：用户消息包含独立关键词时注入工作流通知（steering），
+                    // 引导模型用 task 工具批量 fan-out 做确定性多子 agent 分解。
+                    if (containsWorkflow(message)) {
+                        const wfList = ctx.workflowRegistry
+                            ? ctx.workflowRegistry.list().map((w) => ({
+                                name: w.meta.name,
+                                description: w.meta.description,
+                            }))
+                            : [];
+                        injectSteering(state, buildWorkflowNotice(wfList));
+                    }
+                    // 客户端断开时中止 agent
+                    stream.onAbort(() => {
+                        ctx.agentManager.abort(sessionId);
+                    });
+                    // 跟踪 done 事件是否已发送：agentLoop 正常完成时 yield done；
+                    // 但 error/abort/max_turns 等路径不 yield done，需在 finally 补发。
+                    // 否则前端 isStreaming 永远不会变 false，按钮卡在「终止」态。
+                    try {
+                        for await (const event of runAgent(state, userContent, deps)) {
+                            if (event._tag === 'done')
+                                doneSent = true;
+                            await stream.writeSSE({
+                                event: event._tag,
+                                data: JSON.stringify(event),
+                            });
+                        }
+                    }
+                    catch (err) {
+                        const message = err instanceof Error
+                            ? err.message
+                            : typeof err === 'object' && err !== null && 'message' in err
+                                ? String(err.message)
+                                : String(err);
+                        await stream.writeSSE({
+                            event: 'error',
+                            data: JSON.stringify({
+                                _tag: 'error',
+                                error: {
+                                    _tag: 'unexpected',
+                                    message,
+                                },
+                            }),
+                        });
+                    }
                 }
-                // 无论正常完成、错误还是 abort，只要服务还活着就标记 completed。
-                // 只有服务崩溃/重启才会留下 status='running' → 下次加载检测为 interrupted。
-                await updateSessionLastRun(ctx.db, sessionId, {
-                    status: 'completed',
-                    ...(agentName !== 'default' ? { agentName } : {}),
-                    provider,
-                    model: resolvedModel,
-                    startedAt: runStartedAt,
-                }).catch(() => { });
+                catch (err) {
+                    // 启动阶段（createAgent/updateSessionLastRun 等）失败：补发 error 事件。
+                    // 客户端已断开时 writeSSE 会 reject，吞掉以保证 finally 善后执行。
+                    await stream
+                        .writeSSE({
+                        event: 'error',
+                        data: JSON.stringify({
+                            _tag: 'error',
+                            error: {
+                                _tag: 'unexpected',
+                                message: err instanceof Error ? err.message : String(err),
+                            },
+                        }),
+                    })
+                        .catch(() => { });
+                }
+                finally {
+                    // 先从 agentManager 释放（占位与活跃 run 均幂等）：必须最先执行，确保
+                    // 客户端断开使 writeSSE reject 时 agent 状态（state/deps/AbortController）
+                    // 不会泄漏到 Map（unregister 仅做 Map.delete、不依赖 state，放最前安全）。
+                    ctx.agentManager.unregister(sessionId);
+                    // agentLoop 的 error/abort/max_turns 路径不 yield done，在此补发。
+                    // 正常完成路径已在循环中 yield done，doneSent=true 时跳过避免重复。
+                    // 客户端已断开时 writeSSE 会 reject，吞掉以保证后续 updateSessionLastRun 执行。
+                    if (!doneSent) {
+                        await stream
+                            .writeSSE({ event: 'done', data: JSON.stringify({ _tag: 'done' }) })
+                            .catch(() => { });
+                    }
+                    // 无论正常完成、错误还是 abort，只要服务还活着就标记 completed。
+                    // 只有服务崩溃/重启才会留下 status='running' → 下次加载检测为 interrupted。
+                    // runStartedAt 未定义说明 run 从未真正启动（createAgent 即失败），DB 中
+                    // 无 'running' 标记需要清理，跳过写入。
+                    if (runStartedAt !== undefined) {
+                        await updateSessionLastRun(ctx.db, sessionId, {
+                            status: 'completed',
+                            ...(agentName !== 'default' ? { agentName } : {}),
+                            provider,
+                            model: resolvedModel,
+                            startedAt: runStartedAt,
+                        }).catch(() => { });
+                    }
+                }
+            });
+            // streamSSE 已同步启动回调（回调的 register/finally 从此接管占位填充与
+            // 释放），所有权移交：本层 finally 不再兜底释放。
+            handedOff = true;
+            return response;
+        }
+        finally {
+            if (!handedOff)
                 ctx.agentManager.unregister(sessionId);
-            }
-        });
+        }
     });
     // 控制端点
+    // P0-4：占位中的会话（tryAcquire 后、register 前）run 尚无 state 可供
+    // abort/pause/resume/steer 操作——返回明确 409 而非静默 false 或崩溃。
+    const runStarting = (c, sessionId) => ctx.agentManager.isStarting(sessionId)
+        ? apiError(c, 409, 'RUN_STARTING', '该会话的对话正在启动，请稍后重试')
+        : undefined;
     app.post('/abort', async (c) => {
         const { sessionId } = await c.req.json();
-        return c.json({ aborted: ctx.agentManager.abort(sessionId) });
+        return runStarting(c, sessionId) ?? c.json({ aborted: ctx.agentManager.abort(sessionId) });
     });
     app.post('/pause', async (c) => {
         const { sessionId } = await c.req.json();
-        return c.json({ paused: ctx.agentManager.pause(sessionId) });
+        return runStarting(c, sessionId) ?? c.json({ paused: ctx.agentManager.pause(sessionId) });
     });
     app.post('/resume', async (c) => {
         const { sessionId } = await c.req.json();
-        return c.json({ resumed: ctx.agentManager.resume(sessionId) });
+        return runStarting(c, sessionId) ?? c.json({ resumed: ctx.agentManager.resume(sessionId) });
     });
     app.post('/steer', async (c) => {
         const body = await c.req.json();
-        return c.json({ steered: ctx.agentManager.steer(body.sessionId, body.message) });
+        return (runStarting(c, body.sessionId) ??
+            c.json({ steered: ctx.agentManager.steer(body.sessionId, body.message) }));
     });
     return app;
 }

package/dist/server/routes/config.js

@@ -1,5 +1,5 @@
 import { Hono } from 'hono';
-import { mergeConfig, saveConfig } from '../../core/config.js';
+import { loadConfigScopes, mergeConfig, mergeRaw, saveConfigScoped } from '../../core/config.js';
 import { encryptSecret, isEncryptedSecret } from '../../core/secret.js';
 import { syncRegistryFromConfig } from '../server.js';
 function createConfigRoute(ctx) {
@@ -14,10 +14,14 @@ function createConfigRoute(ctx) {
         if (Array.isArray(patch.providers)) {
             patch.providers = patch.providers.map((p) => p.apiKey && !isEncryptedSecret(p.apiKey) ? { ...p, apiKey: encryptSecret(p.apiKey) } : p);
         }
-        ctx.config = mergeConfig(ctx.config, patch);
+        // 按作用域最小落盘：patch 只合并进项目作用域原始文件，
+        // 不把合并结果（含默认值/global 配置）整体序列化进项目文件。
+        const scopes = loadConfigScopes(ctx.cwd);
+        const nextProject = mergeRaw(scopes.project ?? {}, patch);
+        ctx.config = mergeConfig(scopes.global, nextProject);
         // providers 变更后原地同步 registry，使运行中的连接立即生效
         syncRegistryFromConfig(ctx.llmRegistry, ctx.config);
-        await saveConfig(ctx.config, 'project', ctx.cwd).catch(() => {
+        await saveConfigScoped('project', ctx.cwd, nextProject).catch(() => {
             // 保存失败不影响内存配置
         });
         return c.json(ctx.config);

package/dist/server/routes/session.js

@@ -2,7 +2,7 @@ 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 { BranchPointOutOfRangeError, forkSession, getBranches, getTree, } from '../../session/branch.js';
 import { deleteEntriesByIds, getMessages, insertEntry } from '../../session/message.js';
 import { createSession, deleteSession, getLLMSegments, getSession, listSessions, listSessionsByProject, touchLastOpened, } from '../../session/session.js';
 import { applyShakeRegions, collectShakeRegions, DEFAULT_SHAKE_CONFIG, toRegionViews, } from '../../session/shake.js';
@@ -63,7 +63,11 @@ function createSessionRoute(ctx) {
             const forked = await forkSession(ctx.db, id, messageIndex);
             return c.json(forked, 201);
         }
-        catch {
+        catch (error) {
+            // 分支点越界是客户端索引/分页 bug → 400 并透出明确语义；归 404 会误导排查
+            if (error instanceof BranchPointOutOfRangeError) {
+                return apiError(c, 400, 'BRANCH_POINT_OUT_OF_RANGE', error.message);
+            }
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
         }
     });

package/dist/server/routes/terminal.js

@@ -1,6 +1,9 @@
 // src/server/routes/terminal.ts
+import { isAbsolute } from 'node:path';
 import { Hono } from 'hono';
 import { apiError } from '../middleware/error.js';
+/** 允许的 shell 白名单（P2-6：拒绝路径分隔符与任意二进制）。 */
+const ALLOWED_SHELLS = new Set(['bash', 'zsh', 'fish', 'sh']);
 /** 创建终端路由（REST 部分；WebSocket 升级在 server.ts 中处理）。 */
 function createTerminalRoute(ctx) {
     const app = new Hono();
@@ -18,6 +21,15 @@ function createTerminalRoute(ctx) {
         const title = typeof body.title === 'string' ? body.title : undefined;
         const shell = typeof body.shell === 'string' && body.shell.length > 0 ? body.shell : undefined;
         const projectId = typeof body.projectId === 'string' && body.projectId.length > 0 ? body.projectId : undefined;
+        // 入参校验（P2-6）：shell 白名单；cwd 必须为绝对路径。
+        if (shell !== undefined) {
+            if (shell.includes('/') || shell.includes('\\') || !ALLOWED_SHELLS.has(shell)) {
+                return apiError(c, 400, 'INVALID_SHELL', `shell 必须是 ${[...ALLOWED_SHELLS].join('/')} 之一`);
+            }
+        }
+        if (typeof cwd === 'string' && cwd.length > 0 && !isAbsolute(cwd)) {
+            return apiError(c, 400, 'INVALID_CWD', 'cwd 必须是绝对路径');
+        }
         try {
             const info = mgr.create({ cwd, cols, rows, title, shell, projectId });
             return c.json(info, 201);

package/dist/server/routes/todo.js

@@ -1,9 +1,9 @@
 // src/server/routes/todo.ts
 import { Hono } from 'hono';
-import { getMessages, appendMessage } from '../../session/message.js';
+import { appendMessage, getMessages } from '../../session/message.js';
 import { getSession } from '../../session/session.js';
 import { generateId } from '../../shared/index.js';
-import { todoTool, getLatestTodoPhasesFromMessages } from '../../tools/builtin/todo.js';
+import { formatSummary, getLatestTodoPhasesFromMessages, todoTool, } from '../../tools/builtin/todo.js';
 import { apiError } from '../middleware/error.js';
 /** 构造仅供 todo tool execute 使用的最小 ToolContext。 */
 function makeTodoCtx(phases, abort) {
@@ -89,6 +89,9 @@ function createTodoRoute(ctx) {
             // 更新活跃 agent 的内存状态
             if (run) {
                 run.state.todoPhases = updatedPhases;
+                // 前端手动修改了 todo 状态 → 注入 steering 通知 LLM（通道 A）
+                const summary = formatSummary(updatedPhases, [], true);
+                run.state.steeringQueue.push(`<todo-state-external>\nA todo change was made externally (via UI).\n${summary}\n</todo-state-external>`);
             }
         }
         return c.json({

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

@@ -9,6 +9,7 @@ import type { ServerContext } from '../types.js';
  *   序列化当前会话 → performHotUpdate（npm install -g + spawn 新实例 + handoffPort）。
  *   旧实例通过 handoff 端点优雅退出，新实例 restore 快照并接管端口。
  *   响应立即返回（不阻塞 spawn），实际接管由 handoff IPC 异步完成。
+ *   dev（vite）模式无 handoff server，返回 409——热更新仅在独立 serve 进程可用。
  */
 declare function createUpdateRoute(ctx: ServerContext): Hono;
 export { createUpdateRoute };

package/dist/server/routes/update.js

@@ -1,5 +1,5 @@
 import { Hono } from 'hono';
-import { performHotUpdate, serializeSessions } from '../../update/index.js';
+import { getCurrentVersion, performHotUpdate, serializeSessions } from '../../update/index.js';
 import { apiError } from '../middleware/error.js';
 /**
  * GET /api/update — 返回后台调度器缓存的版本检查结果（spec §18.1）。
@@ -10,6 +10,7 @@ import { apiError } from '../middleware/error.js';
  *   序列化当前会话 → performHotUpdate（npm install -g + spawn 新实例 + handoffPort）。
  *   旧实例通过 handoff 端点优雅退出，新实例 restore 快照并接管端口。
  *   响应立即返回（不阻塞 spawn），实际接管由 handoff IPC 异步完成。
+ *   dev（vite）模式无 handoff server，返回 409——热更新仅在独立 serve 进程可用。
  */
 function createUpdateRoute(ctx) {
     const app = new Hono();
@@ -20,20 +21,26 @@ function createUpdateRoute(ctx) {
         // 无缓存（首次启动延迟未到）：同步触发一次，避免前端首屏空。
         // 不 await——保持 GET 语义非阻塞；前端下次轮询拿到结果。
         void ctx.updateScheduler.checkNow();
+        const v = getCurrentVersion();
         return c.json({
             hasUpdate: false,
-            currentVersion: '0.0.0',
-            latestVersion: '0.0.0',
+            currentVersion: v,
+            latestVersion: v,
         });
     });
     app.post('/apply', async (c) => {
+        if (!ctx.handoff) {
+            return apiError(c, 409, 'HOT_UPDATE_UNAVAILABLE', '热更新仅在独立 serve 进程可用（dev 模式请手动更新）');
+        }
         const result = await ctx.updateScheduler.checkNow();
         if (!result.hasUpdate) {
             return apiError(c, 409, 'NO_UPDATE', '已是最新版本，无需热更新');
         }
         const snapshot = await serializeSessions(ctx.db, ctx.config);
         const r = await performHotUpdate(snapshot, {
-            handoffPort: ctx.handoff?.port,
+            handoffPort: ctx.handoff.port,
+            port: ctx.port,
+            authToken: ctx.authToken,
         });
         if (r._tag === 'success') {
             return c.json({

package/dist/server/routes/workflows.js

@@ -2,9 +2,9 @@ import { unlink } from 'node:fs/promises';
 import { Hono } from 'hono';
 import { streamSSE } from 'hono/streaming';
 import { createAgent } from '../../core/agent.js';
-import { executeWorkflow } from '../../core/workflows/runtime.js';
-import { reloadRegistry } from '../../core/workflows/registry.js';
 import { discoverWorkflows, saveWorkflow } from '../../core/workflows/discovery.js';
+import { reloadRegistry } from '../../core/workflows/registry.js';
+import { executeWorkflow } from '../../core/workflows/runtime.js';
 import { getProject } from '../../project/project.js';
 import { createSession } from '../../session/session.js';
 import { autoAllowChecker } from '../../tools/permission.js';