c0de-agent 1.12.0 → 1.13.0

package/dist/server/routes/chat.js

@@ -5,15 +5,17 @@ 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 { createSlashRegistry, isSlashCommandEnabled, parseSlashInput } from '../../core/slash.js';
 import { injectSteering } from '../../core/steering.js';
 import { buildWorkflowNotice, containsWorkflow } from '../../core/workflow.js';
+import { createWorkflowRegistry, discoverWorkflows, executeWorkflow, resolveWorkflow, workflowSessionTitle, } from '../../core/workflows/index.js';
 import { resolveRoute } from '../../llm/registry.js';
 import { getProject } from '../../project/project.js';
+import { enrichProjectRiskWithGlobal, projectTrustNeeded } from '../../project/trust.js';
 import { insertEntry } from '../../session/message.js';
-import { getLLMSegments, getSession, updateSessionLastRun } from '../../session/session.js';
+import { consumeBudgetPauseMarker, createSession, getLLMSegments, getSession, markUnfinishedTurn, updateSessionLastRun, upgradeTemporarySession, } from '../../session/session.js';
 import { upsertFileSnapshot } from '../../session/snapshot.js';
-import { resolveEnabledToolNames } from '../../tools/index.js';
+import { PROJECT_BOUND_TOOLS, resolveEnabledToolNames } from '../../tools/index.js';
 import { autoAllowChecker } from '../../tools/permission.js';
 import { apiError } from '../middleware/error.js';
 import { createInteractivePermissionChecker } from '../permission/interactive.js';
@@ -49,6 +51,9 @@ export async function resolveAgentCwd(ctx, session) {
  * 服务端 stream.onAbort 随即中止 agent，长命令/权限弹窗/多 agent 全部误杀。
  * 30s 心跳保证看门狗只对「连接真正死亡」（连续 3 个心跳周期无数据）生效。
  */
+/** 权限确认超时兜底拒绝后暂停 run 的暂停原因（区别于用户主动暂停）。
+ *  附重试指引：被拒工具不会自动重试，用户回来后需要知道可以要求 agent 重做。 */
+const PERMISSION_TIMEOUT_PAUSE_REASON = '权限确认超时：该工具已被自动拒绝，对话已暂停。点击「恢复」后可直接要求 agent 重试该工具';
 const SSE_HEARTBEAT_INTERVAL_MS = 30_000;
 /** 启动心跳定时器；返回停止函数（幂等）。流关闭后写入会被吞掉，安全。 */
 function startHeartbeat(stream) {
@@ -58,6 +63,39 @@ function startHeartbeat(stream) {
     return () => clearInterval(timer);
 }
 export { SSE_HEARTBEAT_INTERVAL_MS, startHeartbeat };
+/**
+ * 子 agent run 注册桥接：core 的 registerChildRun → agentManager 槽位。
+ * P1：此前子 run（含后台任务）从不注册，暂停/热更新/删除级联/更新影响面
+ * 全部绕过它们；core 无 agentManager 引用，桥接由 Web 宿主注入。
+ * 返回的注销函数幂等（unregister 对不存在的 key 安全）。
+ */
+export function childRunBridge(manager) {
+    return (run) => {
+        manager.register({
+            sessionId: run.sessionId,
+            parentSessionId: run.parentSessionId,
+            jobId: run.jobId,
+            state: run.state,
+            deps: run.deps,
+        });
+        return () => manager.unregister(run.sessionId);
+    };
+}
+/**
+ * 会话「忙」判定统一口径：活跃 run / tryAcquire 占位（starting）/ 工作流运行期
+ * （发起会话无主 run，busy 映射承载）。变更型操作（fork/compact/clear 等）在斜杠与
+ * REST 双入口共用本判定，防止守卫漂移——REST fork 此前只查 get()，漏 starting
+ * 占位窗口与工作流运行期两种态（斜杠守卫早已覆盖）。
+ */
+export function hasBusySession(ctx, sessionId) {
+    if (ctx.agentManager.get(sessionId))
+        return 'run';
+    if (ctx.agentManager.isStarting(sessionId))
+        return 'starting';
+    if (ctx.workflowBusyBySession.has(sessionId))
+        return 'workflow';
+    return null;
+}
 function createChatRoute(ctx) {
     const app = new Hono();
     // POST / — SSE 流式聊天
@@ -79,9 +117,20 @@ function createChatRoute(ctx) {
                 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`);
+                // P3：按解码字节校验（base64 字符串长度比真实字节约大 33%）；
+                // 无法解码（非法 base64/含 dataURL 前缀等）时按字符串长度保守拦截。
+                if (typeof img.data === 'string') {
+                    let bytes = img.data.length;
+                    try {
+                        bytes = Buffer.from(img.data, 'base64').length;
+                    }
+                    catch {
+                        // 解码失败保留字符串长度兜底
+                    }
+                    if (bytes > MAX_IMAGE_BYTES) {
+                        const mb = (bytes / (1024 * 1024)).toFixed(1);
+                        return apiError(c, 400, 'IMAGE_TOO_LARGE', `图片大小 ${mb}MB 超过上限 ${MAX_IMAGE_BYTES / (1024 * 1024)}MB`);
+                    }
                 }
             }
         }
@@ -95,6 +144,20 @@ function createChatRoute(ctx) {
         if (!session) {
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
         }
+        // P2 修复：拒绝向回收站会话发消息——此前 getSession 不检查 deletedAt，
+        // API 直调可继续向软删除会话写消息，与「删除」心智模型冲突
+        // （CLI --continue 已拒绝，Web API 未对齐）。前端正常流程不会触发（会话 404）。
+        if (session.deletedAt) {
+            return apiError(c, 404, 'NOT_FOUND', '会话不存在或已删除（如需继续对话请先从回收站恢复）');
+        }
+        // P1-3：继续对话的 workflow 会话升级为持久会话——「续接即持久」此前仅
+        // 覆盖 CLI print（upgradeTemporarySession 只被 print --continue 调用），
+        // workflow 会话在 Web 继续追问后仍会被 30 天临时清理移入回收站。
+        if (session.agentType === 'workflow') {
+            await upgradeTemporarySession(ctx.db, sessionId).catch(() => {
+                // 升级失败不阻塞对话（最坏仍按临时会话清理）
+            });
+        }
         // P2：会话级权限覆盖持久化在 metadata——重启后从 DB 恢复到内存 Map，
         // 使 getMode 的「会话覆盖」优先级跨重启成立。
         if (session.metadata.permissionMode === 'auto' ||
@@ -133,6 +196,292 @@ function createChatRoute(ctx) {
             ? mergeConfig(ctx.config, sessionProjectScope)
             : ctx.config;
         const sessionDefaultMode = sessionProjectScope?.permission?.defaultMode;
+        // P0-2 项目信任门禁：未信任项目（或信任后配置漂移）+ 项目作用域原始配置含
+        // 风险项（auto 权限 / timeoutAction=deny 降级 / 启用项目插件 / MCP）→ 409
+        // TRUST_REQUIRED，前端弹窗明示风险，用户显式信任（POST /projects/:id/trust）
+        // 后重发。只评估项目作用域原始配置（全局配置是用户本机显式编辑，天然可信）；
+        // 信任非永久：trustedAt 落盘时附带风险指纹，其后仓库 git pull 新增风险键
+        // （指纹漂移）同样重新触发门禁（P1 信任指纹复检）。
+        if (session.projectId) {
+            const project = await getProject(ctx.db, session.projectId);
+            if (project) {
+                const scopes = loadConfigScopes(cwd);
+                const risks = projectTrustNeeded(scopes.project, scopes.global, project.trustedAt, project.riskFingerprint, project.worktree);
+                if (risks.length > 0) {
+                    // 并入全局配置的权限风险上下文（不改变门禁触发条件）：用户做信任决策时
+                    // 能看到完整生效的权限状态（如全局已 auto），避免「信任了项目却困惑于
+                    // 权限为何仍自动放行」。
+                    const items = enrichProjectRiskWithGlobal(risks, scopes.global);
+                    return apiError(c, 409, 'TRUST_REQUIRED', `项目「${project.name ?? project.worktree}」的项目配置（.c0de/config.json）包含需要你确认的风险项`, { projectId: project.id, projectName: project.name ?? project.worktree, items });
+                }
+            }
+        }
+        // 权限确认超时（双层超时兜底）后的动作：'pause'（默认）拒绝该工具并暂停 run，
+        // 防 default 模式下 agent 在用户缺席时继续自主执行；'deny' 保持旧行为（run 继续）。
+        // 仅显式 'deny' 时选 deny，缺省/非法值一律 pause（安全默认）。
+        const permissionTimeoutAction = sessionConfig.permission.timeoutAction === 'deny' ? 'deny' : 'pause';
+        // 暂停目标：会话自身 run + 其全部子 agent run（/workflow run 路径会话无主 run，
+        // 只有子 agent——仅 pause 主 run 会让子 agent 在用户缺席时继续执行）。
+        // reason 透传给 pauseAgent，使权限超时暂停与用户主动暂停在状态栏可区分。
+        const pauseSessionRun = (reason) => {
+            ctx.agentManager.pause(sessionId, reason);
+            for (const child of ctx.agentManager.children(sessionId)) {
+                ctx.agentManager.pause(child.sessionId, reason);
+            }
+        };
+        // /workflow run 专用执行通道：与 REST POST /api/workflows/:name/run 同口径——
+        // 预算护栏、urlRegistry/hookRunner、agentManager 注册 + 断连 abort、进度 SSE。
+        // 此前经通用 commandCtx.deps 执行：子 agent 预算旁路（P0）、内部 URL 解析失败、
+        // run 游离于 agentManager（不可中止、热更新不可见）。
+        const runWorkflowSlash = async (c, workflowArgs) => {
+            // 并发守卫：主 run 活跃时不允许同会话发起工作流（权限弹窗/预算/终端混淆）。
+            if (ctx.agentManager.get(sessionId) || ctx.agentManager.isStarting(sessionId)) {
+                return apiError(c, 409, 'RUN_ACTIVE', '该会话已有进行中的对话，请等待完成或中止后再运行工作流');
+            }
+            const parts = workflowArgs.split(/\s+/).filter(Boolean);
+            const name = parts[1];
+            if (!name) {
+                return apiError(c, 400, 'BAD_REQUEST', 'Usage: /workflow run <name> [args]');
+            }
+            const wfArgs = parts.slice(2).join(' ');
+            const registry = ctx.workflowRegistry ?? createWorkflowRegistry();
+            // 统一解析：项目级（已信任）> 用户 > 内置。仅在会话已绑定项目时发现
+            // 项目级工作流——聊天门禁已保证该项目可信且指纹未漂移；孤儿会话
+            // （无 projectId）不再按 cwd 无条件发现：其目录未注册、信任状态未知，
+            // 此前会在未信任仓库直接 dynamic import 其工作流代码。
+            let entry = ctx.workflowRegistry?.get(name);
+            if (session.projectId) {
+                entry =
+                    (await resolveWorkflow({
+                        name,
+                        registry,
+                        projectDir: cwd,
+                        projectTrusted: true,
+                    })) ?? entry;
+            }
+            if (!entry) {
+                // 错误提示里列出可用工作流：仅在会话绑定项目（门禁已通过）时发现
+                // 项目级——与上方解析同口径，不因「拼错名字」在未信任目录执行仓库代码。
+                const discovered = session.projectId ? await discoverWorkflows(cwd) : [];
+                const available = [
+                    ...registry.list().map((e) => e.meta.name),
+                    ...discovered.map((e) => e.meta.name),
+                ].join(', ');
+                return streamSSE(c, async (stream) => {
+                    await stream.writeSSE({
+                        event: 'text_delta',
+                        data: JSON.stringify({
+                            _tag: 'text_delta',
+                            text: `未知工作流："${name}"。可用：${available || '(无)'}`,
+                        }),
+                    });
+                    await stream.writeSSE({ event: 'done', data: JSON.stringify({ _tag: 'done' }) });
+                });
+            }
+            // 并发守卫（同步原子占位）：执行作用域 = 项目或目录。此前
+            // tryAcquire(workflowSession.id) 作用在刚创建的全新会话 id 上（永真），且主会话
+            // 在整段工作流期间不注册任何 run——双发 /workflow run、REST 与斜杠并行都能
+            // 并发执行。现在同一作用域仅允许一个工作流运行。
+            const scopeKey = session.projectId ? `project:${session.projectId}` : `dir:${cwd}`;
+            if (ctx.workflowBusyByScope.has(scopeKey)) {
+                return apiError(c, 409, 'RUN_ACTIVE', '该项目/目录已有进行中的工作流执行，请等待完成或中止后重试');
+            }
+            ctx.workflowBusyByScope.set(scopeKey, '');
+            // 工作流运行会话：绑定当前会话项目 + worktree（与 REST 路由同口径），
+            // 标题带时间戳区分多次运行。
+            let workflowSession;
+            try {
+                workflowSession = await createSession(ctx.db, workflowSessionTitle(name), session.projectId ?? undefined, 'workflow', undefined, undefined, cwd, 
+                // 中断恢复指引需要工作流名（重启后会话内无 user 消息可重发）。
+                { workflowName: name });
+            }
+            catch (e) {
+                ctx.workflowBusyByScope.delete(scopeKey);
+                throw e;
+            }
+            ctx.workflowBusyByScope.set(scopeKey, workflowSession.id);
+            // 发起会话在工作流运行期间视为占用：普通消息 409；控制端点据此路由到工作流 run。
+            ctx.workflowBusyBySession.set(sessionId, workflowSession.id);
+            const releaseWorkflowBusy = () => {
+                if (ctx.workflowBusyByScope.get(scopeKey) === workflowSession.id) {
+                    ctx.workflowBusyByScope.delete(scopeKey);
+                }
+                if (ctx.workflowBusyBySession.get(sessionId) === workflowSession.id) {
+                    ctx.workflowBusyBySession.delete(sessionId);
+                }
+            };
+            if (!ctx.agentManager.tryAcquire(workflowSession.id)) {
+                releaseWorkflowBusy();
+                return apiError(c, 409, 'RUN_ACTIVE', '该工作流会话已有进行中的执行');
+            }
+            // 持久化 run 状态：运行中 → completed。服务崩溃时停留在 running，
+            // 重启后 /:id/status 据此识别为 interrupted（此前工作流 run 不写 lastRun）。
+            const startedAtMs = Date.now();
+            await updateSessionLastRun(ctx.db, workflowSession.id, {
+                status: 'running',
+                startedAt: startedAtMs,
+            }).catch(() => { });
+            let handedOff = false;
+            try {
+                const response = streamSSE(c, async (stream) => {
+                    const stopHeartbeat = startHeartbeat(stream);
+                    try {
+                        const permissionChecker = createInteractivePermissionChecker(ctx.permissionStore, {
+                            getMode: () => ctx.sessionPermissionModes.get(sessionId) ??
+                                sessionDefaultMode ??
+                                ctx.permissionMode,
+                            alwaysAllow: () => ctx.sessionAlwaysAllow.get(sessionId) ?? [],
+                            // 子 agent 的 ask 请求统一归属到用户所在的会话（而非各自子会话），
+                            // 刷新/切换页面后按当前会话即可重挂挂起弹窗。
+                            reportSessionId: 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,
+                                        timeoutAction: permissionTimeoutAction,
+                                    }),
+                                })
+                                    .catch(() => { });
+                            },
+                            onPermissionExpired: (req) => {
+                                if (permissionTimeoutAction === 'pause') {
+                                    // P1 级联暂停：与主 chat 通道 pauseSessionRun 同口径——
+                                    // 仅暂停父 run 会让子 agent 在用户缺席时继续执行。
+                                    ctx.agentManager.pause(workflowSession.id, PERMISSION_TIMEOUT_PAUSE_REASON);
+                                    for (const child of ctx.agentManager.children(workflowSession.id)) {
+                                        ctx.agentManager.pause(child.sessionId, PERMISSION_TIMEOUT_PAUSE_REASON);
+                                    }
+                                }
+                                stream
+                                    .writeSSE({
+                                    event: 'permission_expired',
+                                    data: JSON.stringify({
+                                        _tag: 'permission_expired',
+                                        ...req,
+                                        timeoutAction: permissionTimeoutAction,
+                                    }),
+                                })
+                                    .catch(() => { });
+                            },
+                        });
+                        const deps = {
+                            db: ctx.db,
+                            llmRegistry: sessionRegistry,
+                            toolRegistry: ctx.toolRegistry,
+                            urlRegistry: ctx.urlRegistry,
+                            hookRunner: ctx.hookRunner,
+                            permission: permissionChecker,
+                            config: sessionConfig,
+                            cwd,
+                            agentRegistry: ctx.agentRegistry,
+                            registerChildRun: childRunBridge(ctx.agentManager),
+                            // 预算护栏：与主 chat 路由同口径（金额/token 任一轴 pause/abort 即启用）。
+                            ...(sessionConfig.usage?.budgetAction === 'pause' ||
+                                sessionConfig.usage?.budgetAction === 'abort' ||
+                                sessionConfig.usage?.tokenBudgetAction === 'pause' ||
+                                sessionConfig.usage?.tokenBudgetAction === 'abort'
+                                ? { budgetPause: true }
+                                : {}),
+                        };
+                        // P2-5：runner 的工具集不再恒 []——传配置解析结果作为子 agent
+                        // 工具集的交集基准（与主 chat/CLI print 同口径）。config.tools.enabled
+                        // 的 fail-closed 语义对工作流派发的子 agent 成立（全禁 → 交集为空）。
+                        // runner 自身不进 agentLoop，工具名单不产生任何 LLM 调用影响。
+                        const agentConfig = {
+                            provider: sessionConfig.defaultProvider,
+                            model: sessionConfig.defaultModel,
+                            tools: resolveEnabledToolNames(ctx.toolRegistry, sessionConfig).filter((n) => Boolean(session.projectId) || !PROJECT_BOUND_TOOLS.has(n)),
+                            plugins: sessionConfig.plugins.enabled,
+                            agentName: 'default',
+                        };
+                        const parent = await createAgent(workflowSession, agentConfig, deps);
+                        ctx.agentManager.register({ sessionId: workflowSession.id, state: parent, deps });
+                        stream.onAbort(() => {
+                            ctx.agentManager.abort(workflowSession.id);
+                        });
+                        const result = await executeWorkflow({
+                            registry,
+                            name,
+                            entry,
+                            args: wfArgs,
+                            deps,
+                            parent,
+                            onProgress: async (progressMessage, detail) => {
+                                await stream.writeSSE({
+                                    event: 'progress',
+                                    data: JSON.stringify({ _tag: 'progress', message: progressMessage, detail }),
+                                });
+                            },
+                        });
+                        if (result._tag === 'error') {
+                            await stream.writeSSE({
+                                event: 'error',
+                                data: JSON.stringify({
+                                    _tag: 'error',
+                                    error: { _tag: 'unexpected', message: result.message },
+                                }),
+                            });
+                        }
+                        else {
+                            // executeWorkflow 只产出 text/error（success/compact 是斜杠命令泛型变体，不会到达）
+                            const text = result._tag === 'text'
+                                ? result.text
+                                : result._tag === 'success'
+                                    ? result.message
+                                    : '';
+                            await stream.writeSSE({
+                                event: 'text_delta',
+                                data: JSON.stringify({ _tag: 'text_delta', text }),
+                            });
+                        }
+                        await stream.writeSSE({ event: 'done', data: JSON.stringify({ _tag: 'done' }) });
+                    }
+                    catch (e) {
+                        await stream
+                            .writeSSE({
+                            event: 'error',
+                            data: JSON.stringify({
+                                _tag: 'error',
+                                error: {
+                                    _tag: 'unexpected',
+                                    message: e instanceof Error ? e.message : String(e),
+                                },
+                            }),
+                        })
+                            .catch(() => { });
+                        await stream
+                            .writeSSE({ event: 'done', data: JSON.stringify({ _tag: 'done' }) })
+                            .catch(() => { });
+                    }
+                    finally {
+                        stopHeartbeat();
+                        ctx.agentManager.unregister(workflowSession.id);
+                        void updateSessionLastRun(ctx.db, workflowSession.id, {
+                            status: 'completed',
+                            startedAt: startedAtMs,
+                        }).catch(() => { });
+                        releaseWorkflowBusy();
+                    }
+                });
+                handedOff = true;
+                return response;
+            }
+            finally {
+                if (!handedOff) {
+                    ctx.agentManager.unregister(workflowSession.id);
+                    releaseWorkflowBusy();
+                }
+            }
+        };
         // P1-1：会话项目注册表——项目级配置含 providers 时，按该项目合并配置
         // 构建/复用 LLM 注册表（否则项目配置的 provider 永远 NoRoute）。
         // 服务启动目录项目直接复用服务级注册表。
@@ -156,16 +505,14 @@ function createChatRoute(ctx) {
             if (cmd) {
                 // P3：变更型命令（清空/压缩/分支直接改写消息树）与活跃 run 的并发
                 // 写入存在竞态——斜杠拦截早于 tryAcquire，须在此显式拒绝。
+                // 守卫口径统一为 hasBusySession（get + isStarting + workflowBusy）。
                 const MUTATING_SLASH = new Set(['compact', 'clear', 'fork']);
-                if (MUTATING_SLASH.has(parsed.name) &&
-                    (ctx.agentManager.get(sessionId) || ctx.agentManager.isStarting(sessionId))) {
+                if (MUTATING_SLASH.has(parsed.name) && hasBusySession(ctx, 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)) {
+                // enabled 为空 = 全部禁用（fail-closed）；含 ['*'] = 全部启用；名称兼容带/不带前缀斜杠。
+                if (!isSlashCommandEnabled(sessionConfig.slashCommands?.enabled, parsed.name)) {
                     return streamSSE(c, async (stream) => {
                         await stream.writeSSE({
                             event: 'text_delta',
@@ -177,6 +524,11 @@ function createChatRoute(ctx) {
                         await stream.writeSSE({ event: 'done', data: JSON.stringify({ _tag: 'done' }) });
                     });
                 }
+                // /workflow run 走专用通道（预算/URL 注册表/agentManager 生命周期与 REST 同口径）；
+                // 其余 workflow 子命令（list/show/create/edit）继续走通用 commandCtx。
+                if (parsed.name === 'workflow' && /^run(?:\s|$)/.test(parsed.args.trim())) {
+                    return runWorkflowSlash(c, parsed.args.trim());
+                }
                 const commandCtx = {
                     cwd,
                     config: sessionConfig,
@@ -197,7 +549,17 @@ function createChatRoute(ctx) {
                         permission: autoAllowChecker,
                         toolRegistry: ctx.toolRegistry,
                         llmRegistry: sessionRegistry,
+                        urlRegistry: ctx.urlRegistry,
+                        hookRunner: ctx.hookRunner,
                         agentRegistry: ctx.agentRegistry,
+                        registerChildRun: childRunBridge(ctx.agentManager),
+                        // 预算护栏：/compact 的压缩 LLM 调用与子 agent 同样受护栏约束。
+                        ...(sessionConfig.usage?.budgetAction === 'pause' ||
+                            sessionConfig.usage?.budgetAction === 'abort' ||
+                            sessionConfig.usage?.tokenBudgetAction === 'pause' ||
+                            sessionConfig.usage?.tokenBudgetAction === 'abort'
+                            ? { budgetPause: true }
+                            : {}),
                     },
                 };
                 return streamSSE(c, async (stream) => {
@@ -213,6 +575,9 @@ function createChatRoute(ctx) {
                                 sessionDefaultMode ??
                                 ctx.permissionMode,
                             alwaysAllow: () => ctx.sessionAlwaysAllow.get(sessionId) ?? [],
+                            // 子 agent 的 ask 请求统一归属到用户所在的会话（而非各自子会话），
+                            // 刷新/切换页面后按当前会话即可重挂挂起弹窗。
+                            reportSessionId: sessionId,
                             onPermissionRequired: async (req) => {
                                 await stream.writeSSE({
                                     event: 'permission_required',
@@ -223,15 +588,27 @@ function createChatRoute(ctx) {
                                 stream
                                     .writeSSE({
                                     event: 'permission_timeout',
-                                    data: JSON.stringify({ _tag: 'permission_timeout', ...req }),
+                                    data: JSON.stringify({
+                                        _tag: 'permission_timeout',
+                                        ...req,
+                                        timeoutAction: permissionTimeoutAction,
+                                    }),
                                 })
                                     .catch(() => { });
                             },
                             onPermissionExpired: (req) => {
+                                // P1-1：timeoutAction='pause' 时拒绝并暂停（主 run + 子 agent），
+                                // 不让 agent 在用户缺席时继续自主推进；'deny' 时仅拒绝、run 继续。
+                                if (permissionTimeoutAction === 'pause')
+                                    pauseSessionRun(PERMISSION_TIMEOUT_PAUSE_REASON);
                                 stream
                                     .writeSSE({
                                     event: 'permission_expired',
-                                    data: JSON.stringify({ _tag: 'permission_expired', ...req }),
+                                    data: JSON.stringify({
+                                        _tag: 'permission_expired',
+                                        ...req,
+                                        timeoutAction: permissionTimeoutAction,
+                                    }),
                                 })
                                     .catch(() => { });
                             },
@@ -325,9 +702,12 @@ function createChatRoute(ctx) {
             const valid = mentionedAgents
                 .map((n) => ctx.agentRegistry.get(n))
                 .filter((d) => Boolean(d && d.mode !== 'primary'));
-            // P2：全部无效（拼错/未注册/primary）→ 明确 400，此前静默忽略，用户以为已派发
-            if (valid.length === 0) {
-                return apiError(c, 400, 'INVALID_AGENT_MENTION', `未知或非 subagent 类型的 agent 提及：${mentionedAgents.join(', ')}`);
+            // P3-10 修复：部分无效也显式 400——此前仅全无效报错，拼错 1 个时该提及
+            // 被静默丢弃、用户以为已派发。列出全部无效名，供用户修正后重发。
+            const validNames = new Set(valid.map((d) => d.name));
+            const invalid = mentionedAgents.filter((n) => !validNames.has(n));
+            if (invalid.length > 0) {
+                return apiError(c, 400, 'INVALID_AGENT_MENTION', `未知或非 subagent 类型的 agent 提及：${invalid.join(', ')}`);
             }
             const names = valid.map((d) => d.name).join(', ');
             const first = userContent[0];
@@ -397,6 +777,12 @@ function createChatRoute(ctx) {
                 return apiError(c, 400, 'MODEL_NOT_FOUND', `provider「${provider}」没有名为「${model}」的模型。已配置模型：${modelNames.join(', ')}`, { provider, model, knownModels: modelNames });
             }
         }
+        // 对称并发守卫：该会话的工作流运行期间不允许发起普通对话（与 /workflow run
+        // 侧「主 run 活跃时拒绝工作流」互斥）；工作流进度在其运行会话中可见。
+        // 控制端点（abort/pause/resume）经 workflowBusyBySession 路由到工作流 run。
+        if (ctx.workflowBusyBySession.has(sessionId)) {
+            return apiError(c, 409, 'RUN_ACTIVE', '该会话有进行中的工作流执行（进度见工作流运行会话），请等待完成或中止后重试');
+        }
         // 并发守卫（P0-4）：同步原子占位 tryAcquire（Map has+set 一气呵成、无 await）。
         // 旧实现先 get 检查、真正 register 在 SSE 回调内，两者之间隔多个 await
         // （getLLMSegments、createAgent 等）：双发 POST 在窗口内均通过守卫，后注册
@@ -411,18 +797,23 @@ function createChatRoute(ctx) {
         // （其 finally 负责幂等释放），移交前的全部路径在 finally 统一兜底释放。
         let handedOff = false;
         try {
-            // 工具解析（P1-1）：config.tools.enabled 非空时作为默认集；空 = 全部注册工具。
-            // disabled 已在 registry 层过滤（createDefaultRegistry），此处兜底。
+            // 工具解析（P1-1）：config.tools.enabled 含 '*' = 全部注册工具；空 = 无工具（fail-closed）；
+            // 非空名单 = 默认集。disabled 已在 registry 层过滤，此处兜底。
             // P1 多项目：按会话项目配置解析（此前用启动目录配置）。
-            const tools = resolveEnabledToolNames(ctx.toolRegistry, sessionConfig, body.tools);
+            // 无项目会话（projectId null/undefined）剔除项目绑定工具（kanban 等）
+            const sessionHasProject = Boolean(session.projectId);
+            const tools = resolveEnabledToolNames(ctx.toolRegistry, sessionConfig, body.tools).filter((n) => sessionHasProject || !PROJECT_BOUND_TOOLS.has(n));
             // 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;
+            // agent def 覆盖：tools（plan 限只读）、model（可选）。
+            // P1 修复：def.tools 与配置解析结果取交集——此前完全覆盖会绕过
+            // config.tools.enabled 的 fail-closed 语义（禁用 bash 后切到 plan agent
+            // 又静默恢复）。def 未声明 tools 时原样沿用配置解析结果。
+            const resolvedTools = agentDef.tools ? agentDef.tools.filter((t) => tools.includes(t)) : tools;
             const resolvedModel = agentDef.model ?? model;
             // 分段预检：切换 provider/model/tools 将开新段（前缀失效→缓存 miss），
             // 需用户显式确认（confirmSegmentBreak）。首轮无活跃段时跳过。
@@ -439,7 +830,7 @@ function createChatRoute(ctx) {
                 const agentDiffer = (active.agentName ?? 'default') !== agentName;
                 const confirmed = body.confirmSegmentBreak === true;
                 if ((modelDiffer || toolsDiffer || agentDiffer) && !confirmed) {
-                    return apiError(c, 409, 'SEGMENT_BREAK_REQUIRED', '切换模型/工具将开始新的上下文段（缓存失效），需用户确认', {
+                    return apiError(c, 409, 'SEGMENT_BREAK_REQUIRED', '切换模型/工具将开始新的上下文段：此前的对话内容需要重新读取，需用户确认', {
                         activeSegment: {
                             provider: active.provider,
                             model: active.model,
@@ -457,12 +848,20 @@ function createChatRoute(ctx) {
                 let doneSent = false;
                 let runStartedAt;
                 try {
+                    // M3：上轮 run 未正常结束（崩溃/重启/热更新交接，lastRun 仍为
+                    // running/paused）→ 把最后一条 user 消息之后的半截条目标记为
+                    // 「未完成轮次」：构建上下文时剔除、时间线置灰。必须先于
+                    // runAgent（其内部 append 新 user 消息）执行，保证边界判定正确。
+                    await markUnfinishedTurn(ctx.db, sessionId).catch(() => { });
                     // 权限检查器：ask 权限通过 SSE 通知前端，阻塞等待确认。
                     // 模式优先级：会话级覆盖（PUT /:sessionId）> 会话项目配置 defaultMode
                     // > 运行时全局模式（启动默认或 PUT / 覆盖）。
                     const permissionChecker = createInteractivePermissionChecker(ctx.permissionStore, {
                         getMode: () => ctx.sessionPermissionModes.get(sessionId) ?? sessionDefaultMode ?? ctx.permissionMode,
                         alwaysAllow: () => ctx.sessionAlwaysAllow.get(sessionId) ?? [],
+                        // 子 agent 的 ask 请求统一归属到用户所在的会话（而非各自子会话），
+                        // 刷新/切换页面后按当前会话即可重挂挂起弹窗。
+                        reportSessionId: sessionId,
                         onPermissionRequired: async (req) => {
                             await stream.writeSSE({
                                 event: 'permission_required',
@@ -474,17 +873,27 @@ function createChatRoute(ctx) {
                             stream
                                 .writeSSE({
                                 event: 'permission_timeout',
-                                data: JSON.stringify({ _tag: 'permission_timeout', ...req }),
+                                data: JSON.stringify({
+                                    _tag: 'permission_timeout',
+                                    ...req,
+                                    timeoutAction: permissionTimeoutAction,
+                                }),
                             })
                                 .catch(() => { });
                         },
                         // P0 双层超时：提示后仍无响应 → 兜底拒绝，SSE 通知前端清理弹窗状态
                         //（run 已继续，重开弹窗/拒绝按钮均失效，必须显式清理）。
                         onPermissionExpired: (req) => {
+                            if (permissionTimeoutAction === 'pause')
+                                pauseSessionRun(PERMISSION_TIMEOUT_PAUSE_REASON);
                             stream
                                 .writeSSE({
                                 event: 'permission_expired',
-                                data: JSON.stringify({ _tag: 'permission_expired', ...req }),
+                                data: JSON.stringify({
+                                    _tag: 'permission_expired',
+                                    ...req,
+                                    timeoutAction: permissionTimeoutAction,
+                                }),
                             })
                                 .catch(() => { });
                         },
@@ -500,7 +909,18 @@ function createChatRoute(ctx) {
                         permission: permissionChecker,
                         config: sessionConfig,
                         agentRegistry: ctx.agentRegistry,
+                        registerChildRun: childRunBridge(ctx.agentManager),
                         cwd,
+                        // P3 成本护栏：会话项目配置任一轴动作为 'pause'/'abort' 时启用预算检查。
+                        // 具体 pause/abort 由 budgetOverageParts 按超支轴配置动作判定（abort >
+                        // pause），此处仅注入「启用」门禁——修 P1 双轴动作坍缩（此前 pause 分支
+                        // 优先，金额=abort+token=pause 等混合配置被静默降级为暂停）。
+                        ...(sessionConfig.usage?.budgetAction === 'pause' ||
+                            sessionConfig.usage?.budgetAction === 'abort' ||
+                            sessionConfig.usage?.tokenBudgetAction === 'pause' ||
+                            sessionConfig.usage?.tokenBudgetAction === 'abort'
+                            ? { budgetPause: true }
+                            : {}),
                         ...(ctx.chatStream ? { chatStream: ctx.chatStream } : {}),
                     };
                     const agentConfig = {
@@ -512,6 +932,12 @@ function createChatRoute(ctx) {
                         ...(agentDef.systemPrompt ? { agentRolePrompt: agentDef.systemPrompt } : {}),
                     };
                     const state = await createAgent(session, agentConfig, deps);
+                    // P2-3：热更新/重启后 run 重建，内存 budgetPauseTriggered 丢失——从会话
+                    // metadata 消费上次预算暂停标记还原（单次语义），避免用户已确认继续后
+                    // 又被同一超支原因二次暂停。
+                    const priorBudgetPause = await consumeBudgetPauseMarker(ctx.db, sessionId).catch(() => null);
+                    if (priorBudgetPause)
+                        state.budgetPauseTriggered = true;
                     // 持久化 run 状态：status='running' 写入 DB。服务重启后此字段仍为 'running'
                     // 而进程无活跃 run → 检测为 interrupted。finally 中标记 'completed'。
                     runStartedAt = Date.now();
@@ -634,15 +1060,41 @@ function createChatRoute(ctx) {
         : undefined;
     app.post('/abort', async (c) => {
         const { sessionId } = await c.req.json();
+        // 工作流运行期间发起会话无主 run：中止请求路由到实际的工作流 run。
+        const busyWorkflowId = ctx.workflowBusyBySession.get(sessionId);
+        if (busyWorkflowId) {
+            return c.json({ aborted: ctx.agentManager.abort(busyWorkflowId) });
+        }
         return runStarting(c, sessionId) ?? c.json({ aborted: ctx.agentManager.abort(sessionId) });
     });
     app.post('/pause', async (c) => {
         const { sessionId } = await c.req.json();
-        return runStarting(c, sessionId) ?? c.json({ paused: ctx.agentManager.pause(sessionId) });
+        // 级联子 run（P1：子 agent 现已注册，暂停主 run 必须一并暂停——
+        // 否则后台子 agent 在用户认为「已暂停」时继续执行）。
+        const busyWorkflowId = ctx.workflowBusyBySession.get(sessionId);
+        const targetId = busyWorkflowId ?? sessionId;
+        if (!busyWorkflowId && runStarting(c, sessionId))
+            return runStarting(c, sessionId);
+        const paused = ctx.agentManager.pause(targetId);
+        for (const child of ctx.agentManager.children(targetId)) {
+            ctx.agentManager.pause(child.sessionId);
+        }
+        return c.json({ paused });
     });
     app.post('/resume', async (c) => {
         const { sessionId } = await c.req.json();
-        return runStarting(c, sessionId) ?? c.json({ resumed: ctx.agentManager.resume(sessionId) });
+        // 权限超时暂停工作流后，发起会话展示「恢复」按钮——路由到工作流 run 真正恢复。
+        // 级联恢复子 run：暂停时子 run 一并暂停，仅恢复主 run 会让父的工具批次
+        // 永远等待已暂停的子 agent（死锁）。
+        const busyWorkflowId = ctx.workflowBusyBySession.get(sessionId);
+        const targetId = busyWorkflowId ?? sessionId;
+        if (!busyWorkflowId && runStarting(c, sessionId))
+            return runStarting(c, sessionId);
+        const resumed = ctx.agentManager.resume(targetId);
+        for (const child of ctx.agentManager.children(targetId)) {
+            ctx.agentManager.resume(child.sessionId);
+        }
+        return c.json({ resumed });
     });
     app.post('/steer', async (c) => {
         const body = await c.req.json();
@@ -652,7 +1104,10 @@ function createChatRoute(ctx) {
         const message = typeof body.message === 'string' ? body.message.trim() : '';
         if (!message)
             return c.json({ steered: false });
-        const steered = ctx.agentManager.steer(body.sessionId, message);
+        // P1 工作流路由：工作流运行期间 steer 目标为实际的 workflow run
+        //（此前 steer 恒 false、指令静默丢失，用户以为已生效）。
+        const busyWorkflowId = ctx.workflowBusyBySession.get(body.sessionId);
+        const steered = ctx.agentManager.steer(busyWorkflowId ?? body.sessionId, message);
         // P0 闭环：steering 持久化为会话条目——用户运行中输入追加指令曾是内存瞬态，
         // 刷新后彻底丢失；现在与消息同样入史（context 重建时作为 system 消息注入，
         // 时间线经 /messages 渲染为 user steering 块）。