c0de-agent 1.10.0 → 1.12.0

package/dist/server/routes/auth.js

@@ -0,0 +1,124 @@
+// src/server/routes/auth.ts
+// P2-16：认证引导 + 设备配对审批端点。
+//
+// 公开端点（未认证，中间件 publicPaths 放行）：
+//   POST /api/auth/register          首设备注册：凭 bootstrap token 换发设备 token
+//   POST /api/auth/pairing/request   新设备发起配对：返回 pairingId + 6 位配对码
+//   GET  /api/auth/pairing/status?pairingId=xxx  新设备轮询审批结果
+//
+// 需认证端点（已授权设备调用）：
+//   GET  /api/auth/pairing           列出待审批配对
+//   POST /api/auth/pairing/approve   审批通过（签发设备 token）
+//   POST /api/auth/pairing/deny      拒绝配对
+//   GET  /api/auth/devices           列出已授权设备
+//   DELETE /api/auth/devices/:id     撤销设备（立即生效）
+import { Hono } from 'hono';
+import { apiError } from '../middleware/error.js';
+/** 尽力而为的请求来源：x-forwarded-for 首跳（反代场景），否则视为本地回环。仅展示/软限流。 */
+function requestSource(c) {
+    const fwd = c.req.header('x-forwarded-for');
+    if (fwd) {
+        const first = fwd.split(',')[0]?.trim();
+        if (first)
+            return first;
+    }
+    return 'local';
+}
+function createAuthRoute(ctx) {
+    const app = new Hono();
+    // 首设备注册：凭 bootstrap token（URL ?token=）换发设备 token，bootstrap 随即轮换失效。
+    app.post('/register', async (c) => {
+        if (!ctx.authManager) {
+            return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
+        }
+        const body = (await c.req.json().catch(() => ({})));
+        if (!body.token) {
+            return apiError(c, 400, 'BAD_REQUEST', 'token is required');
+        }
+        const deviceToken = await ctx.authManager.registerFirstDevice(body.token, body.deviceName ?? '设备');
+        if (!deviceToken) {
+            // bootstrap 已失效/已注册过设备 → 引导走配对审批
+            return apiError(c, 403, 'BOOTSTRAP_CONSUMED', 'bootstrap token 已失效（已有设备注册）。请在新设备发起配对，由已授权设备审批。');
+        }
+        // P1-3：回传注册成功的设备名，前端展示一次性确认（用户可核对注册的是否自己）。
+        return c.json({ deviceToken, deviceName: body.deviceName ?? '设备' });
+    });
+    // 新设备发起配对请求（公开）。
+    app.post('/pairing/request', async (c) => {
+        if (!ctx.authManager) {
+            return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
+        }
+        const body = (await c.req.json().catch(() => ({})));
+        const result = ctx.authManager.requestPairing(body.deviceName ?? '新设备', requestSource(c));
+        if (!result) {
+            return apiError(c, 429, 'PAIRING_LIMIT', '待审批的配对请求过多，请稍后再试');
+        }
+        return c.json(result);
+    });
+    // 新设备轮询配对审批结果（公开）。
+    app.get('/pairing/status', (c) => {
+        if (!ctx.authManager) {
+            return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
+        }
+        const pairingId = c.req.query('pairingId') ?? '';
+        if (!pairingId)
+            return apiError(c, 400, 'BAD_REQUEST', 'pairingId is required');
+        const status = ctx.authManager.pairingStatus(pairingId);
+        if (status.status === 'not_found') {
+            return apiError(c, 404, 'PAIRING_NOT_FOUND', '配对请求不存在或已过期');
+        }
+        return c.json(status);
+    });
+    // 列出待审批配对（需认证）。
+    app.get('/pairing', (c) => {
+        if (!ctx.authManager) {
+            return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
+        }
+        return c.json({ pairings: ctx.authManager.listPairings() });
+    });
+    // 审批通过（需认证）。
+    app.post('/pairing/approve', async (c) => {
+        if (!ctx.authManager) {
+            return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
+        }
+        const body = (await c.req.json().catch(() => ({})));
+        if (!body.pairingId)
+            return apiError(c, 400, 'BAD_REQUEST', 'pairingId is required');
+        const ok = ctx.authManager.approvePairing(body.pairingId);
+        if (!ok)
+            return apiError(c, 404, 'PAIRING_NOT_FOUND', '配对请求不存在或已过期');
+        return c.json({ ok: true });
+    });
+    // 拒绝配对（需认证）。
+    app.post('/pairing/deny', async (c) => {
+        if (!ctx.authManager) {
+            return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
+        }
+        const body = (await c.req.json().catch(() => ({})));
+        if (!body.pairingId)
+            return apiError(c, 400, 'BAD_REQUEST', 'pairingId is required');
+        const ok = ctx.authManager.denyPairing(body.pairingId);
+        if (!ok)
+            return apiError(c, 404, 'PAIRING_NOT_FOUND', '配对请求不存在或已过期');
+        return c.json({ ok: true });
+    });
+    // 列出已授权设备（需认证；设置页「已授权设备」面板）。
+    app.get('/devices', (c) => {
+        if (!ctx.authManager) {
+            return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
+        }
+        return c.json({ devices: ctx.authManager.listDevices() });
+    });
+    // 撤销设备（需认证）。撤销唯一设备后如需重新注册首设备，请运行 c0de auth reset。
+    app.delete('/devices/:id', async (c) => {
+        if (!ctx.authManager) {
+            return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
+        }
+        const ok = ctx.authManager.revokeDevice(c.req.param('id'));
+        if (!ok)
+            return apiError(c, 404, 'NOT_FOUND', 'Device not found');
+        return c.json({ ok: true });
+    });
+    return app;
+}
+export { createAuthRoute };

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

@@ -1,8 +1,25 @@
 import { Hono } from 'hono';
+import { type SSEStreamingApi } from 'hono/streaming';
 import type { ServerContext } from '../types.js';
-/** 按 session.projectId 解析 agent 工作目录；无项目回退 ctx.cwd。 */
+/** 按 session.projectId / worktreePath 解析 agent 工作目录：
+ *  - 有 projectId → 项目 worktree（缺失/目录失效时抛错，由上层转 409）。
+ *  - 无 projectId（项目已删除后从回收站恢复的会话）→ 用 worktreePath 兜底：
+ *    目录失效同样抛错，绝不静默回退 serve cwd 导致 agent 在错误目录执行工具。
+ *  - 两者皆无（从未绑定项目的会话，如 CLI print）→ 回退 ctx.cwd。 */
 export declare function resolveAgentCwd(ctx: ServerContext, session: {
     projectId: string | null;
+    worktreePath?: string | null;
 }): Promise<string>;
+/**
+ * SSE 心跳间隔。前端有 90s 静默看门狗（web/services/chat.ts），而服务端各
+ * 等待语义远长于此：bash 默认超时 120s、权限确认 5 分钟、子 agent 执行数分钟。
+ * 这些等待期间没有业务事件帧——若无心跳，前端会在 90s 时 abort 连接，
+ * 服务端 stream.onAbort 随即中止 agent，长命令/权限弹窗/多 agent 全部误杀。
+ * 30s 心跳保证看门狗只对「连接真正死亡」（连续 3 个心跳周期无数据）生效。
+ */
+declare const SSE_HEARTBEAT_INTERVAL_MS = 30000;
+/** 启动心跳定时器；返回停止函数（幂等）。流关闭后写入会被吞掉，安全。 */
+declare function startHeartbeat(stream: SSEStreamingApi): () => void;
+export { SSE_HEARTBEAT_INTERVAL_MS, startHeartbeat };
 declare function createChatRoute(ctx: ServerContext): Hono;
 export { createChatRoute };

package/dist/server/routes/chat.js

@@ -1,26 +1,63 @@
+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';
+import { loadConfigScopes, mergeConfig } from '../../core/config.js';
 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 { insertEntry } from '../../session/message.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 { apiError } from '../middleware/error.js';
 import { createInteractivePermissionChecker } from '../permission/interactive.js';
+import { buildRegistryFromConfig } from '../registry-config.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;
+}
+/**
+ * SSE 心跳间隔。前端有 90s 静默看门狗（web/services/chat.ts），而服务端各
+ * 等待语义远长于此：bash 默认超时 120s、权限确认 5 分钟、子 agent 执行数分钟。
+ * 这些等待期间没有业务事件帧——若无心跳，前端会在 90s 时 abort 连接，
+ * 服务端 stream.onAbort 随即中止 agent，长命令/权限弹窗/多 agent 全部误杀。
+ * 30s 心跳保证看门狗只对「连接真正死亡」（连续 3 个心跳周期无数据）生效。
+ */
+const SSE_HEARTBEAT_INTERVAL_MS = 30_000;
+/** 启动心跳定时器；返回停止函数（幂等）。流关闭后写入会被吞掉，安全。 */
+function startHeartbeat(stream) {
+    const timer = setInterval(() => {
+        stream.writeSSE({ event: 'heartbeat', data: '' }).catch(() => { }); // 流已关闭/客户端断开时写入失败，忽略
+    }, SSE_HEARTBEAT_INTERVAL_MS);
+    return () => clearInterval(timer);
 }
+export { SSE_HEARTBEAT_INTERVAL_MS, startHeartbeat };
 function createChatRoute(ctx) {
     const app = new Hono();
     // POST / — SSE 流式聊天
@@ -28,8 +65,25 @@ function createChatRoute(ctx) {
         const body = await c.req.json().catch(() => ({}));
         const sessionId = body.sessionId;
         const message = body.message;
-        if (!sessionId || !message) {
-            return apiError(c, 400, 'BAD_REQUEST', 'sessionId and message are required');
+        const images = body.images;
+        // P1-5：纯图片消息放行（Composer 允许只带图片不带文本），
+        // 仅当文本与图片皆无时拒绝，错误信息说明可操作原因。
+        if (!sessionId || (!message && !images?.length)) {
+            return apiError(c, 400, 'BAD_REQUEST', '消息内容不能为空：请输入文字或附带图片后再发送');
+        }
+        // P0：图片大小/数量服务端限额（前端已限制，此为兜底——API 直调/旧客户端）。
+        if (images) {
+            const MAX_IMAGE_COUNT = 6;
+            const MAX_IMAGE_BYTES = 8 * 1024 * 1024;
+            if (images.length > MAX_IMAGE_COUNT) {
+                return apiError(c, 400, 'TOO_MANY_IMAGES', `最多 ${MAX_IMAGE_COUNT} 张图片（收到 ${images.length} 张）`);
+            }
+            for (const img of images) {
+                if (typeof img.data === 'string' && img.data.length > MAX_IMAGE_BYTES) {
+                    const mb = (img.data.length / (1024 * 1024)).toFixed(1);
+                    return apiError(c, 400, 'IMAGE_TOO_LARGE', `图片大小 ${mb}MB 超过上限 ${MAX_IMAGE_BYTES / (1024 * 1024)}MB`);
+                }
+            }
         }
         let session;
         try {
@@ -41,46 +95,163 @@ function createChatRoute(ctx) {
         if (!session) {
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
         }
+        // P2：会话级权限覆盖持久化在 metadata——重启后从 DB 恢复到内存 Map，
+        // 使 getMode 的「会话覆盖」优先级跨重启成立。
+        if (session.metadata.permissionMode === 'auto' ||
+            session.metadata.permissionMode === 'default') {
+            ctx.sessionPermissionModes.set(sessionId, session.metadata.permissionMode);
+        }
+        // P2：会话级「始终允许」白名单同样持久化于 metadata，checker 经 getter 实时读取
+        // （run 期间用户可追加；此处仅在本会话 Map 尚未加载时注入，已有值优先）。
+        if (!ctx.sessionAlwaysAllow.has(sessionId)) {
+            const list = session.metadata.alwaysAllow;
+            ctx.sessionAlwaysAllow.set(sessionId, Array.isArray(list) ? list.filter((t) => typeof t === 'string') : []);
+        }
         // 提前解析 cwd（slash 拦截与 agent 路径都需使用）
-        const cwd = await resolveAgentCwd(ctx, session);
-        // 斜杠命令拦截
-        const parsed = parseSlashInput(message);
+        // 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);
+        }
+        // P1 多项目配置：会话级配置按会话工作目录解析（该项目 .c0de/config.json 的原始
+        // 作用域合并到服务级配置之上）。此前所有项目共用启动目录配置——在其他项目里
+        // 修改「项目配置」实际写的是启动项目。cwd === ctx.cwd 时直接复用服务级配置。
+        // 权限默认模式单独取原始 project 作用域：项目文件未显式设置时回退运行时全局
+        // 模式（启动默认或 PUT /api/permissions 覆盖），避免启动项目配置泄漏到其他项目。
+        const sessionProjectScope = cwd === ctx.cwd ? undefined : loadConfigScopes(cwd).project;
+        const sessionConfig = sessionProjectScope
+            ? mergeConfig(ctx.config, sessionProjectScope)
+            : ctx.config;
+        const sessionDefaultMode = sessionProjectScope?.permission?.defaultMode;
+        // P1-1：会话项目注册表——项目级配置含 providers 时，按该项目合并配置
+        // 构建/复用 LLM 注册表（否则项目配置的 provider 永远 NoRoute）。
+        // 服务启动目录项目直接复用服务级注册表。
+        let sessionRegistry = ctx.llmRegistry;
+        if (sessionProjectScope && session.projectId) {
+            const pid = session.projectId;
+            const cached = ctx.projectRegistries?.get(pid);
+            if (cached) {
+                sessionRegistry = cached;
+            }
+            else if (sessionConfig.providers.length > 0) {
+                sessionRegistry = buildRegistryFromConfig(sessionConfig);
+                ctx.projectRegistries?.set(pid, sessionRegistry);
+            }
+        }
+        // 斜杠命令拦截（纯图片消息无文本，跳过命令解析）
+        const parsed = parseSlashInput(message ?? '');
         if (parsed) {
             const registry = createSlashRegistry();
             const cmd = registry.get(parsed.name);
             if (cmd) {
+                // P3：变更型命令（清空/压缩/分支直接改写消息树）与活跃 run 的并发
+                // 写入存在竞态——斜杠拦截早于 tryAcquire，须在此显式拒绝。
+                const MUTATING_SLASH = new Set(['compact', 'clear', 'fork']);
+                if (MUTATING_SLASH.has(parsed.name) &&
+                    (ctx.agentManager.get(sessionId) || ctx.agentManager.isStarting(sessionId))) {
+                    return apiError(c, 409, 'RUN_ACTIVE', `该会话已有进行中的对话，请等待完成或中止后再执行 /${parsed.name}`);
+                }
+                // P2-4：执行 config.slashCommands.enabled 过滤（此前该配置无任何消费方）。
+                // enabled 为空 = 全部启用（与 tools.enabled 语义一致）；名称兼容带/不带前缀斜杠。
+                const enabledList = sessionConfig.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,
+                    config: sessionConfig,
+                    // 当前会话 id：/clear /fork 等命令默认作用于当前会话（P2-4）。
+                    sessionId,
+                    // 消费渠道：/model 等命令按渠道给指引（Web 有底部模型选择器）。
+                    channel: 'web',
                     // 内置斜杠命令（/clear、/fork、/config）仅需 db + config；
                     // 但 /workflow run 会走 executeWorkflow → buildWorkflowContext → runSubAgent，
                     // 该路径需要 agentRegistry 来派生子 agent，因此必须注入。
-                    // permission/toolRegistry 用 autoAllow 凑齐类型（子命令不触发交互权限）。
                     workflowRegistry: ctx.workflowRegistry,
                     deps: {
                         db: ctx.db,
-                        config: ctx.config,
+                        config: sessionConfig,
                         cwd,
+                        // P1 工作流权限：占位 checker 在 streamSSE 回调内被替换为交互式
+                        // checker——/workflow run 的子 agent 才能对 ask 工具弹窗确认。
                         permission: autoAllowChecker,
                         toolRegistry: ctx.toolRegistry,
-                        llmRegistry: ctx.llmRegistry,
+                        llmRegistry: sessionRegistry,
                         agentRegistry: ctx.agentRegistry,
                     },
                 };
                 return streamSSE(c, async (stream) => {
+                    const stopHeartbeat = startHeartbeat(stream);
                     try {
-                        const result = await cmd.execute(parsed.args, commandCtx);
+                        // P1 工作流权限：子命令（尤其 /workflow run）的子 agent 继承此 checker。
+                        // 此前用 autoAllowChecker：ask 工具返回 permission_required 结果但无
+                        // 确认通道（confirm 是 no-op），写/执行工具在工作流里静默不可用。
+                        // 现在与主 agent 一致：permission_required 经 SSE 弹窗，用户确认后
+                        // 经 /api/tools/confirm 消费全局 store。
+                        const permissionChecker = createInteractivePermissionChecker(ctx.permissionStore, {
+                            getMode: () => ctx.sessionPermissionModes.get(sessionId) ??
+                                sessionDefaultMode ??
+                                ctx.permissionMode,
+                            alwaysAllow: () => ctx.sessionAlwaysAllow.get(sessionId) ?? [],
+                            onPermissionRequired: async (req) => {
+                                await stream.writeSSE({
+                                    event: 'permission_required',
+                                    data: JSON.stringify({ _tag: 'permission_required', ...req }),
+                                });
+                            },
+                            onPermissionTimeout: (req) => {
+                                stream
+                                    .writeSSE({
+                                    event: 'permission_timeout',
+                                    data: JSON.stringify({ _tag: 'permission_timeout', ...req }),
+                                })
+                                    .catch(() => { });
+                            },
+                            onPermissionExpired: (req) => {
+                                stream
+                                    .writeSSE({
+                                    event: 'permission_expired',
+                                    data: JSON.stringify({ _tag: 'permission_expired', ...req }),
+                                })
+                                    .catch(() => { });
+                            },
+                        });
+                        const streamCommandCtx = {
+                            ...commandCtx,
+                            deps: { ...commandCtx.deps, permission: permissionChecker },
+                        };
+                        const result = await cmd.execute(parsed.args, streamCommandCtx);
                         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 provider = body.provider ?? sessionConfig.defaultProvider;
+                            const model = body.model ?? sessionConfig.defaultModel;
                             const agentConfig = {
                                 provider,
                                 model,
                                 tools: [],
-                                plugins: ctx.config.plugins.enabled,
+                                plugins: sessionConfig.plugins.enabled,
                                 agentName: 'default',
                             };
                             const compactState = await createAgent(session, agentConfig, commandCtx.deps);
@@ -133,13 +304,16 @@ function createChatRoute(ctx) {
                         });
                         await stream.writeSSE({ event: 'done', data: JSON.stringify({ _tag: 'done' }) });
                     }
+                    finally {
+                        stopHeartbeat();
+                    }
                 });
             }
             // 未知斜杠命令：回退为正常消息发给 agent
         }
-        // 构建多模态 user content：文本在前，images（dataURL base64）在后
-        const userContent = [{ _tag: 'text', text: message }];
-        const images = body.images;
+        // 构建多模态 user content：文本在前（可为空串/缺省，纯图片消息），
+        // images（dataURL base64）在后。文本为空时跳过 text part，避免把空文本发给模型。
+        const userContent = message ? [{ _tag: 'text', text: message }] : [];
         if (images?.length) {
             for (const img of images) {
                 userContent.push({ _tag: 'image', mediaType: img.mediaType, data: img.data });
@@ -151,12 +325,18 @@ function createChatRoute(ctx) {
             const valid = mentionedAgents
                 .map((n) => ctx.agentRegistry.get(n))
                 .filter((d) => Boolean(d && d.mode !== 'primary'));
-            if (valid.length > 0) {
-                const names = valid.map((d) => d.name).join(', ');
-                const first = userContent[0];
-                if (first && first._tag === 'text') {
-                    first.text = `[User requested subagent(s): ${names}]\n\n${first.text}`;
-                }
+            // P2：全部无效（拼错/未注册/primary）→ 明确 400，此前静默忽略，用户以为已派发
+            if (valid.length === 0) {
+                return apiError(c, 400, 'INVALID_AGENT_MENTION', `未知或非 subagent 类型的 agent 提及：${mentionedAgents.join(', ')}`);
+            }
+            const names = valid.map((d) => d.name).join(', ');
+            const first = userContent[0];
+            if (first && first._tag === 'text') {
+                first.text = `[User requested subagent(s): ${names}]\n\n${first.text}`;
+            }
+            else {
+                // 纯图片消息：前置文本 part 承载 subagent 指令，避免指令静默丢失
+                userContent.unshift({ _tag: 'text', text: `[User requested subagent(s): ${names}]` });
             }
         }
         // @文件上下文：读取文件内容写入快照，后续 getSessionContext→injectSnapshots 自动注入。
@@ -182,8 +362,41 @@ function createChatRoute(ctx) {
                 }
             }
         }
-        const provider = body.provider ?? ctx.config.defaultProvider;
-        const model = body.model ?? ctx.config.defaultModel;
+        // P1-1：默认 provider/model 按会话项目配置解析（此前用服务启动目录配置，
+        // 其他项目的 defaultProvider 设置被静默忽略）。
+        const provider = body.provider ?? sessionConfig.defaultProvider;
+        const model = body.model ?? sessionConfig.defaultModel;
+        // P0-1 首次运行引导：provider 未配置/未注册时立即返回可操作错误，
+        // 不让错误延迟到 SSE 流内以英文 NoRoute 冒出。前端据此引导用户去设置页。
+        // 注：测试注入 ctx.chatStream 时跳过——测试 registry 空壳不代表生产未配置。
+        // P2-4：区分两种失败——完全没有配置 provider vs 配置了但名字不匹配。
+        if (!ctx.chatStream) {
+            try {
+                resolveRoute(sessionRegistry, provider, model);
+            }
+            catch {
+                const configured = sessionConfig.providers
+                    .map((p) => p.name)
+                    .filter(Boolean)
+                    .join(', ');
+                const hasAny = sessionConfig.providers.length > 0;
+                return apiError(c, 400, hasAny ? 'PROVIDER_NOT_FOUND' : 'NO_PROVIDER_CONFIGURED', hasAny
+                    ? `未找到名为「${provider}」的 AI 服务。已配置：${configured}。` +
+                        '请检查拼写，或前往「设置 → Provider」添加该服务。'
+                    : `未配置可用的 AI 服务（provider: ${provider}）。请前往「设置 → Provider」添加 API 服务并测试连接`, {
+                    provider,
+                    configuredProviders: sessionConfig.providers.map((p) => p.name).filter(Boolean),
+                    ...(configured ? { hint: `已配置：${configured}` } : {}),
+                });
+            }
+            // P2-4：provider 显式声明了模型清单但请求模型不在其中 → 大概率拼写错误。
+            // 未声明清单的 provider（自建网关等）接受任意模型名，不做校验。
+            const providerDef = sessionConfig.providers.find((p) => (p.name || p._tag) === provider);
+            const modelNames = providerDef?.models ? Object.keys(providerDef.models) : undefined;
+            if (modelNames && modelNames.length > 0 && !modelNames.includes(model)) {
+                return apiError(c, 400, 'MODEL_NOT_FOUND', `provider「${provider}」没有名为「${model}」的模型。已配置模型：${modelNames.join(', ')}`, { provider, model, knownModels: modelNames });
+            }
+        }
         // 并发守卫（P0-4）：同步原子占位 tryAcquire（Map has+set 一气呵成、无 await）。
         // 旧实现先 get 检查、真正 register 在 SSE 回调内，两者之间隔多个 await
         // （getLLMSegments、createAgent 等）：双发 POST 在窗口内均通过守卫，后注册
@@ -200,7 +413,8 @@ function createChatRoute(ctx) {
         try {
             // 工具解析（P1-1）：config.tools.enabled 非空时作为默认集；空 = 全部注册工具。
             // disabled 已在 registry 层过滤（createDefaultRegistry），此处兜底。
-            const tools = resolveEnabledToolNames(ctx.toolRegistry, ctx.config, body.tools);
+            // P1 多项目：按会话项目配置解析（此前用启动目录配置）。
+            const tools = resolveEnabledToolNames(ctx.toolRegistry, sessionConfig, body.tools);
             // primary agent 解析（spec: agent-frontend-switching §4.3）
             const agentName = body.agent ?? 'default';
             const agentDef = ctx.agentRegistry.get(agentName);
@@ -238,29 +452,53 @@ function createChatRoute(ctx) {
                 // P0-4：回调从首行起全部纳入 try/finally——createAgent、updateSessionLastRun
                 // 等启动阶段失败同样必须释放占位并补发 error/done（hono 的 stream 包装器
                 // 只 console.error 不善后），不得泄漏占位或让前端卡在 streaming 态。
+                // P0 心跳：长工具执行/权限确认等待期间无业务帧，心跳防前端 90s 看门狗误杀。
+                const stopHeartbeat = startHeartbeat(stream);
                 let doneSent = false;
                 let runStartedAt;
                 try {
-                    // 权限检查器：ask 权限通过 SSE 通知前端，阻塞等待确认
+                    // 权限检查器：ask 权限通过 SSE 通知前端，阻塞等待确认。
+                    // 模式优先级：会话级覆盖（PUT /:sessionId）> 会话项目配置 defaultMode
+                    // > 运行时全局模式（启动默认或 PUT / 覆盖）。
                     const permissionChecker = createInteractivePermissionChecker(ctx.permissionStore, {
-                        getMode: () => ctx.permissionMode,
+                        getMode: () => ctx.sessionPermissionModes.get(sessionId) ?? sessionDefaultMode ?? ctx.permissionMode,
+                        alwaysAllow: () => ctx.sessionAlwaysAllow.get(sessionId) ?? [],
                         onPermissionRequired: async (req) => {
                             await stream.writeSSE({
                                 event: 'permission_required',
                                 data: JSON.stringify({ _tag: 'permission_required', ...req }),
                             });
                         },
+                        // P2-9：确认超时（5 分钟）仅通知前端（pending 保持，重开弹窗不重发消息）
+                        onPermissionTimeout: (req) => {
+                            stream
+                                .writeSSE({
+                                event: 'permission_timeout',
+                                data: JSON.stringify({ _tag: 'permission_timeout', ...req }),
+                            })
+                                .catch(() => { });
+                        },
+                        // P0 双层超时：提示后仍无响应 → 兜底拒绝，SSE 通知前端清理弹窗状态
+                        //（run 已继续，重开弹窗/拒绝按钮均失效，必须显式清理）。
+                        onPermissionExpired: (req) => {
+                            stream
+                                .writeSSE({
+                                event: 'permission_expired',
+                                data: JSON.stringify({ _tag: 'permission_expired', ...req }),
+                            })
+                                .catch(() => { });
+                        },
                     });
                     // cwd 已在斜杠拦截前解析，此处直接复用
                     // 构建 agent 依赖（注入测试用 chatStream）
                     const deps = {
                         db: ctx.db,
-                        llmRegistry: ctx.llmRegistry,
+                        llmRegistry: sessionRegistry,
                         toolRegistry: ctx.toolRegistry,
                         urlRegistry: ctx.urlRegistry,
                         hookRunner: ctx.hookRunner,
                         permission: permissionChecker,
-                        config: ctx.config,
+                        config: sessionConfig,
                         agentRegistry: ctx.agentRegistry,
                         cwd,
                         ...(ctx.chatStream ? { chatStream: ctx.chatStream } : {}),
@@ -269,7 +507,7 @@ function createChatRoute(ctx) {
                         provider,
                         model: resolvedModel,
                         tools: resolvedTools,
-                        plugins: ctx.config.plugins.enabled,
+                        plugins: sessionConfig.plugins.enabled,
                         agentName,
                         ...(agentDef.systemPrompt ? { agentRolePrompt: agentDef.systemPrompt } : {}),
                     };
@@ -284,11 +522,12 @@ function createChatRoute(ctx) {
                         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)) {
+                    if (message && containsWorkflow(message)) {
                         const wfList = ctx.workflowRegistry
                             ? ctx.workflowRegistry.list().map((w) => ({
                                 name: w.meta.name,
@@ -349,6 +588,7 @@ function createChatRoute(ctx) {
                         .catch(() => { });
                 }
                 finally {
+                    stopHeartbeat();
                     // 先从 agentManager 释放（占位与活跃 run 均幂等）：必须最先执行，确保
                     // 客户端断开使 writeSSE reject 时 agent 状态（state/deps/AbortController）
                     // 不会泄漏到 Map（unregister 仅做 Map.delete、不依赖 state，放最前安全）。
@@ -406,8 +646,26 @@ function createChatRoute(ctx) {
     });
     app.post('/steer', async (c) => {
         const body = await c.req.json();
-        return (runStarting(c, body.sessionId) ??
-            c.json({ steered: ctx.agentManager.steer(body.sessionId, body.message) }));
+        const starting = runStarting(c, body.sessionId);
+        if (starting)
+            return starting;
+        const message = typeof body.message === 'string' ? body.message.trim() : '';
+        if (!message)
+            return c.json({ steered: false });
+        const steered = ctx.agentManager.steer(body.sessionId, message);
+        // P0 闭环：steering 持久化为会话条目——用户运行中输入追加指令曾是内存瞬态，
+        // 刷新后彻底丢失；现在与消息同样入史（context 重建时作为 system 消息注入，
+        // 时间线经 /messages 渲染为 user steering 块）。
+        if (steered) {
+            await insertEntry(ctx.db, {
+                sessionId: body.sessionId,
+                tag: 'steering',
+                content: { text: message },
+            }).catch(() => {
+                // 持久化失败不阻塞本轮生效（指令已进入 run 队列）
+            });
+        }
+        return c.json({ steered });
     });
     return app;
 }

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

@@ -1,5 +1,7 @@
 import { Hono } from 'hono';
 import type { ServerContext } from '../types.js';
-/** GET / — 返回内置斜杠命令列表（name/description/argsHint）。 */
-declare function createCommandsRoute(_ctx: ServerContext): Hono;
+/** GET / — 返回内置斜杠命令列表（name/description/argsHint）。
+ *  按 config.slashCommands.enabled 过滤：enabled 为空 = 全部启用；
+ *  否则只返回启用项，保证弹窗发现性 = 可执行性（避免展示必被拒的命令）。 */
+declare function createCommandsRoute(ctx: ServerContext): Hono;
 export { createCommandsRoute };