c0de-agent 1.9.0 → 1.11.0

package/dist/server/routes/chat.js

@@ -1,4 +1,5 @@
-import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { readFile, stat } from 'node:fs/promises';
 import { Hono } from 'hono';
 import { streamSSE } from 'hono/streaming';
 import { createAgent, runAgent } from '../../core/agent.js';
@@ -6,20 +7,37 @@ import { compactContext } from '../../core/loop.js';
 import { createSlashRegistry, parseSlashInput } from '../../core/slash.js';
 import { injectSteering } from '../../core/steering.js';
 import { buildWorkflowNotice, containsWorkflow } from '../../core/workflow.js';
+import { resolveRoute } from '../../llm/registry.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';
-/** 按 session.projectId 解析 agent 工作目录；无项目回退 ctx.cwd。 */
+/** 按 session.projectId / worktreePath 解析 agent 工作目录：
+ *  - 有 projectId → 项目 worktree（缺失/目录失效时抛错，由上层转 409）。
+ *  - 无 projectId（项目已删除后从回收站恢复的会话）→ 用 worktreePath 兜底：
+ *    目录失效同样抛错，绝不静默回退 serve cwd 导致 agent 在错误目录执行工具。
+ *  - 两者皆无（从未绑定项目的会话，如 CLI print）→ 回退 ctx.cwd。 */
 export async function resolveAgentCwd(ctx, session) {
-    if (!session.projectId)
-        return ctx.cwd;
+    if (!session.projectId) {
+        if (!session.worktreePath)
+            return ctx.cwd;
+        if (!existsSync(session.worktreePath)) {
+            throw new Error(`WORKTREE_MISSING: 会话工作目录已失效（${session.worktreePath}）。请检查目录是否被移动或删除`);
+        }
+        return session.worktreePath;
+    }
     const project = await getProject(ctx.db, session.projectId);
-    return project?.worktree ?? ctx.cwd;
+    if (!project) {
+        throw new Error(`PROJECT_MISSING: 会话所属项目已不存在（projectId=${session.projectId}）`);
+    }
+    if (!existsSync(project.worktree)) {
+        throw new Error(`WORKTREE_MISSING: 项目工作目录已失效（${project.worktree}）。请检查目录是否被移动或删除`);
+    }
+    return project.worktree;
 }
 function createChatRoute(ctx) {
     const app = new Hono();
@@ -42,16 +60,48 @@ function createChatRoute(ctx) {
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
         }
         // 提前解析 cwd（slash 拦截与 agent 路径都需使用）
-        const cwd = await resolveAgentCwd(ctx, session);
+        // P1-9：worktree 失效/项目缺失 → 明确 409，不静默回退服务端 cwd。
+        let cwd;
+        try {
+            cwd = await resolveAgentCwd(ctx, session);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.startsWith('PROJECT_MISSING')) {
+                return apiError(c, 409, 'PROJECT_MISSING', msg.replace('PROJECT_MISSING: ', ''));
+            }
+            if (msg.startsWith('WORKTREE_MISSING')) {
+                return apiError(c, 409, 'WORKTREE_MISSING', msg.replace('WORKTREE_MISSING: ', ''));
+            }
+            return apiError(c, 500, 'CWD_RESOLVE_FAILED', msg);
+        }
         // 斜杠命令拦截
         const parsed = parseSlashInput(message);
         if (parsed) {
             const registry = createSlashRegistry();
             const cmd = registry.get(parsed.name);
             if (cmd) {
+                // P2-4：执行 config.slashCommands.enabled 过滤（此前该配置无任何消费方）。
+                // enabled 为空 = 全部启用（与 tools.enabled 语义一致）；名称兼容带/不带前缀斜杠。
+                const enabledList = ctx.config.slashCommands?.enabled ?? [];
+                const enabledSet = new Set(enabledList.map((n) => (n.startsWith('/') ? n.slice(1) : n)));
+                if (enabledSet.size > 0 && !enabledSet.has(parsed.name)) {
+                    return streamSSE(c, async (stream) => {
+                        await stream.writeSSE({
+                            event: 'text_delta',
+                            data: JSON.stringify({
+                                _tag: 'text_delta',
+                                text: `斜杠命令 /${parsed.name} 未启用（config.slashCommands.enabled）`,
+                            }),
+                        });
+                        await stream.writeSSE({ event: 'done', data: JSON.stringify({ _tag: 'done' }) });
+                    });
+                }
                 const commandCtx = {
                     cwd,
                     config: ctx.config,
+                    // 当前会话 id：/clear /fork 等命令默认作用于当前会话（P2-4）。
+                    sessionId,
                     // 内置斜杠命令（/clear、/fork、/config）仅需 db + config；
                     // 但 /workflow run 会走 executeWorkflow → buildWorkflowContext → runSubAgent，
                     // 该路径需要 agentRegistry 来派生子 agent，因此必须注入。
@@ -160,6 +210,7 @@ function createChatRoute(ctx) {
             }
         }
         // @文件上下文：读取文件内容写入快照，后续 getSessionContext→injectSnapshots 自动注入。
+        // 快照记录文件 mtime——注入前比对磁盘，过期自动刷新（P1-5）。
         // 路径越界或读取失败静默跳过，不阻塞主对话流。
         const files = body.files;
         if (files?.length) {
@@ -168,8 +219,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,175 +234,260 @@ 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}`);
-        }
-        // 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),
-                    },
+        // P0-1 首次运行引导：provider 未配置/未注册时立即返回可操作错误，
+        // 不让错误延迟到 SSE 流内以英文 NoRoute 冒出。前端据此引导用户去设置页。
+        // 注：测试注入 ctx.chatStream 时跳过——测试 registry 空壳不代表生产未配置。
+        if (!ctx.chatStream) {
+            try {
+                resolveRoute(ctx.llmRegistry, provider, model);
+            }
+            catch {
+                const configured = ctx.config.providers
+                    .map((p) => p.name)
+                    .filter(Boolean)
+                    .join(', ');
+                return apiError(c, 400, 'NO_PROVIDER_CONFIGURED', `未配置可用的 AI 服务（provider: ${provider}）。请前往「设置 → Provider」添加 API 服务并测试连接`, {
+                    provider,
+                    configuredProviders: ctx.config.providers.map((p) => p.name).filter(Boolean),
+                    ...(configured ? { hint: `已配置：${configured}` } : {}),
                 });
             }
         }
-        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));
+        // 并发守卫（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', '该会话已有进行中的对话');
+        }
+        // 占位持有期（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 通知前端，阻塞等待确认。
+                    // P1-5：模式按会话隔离（sessionPermissionModes 覆盖优先）。
+                    const permissionChecker = createInteractivePermissionChecker(ctx.permissionStore, {
+                        getMode: () => ctx.sessionPermissionModes.get(sessionId) ?? ctx.permissionMode,
+                        onPermissionRequired: async (req) => {
+                            await stream.writeSSE({
+                                event: 'permission_required',
+                                data: JSON.stringify({ _tag: 'permission_required', ...req }),
+                            });
                         },
-                    }),
-                });
-            }
-            finally {
-                // 先从 agentManager 注销：必须最先执行，确保客户端断开使 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) {
+                        // P1-6：确认超时（5 分钟）被自动拒绝时通知前端，避免用户误以为已执行
+                        onPermissionTimeout: (req) => {
+                            stream
+                                .writeSSE({
+                                event: 'permission_timeout',
+                                data: JSON.stringify({ _tag: 'permission_timeout', ...req }),
+                            })
+                                .catch(() => { });
+                        },
+                    });
+                    // 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,
+                    });
+                    state.lastRunStartedAt = 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,
+                                },
+                            }),
+                        });
+                    }
+                }
+                catch (err) {
+                    // 启动阶段（createAgent/updateSessionLastRun 等）失败：补发 error 事件。
+                    // 客户端已断开时 writeSSE 会 reject，吞掉以保证 finally 善后执行。
                     await stream
-                        .writeSSE({ event: 'done', data: JSON.stringify({ _tag: 'done' }) })
+                        .writeSSE({
+                        event: 'error',
+                        data: JSON.stringify({
+                            _tag: 'error',
+                            error: {
+                                _tag: 'unexpected',
+                                message: err instanceof Error ? err.message : String(err),
+                            },
+                        }),
+                    })
                         .catch(() => { });
                 }
-                // 无论正常完成、错误还是 abort，只要服务还活着就标记 completed。
-                // 只有服务崩溃/重启才会留下 status='running' → 下次加载检测为 interrupted。
-                await updateSessionLastRun(ctx.db, sessionId, {
-                    status: 'completed',
-                    ...(agentName !== 'default' ? { agentName } : {}),
-                    provider,
-                    model: resolvedModel,
-                    startedAt: runStartedAt,
-                }).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,26 +1,78 @@
 import { Hono } from 'hono';
-import { mergeConfig, saveConfig } from '../../core/config.js';
-import { encryptSecret, isEncryptedSecret } from '../../core/secret.js';
+import { applyScopedPatch, loadConfigScopes, mergeConfig, saveConfigScoped, } from '../../core/config.js';
+import { decryptSecret, encryptSecret, isEncryptedSecret } from '../../core/secret.js';
+import { apiError } from '../middleware/error.js';
 import { syncRegistryFromConfig } from '../server.js';
+/** 检查每个 provider 的 apiKey 能否在本机解密（机器绑定密钥换机/容器重建后会失败）。 */
+function providerApiKeyWarnings(providers) {
+    const warnings = [];
+    for (const p of providers) {
+        if (!p.apiKey || !isEncryptedSecret(p.apiKey))
+            continue;
+        try {
+            decryptSecret(p.apiKey);
+        }
+        catch {
+            warnings.push(`provider "${p.name || '(未命名)'}" 的 API Key 无法在本机解密（密钥与机器绑定）。` +
+                '若配置来自其他机器或容器重建，请重新填写 API Key。');
+        }
+    }
+    return warnings;
+}
 function createConfigRoute(ctx) {
     const app = new Hono();
+    // GET / — 合并后配置 + 作用域信息 + apiKey 解密警告
     app.get('/', (c) => {
-        return c.json(ctx.config);
+        const scopes = loadConfigScopes(ctx.cwd);
+        return c.json({
+            config: ctx.config,
+            scopes: {
+                global: scopes.global ?? null,
+                project: scopes.project ?? null,
+            },
+            warnings: providerApiKeyWarnings(ctx.config.providers),
+        });
     });
+    // PATCH / — 按作用域写入。body.scope: 'global' | 'project'（默认 project，兼容旧客户端）。
     app.patch('/', async (c) => {
-        const patch = (await c.req.json());
+        const body = (await c.req.json());
+        const scope = body.scope === 'global' ? 'global' : 'project';
+        const { scope: _omit, ...patch } = body;
         // spec §24.2：provider apiKey 落盘前加密，明文不持久化。
         // 已加密（enc: 前缀）或无 apiKey 的透传。
         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 只合并进指定作用域原始文件，
+        // 不把合并结果（含默认值/另一作用域配置）整体序列化进文件。
+        // null 值 = 删除该作用域中的键（回落到另一作用域/默认值）。
+        const scopes = loadConfigScopes(ctx.cwd);
+        const nextScoped = scope === 'global'
+            ? applyScopedPatch(scopes.global ?? {}, patch)
+            : applyScopedPatch(scopes.project ?? {}, patch);
+        // P2-3：落盘失败必须反馈给前端（此前静默吞掉，UI 显示已保存但重启后丢失）。
+        // 先落盘、成功后才更新内存配置与 registry，保证「已保存」反馈与磁盘状态一致。
+        try {
+            await saveConfigScoped(scope, ctx.cwd, nextScoped);
+        }
+        catch (err) {
+            return apiError(c, 500, 'CONFIG_SAVE_FAILED', `配置保存失败：${err instanceof Error ? err.message : String(err)}`);
+        }
+        ctx.config =
+            scope === 'global'
+                ? mergeConfig(nextScoped, scopes.project)
+                : mergeConfig(scopes.global, nextScoped);
         // providers 变更后原地同步 registry，使运行中的连接立即生效
         syncRegistryFromConfig(ctx.llmRegistry, ctx.config);
-        await saveConfig(ctx.config, 'project', ctx.cwd).catch(() => {
-            // 保存失败不影响内存配置
+        // 安全类配置（token/authEnabled/allowedOrigins）由 authManager 在启动时一次性读取，
+        // 运行时修改不生效——告知前端提示重启。
+        const needsRestart = patch.security !== undefined;
+        return c.json({
+            config: ctx.config,
+            scope,
+            needsRestart,
+            warnings: providerApiKeyWarnings(ctx.config.providers),
         });
-        return c.json(ctx.config);
     });
     return app;
 }

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

@@ -1,5 +1,8 @@
 import { Hono } from 'hono';
 import type { ServerContext } from '../types.js';
-/** GET/PUT /api/permissions — 全局授权模式（default 逐个确认 / auto 自动放行 ask 工具）。 */
+/** GET/PUT /api/permissions — 授权模式（default 逐个确认 / auto 自动放行 ask 工具）。
+ *  - 根路径：默认模式（全局，启动时取 config.permission.defaultMode）
+ *  - /:sessionId：会话级覆盖（P1-5 按会话隔离 auto 高风险状态）
+ */
 declare function createPermissionsRoute(ctx: ServerContext): Hono;
 export { createPermissionsRoute };