c0de-agent 1.13.0 → 1.14.0

package/dist/project/project.js

@@ -1,5 +1,5 @@
 import { basename } from 'node:path';
-import { eq } from 'drizzle-orm';
+import { and, eq, isNull } from 'drizzle-orm';
 import { loadConfigScopes } from '../core/config.js';
 import { kanbanBoards, projects, sessions } from '../db/schema.js';
 import { resolveProject } from './resolve.js';
@@ -57,8 +57,8 @@ export async function fromDirectory(handle, directory) {
     return result;
 }
 /**
- * 合并同 worktree 下 id ≠ canonicalId 的项目记录：迁移其会话到 canonicalId 后删除。
- * 清理因 id 漂移（remote 变更）产生的历史重复项目，使列表不再出现同名重复项，
+ * 合并同 worktree 下 id ≠ canonicalId 的项目记录：迁移其会话（与看板）到 canonicalId
+ * 后删除。清理因 id 漂移（remote 变更）产生的历史重复项目，使列表不再出现同名重复项，
  * 也让挂在漂移 id 上的会话重新归属规范项目。
  */
 async function mergeDuplicateProjects(handle, canonicalId, worktree) {
@@ -70,9 +70,56 @@ async function mergeDuplicateProjects(handle, canonicalId, worktree) {
             .update(sessions)
             .set({ projectId: canonicalId })
             .where(eq(sessions.projectId, dup.id));
+        await adoptKanbanBoard(handle, dup, canonicalId);
         await handle.db.delete(projects).where(eq(projects.id, dup.id));
     }
 }
+/**
+ * 把漂移项目的活动看板随会话一起迁到规范项目。看板（及其卡片）必须显式处理——
+ * 删除项目行后 FK `kanban_boards.project_id` 是 set null：留着不管会得到
+ * 「projectId 为 null 且 deletedAt 也为 null」的孤儿看板，任何项目视图都查不到它
+ * （createKanbanStore 按 projectId 查、看板回收站只列已软删），卡片静默消失且
+ * 无任何恢复入口——同口径缺陷在 relocateProject 与 DELETE /api/projects/:id 早已修掉，
+ * 只有本路径漏了。
+ *
+ * 规范项目已有活动看板时（uq_kanban_boards_project 唯一约束不允许两块并存）不覆盖
+ * 用户现有看板：把漂移看板软删进回收站并记录原项目名/目录，用户可在看板回收站里
+ * 用「合并恢复」把卡片并回现有看板（与项目删除路径同口径的可恢复语义）。
+ */
+async function adoptKanbanBoard(handle, 
+/** 漂移项目（原始 DB 行或 Project 均可，仅取 id/name/worktree）。 */
+from, toProjectId) {
+    const [board] = await handle.db
+        .select({ id: kanbanBoards.id })
+        .from(kanbanBoards)
+        .where(and(eq(kanbanBoards.projectId, from.id), isNull(kanbanBoards.deletedAt)))
+        .limit(1);
+    if (!board)
+        return;
+    const [existing] = await handle.db
+        .select({ id: kanbanBoards.id })
+        .from(kanbanBoards)
+        .where(and(eq(kanbanBoards.projectId, toProjectId), isNull(kanbanBoards.deletedAt)))
+        .limit(1);
+    if (!existing) {
+        await handle.db
+            .update(kanbanBoards)
+            .set({ projectId: toProjectId, updatedAt: new Date() })
+            .where(eq(kanbanBoards.id, board.id));
+        return;
+    }
+    await handle.db
+        .update(kanbanBoards)
+        .set({
+        deletedAt: new Date(),
+        deletedProjectName: from.name ?? from.worktree,
+        deletedProjectWorktree: from.worktree,
+        // 恢复后重删须重新经历「到期 → 宽限」周期（与 softDeleteKanbanBoard 同口径）
+        purgePendingAt: null,
+        updatedAt: new Date(),
+    })
+        .where(eq(kanbanBoards.id, board.id));
+}
 export async function listProjects(handle) {
     const rows = await handle.db.select().from(projects);
     return rows.map(rowToProject);

package/dist/project/resolve.d.ts

@@ -16,6 +16,12 @@ export declare function getGitStatus(cwd: string): Record<string, GitStatusCode>
  * 只检查当前展开目录的直接子项（通常 10-50 个），不递归进 node_modules 等。
  * 非 git 仓库或无忽略文件时返回空集。
  *
+ * 路径经 `--` 传入：它们是**位置参数**，以 `-` 开头的合法文件名（-v / --stdin
+ * 等）否则会被 git 当成 check-ignore 自己的选项——`-v` 变 verbose（输出
+ * `.gitignore:1:path` 形态的行，解析端无法匹配任何路径）、`--stdin` 改从标准
+ * 输入读路径（无输入 → 空集），该目录的忽略标记整体静默失效。与分支名注入
+ * （checkoutGitBranch 的 -B<name>）同类：用户可控值不得落进选项槽。
+ *
  * 注意：git check-ignore 在「无路径被忽略」或「非 git 仓库」时退出码为 1，
  * 这两种情况都返回空集。 */
 export declare function checkIgnored(cwd: string, paths: string[]): Set<string>;
@@ -64,6 +70,7 @@ export interface GitBranchInfo {
  * 列出本地分支及当前分支标记（非 git 仓库返回 null）。
  */
 export declare function listGitBranches(cwd: string): GitBranchInfo[] | null;
+export declare function isValidBranchName(name: string): boolean;
 /**
  * 切换到指定分支（git checkout）。成功返回分支名，失败返回 error。
  */

package/dist/project/resolve.js

@@ -64,10 +64,15 @@ export function getGitStatus(cwd) {
         const xy = token.slice(0, 2);
         const code = classifyStatus(xy);
         const isRename = xy[0] === 'R' || xy[0] === 'C';
-        // 重命名/复制："XY oldpath\0newpath"，状态挂在 newpath
+        // 重命名/复制：porcelain v1 -z 输出 "XY newpath\0oldpath\0"——第一字段
+        // 携带新路径（XY 前缀后），第二字段为旧路径。状态必须挂在新路径上：
+        // 文件树按现行路径取状态，旧路径已不存在；此前把 tokens[i+1]（旧路径）
+        // 当新路径挂状态并跳过首字段——git mv 后新文件无任何状态标记，且 map 里
+        // 残留指向不存在路径的幽灵条目。
         if (isRename && i + 1 < tokens.length) {
-            const newPath = tokens[i + 1] ?? '';
-            map[normalizePath(newPath)] = code;
+            const rest = token.slice(3); // 跳过 "XY "，得新路径
+            if (rest)
+                map[normalizePath(rest)] = code;
             i += 2;
         }
         else {
@@ -106,13 +111,19 @@ function git(args, cwd) {
  * 只检查当前展开目录的直接子项（通常 10-50 个），不递归进 node_modules 等。
  * 非 git 仓库或无忽略文件时返回空集。
  *
+ * 路径经 `--` 传入：它们是**位置参数**，以 `-` 开头的合法文件名（-v / --stdin
+ * 等）否则会被 git 当成 check-ignore 自己的选项——`-v` 变 verbose（输出
+ * `.gitignore:1:path` 形态的行，解析端无法匹配任何路径）、`--stdin` 改从标准
+ * 输入读路径（无输入 → 空集），该目录的忽略标记整体静默失效。与分支名注入
+ * （checkoutGitBranch 的 -B<name>）同类：用户可控值不得落进选项槽。
+ *
  * 注意：git check-ignore 在「无路径被忽略」或「非 git 仓库」时退出码为 1，
  * 这两种情况都返回空集。 */
 export function checkIgnored(cwd, paths) {
     if (paths.length === 0)
         return new Set();
     try {
-        const result = spawnSync('git', ['check-ignore', ...paths], {
+        const result = spawnSync('git', ['check-ignore', '--', ...paths], {
             cwd,
             encoding: 'utf-8',
             stdio: ['ignore', 'pipe', 'ignore'],
@@ -178,7 +189,10 @@ function firstRemoteUrl(cwd) {
         .filter(Boolean)[0];
     if (!first)
         return '';
-    return git(['remote', 'get-url', first], cwd);
+    // remote 名来自仓库自身的 .git/config（克隆的仓库可携带 `[remote "-x"]` 这类
+    // 以 `-` 开头的名字）：与 checkIgnored 同口径，位置参数先以 `--` 终止选项解析，
+    // 否则名字被当成 get-url 的选项（--push/--all）而取不到 URL。
+    return git(['remote', 'get-url', '--', first], cwd);
 }
 /**
  * 取当前分支名（非 git 仓库返回 null）。
@@ -271,10 +285,41 @@ export function listGitBranches(cwd) {
     })
         .filter((b) => b.name);
 }
+/**
+ * git 分支名合法性：拒绝「以 `-` 开头」（位置参数会被 git 当作**选项**解释——
+ * `git checkout -B<name>` 静默把该分支指针重置到当前 HEAD、`--detach` 让 HEAD
+ * 脱离分支，接口还照常回成功）与 git ref 规则禁用的字符/形状。
+ * 规则取 git-check-ref-format(1) 的常见子集：本产品的分支名来自 UI 分支列表，
+ * 不接受 revision 语法（HEAD~1 / @{-1}）。
+ */
+const INVALID_BRANCH_CHARS = /[\s~^:?*[\]\\]/;
+/** 控制字符（C0/C1）：ref 名不允许，且会污染日志/UI（与 `\s` 不覆盖 NUL 等）。 */
+const BRANCH_CONTROL_CHARS = /\p{Cc}/u;
+export function isValidBranchName(name) {
+    if (!name || name.startsWith('-') || name === '@')
+        return false;
+    if (INVALID_BRANCH_CHARS.test(name) || BRANCH_CONTROL_CHARS.test(name))
+        return false;
+    if (name.includes('..') || name.includes('@{') || name.includes('//'))
+        return false;
+    if (name.startsWith('/') || name.endsWith('/'))
+        return false;
+    if (name.endsWith('.') || name.endsWith('.lock'))
+        return false;
+    return name.split('/').every((segment) => segment.length > 0 && !segment.startsWith('.'));
+}
+/** 分支名非法时的统一错误（不回显 git stderr：那是「用户输入非法」而非「git 失败」）。 */
+function invalidBranchNameError(name) {
+    return {
+        error: `Invalid branch name ${JSON.stringify(name)}: must be a valid git ref (no leading "-", no whitespace or ~^:?*[\\, no "..", no leading/trailing "/")`,
+    };
+}
 /**
  * 切换到指定分支（git checkout）。成功返回分支名，失败返回 error。
  */
 export function checkoutGitBranch(cwd, branch) {
+    if (!isValidBranchName(branch))
+        return invalidBranchNameError(branch);
     const result = spawnSync('git', ['checkout', branch], {
         cwd,
         encoding: 'utf-8',
@@ -291,6 +336,8 @@ export function checkoutGitBranch(cwd, branch) {
  * 创建并切换到新分支。成功返回分支名，失败返回 error。
  */
 export function createGitBranch(cwd, name) {
+    if (!isValidBranchName(name))
+        return invalidBranchNameError(name);
     const result = spawnSync('git', ['checkout', '-b', name], {
         cwd,
         encoding: 'utf-8',

package/dist/server/permission/interactive.js

@@ -55,15 +55,20 @@ function createInteractivePermissionChecker(store, opts = {}) {
             // agent abort 联动：abort 时主动 deny 并清理 store 条目，
             // 避免 agent 已中止后 promise 仍悬空等待超时。store.resolve 是幂等终结，
             // 与超时/confirm 互斥——谁先到谁生效。
+            // 监听器必须在终结时注销：{ once: true } 只在「真的触发 abort」时自动摘除，
+            // 而确认/超时终结的请求（绝大多数）从不触发 abort——同一次 run 里累积到第 11
+            // 个监听器即触发 Node 的 MaxListenersExceededWarning，每个闭包还随 run 级
+            // signal 活到 run 结束（executor/bash 的同型监听都已在 finally 摘除）。
+            const onAbort = () => {
+                store.resolve(toolCallId, false);
+            };
             if (ctx.abort.aborted) {
                 store.resolve(toolCallId, false);
             }
             else {
-                ctx.abort.addEventListener('abort', () => {
-                    store.resolve(toolCallId, false);
-                }, { once: true });
+                ctx.abort.addEventListener('abort', onAbort, { once: true });
             }
-            return promise;
+            return promise.finally(() => ctx.abort.removeEventListener('abort', onAbort));
         },
         confirm(toolCallId, approved) {
             return store.resolve(toolCallId, approved);

package/dist/server/permission/store.js

@@ -4,14 +4,20 @@
 // reply 按 toolCallId 直接寻址，不依赖 session/agent run 的注册状态。
 // 这样即使 agent run 被覆盖、注销或 abort，pending 仍在 store 里，
 // confirm 仍能找到并 resolve。
+import { clampTimerDelay } from '../../shared/timer.js';
 /** 默认 pending 超时时长：5 分钟（300_000ms）。
  *  超过后自动 resolve 为 deny 并清理 store 条目，避免 promise 永久挂起与 pending Map 泄漏。 */
 const DEFAULT_PERMISSION_TIMEOUT_MS = 5 * 60 * 1000;
 /** 首层超时（仅提示）后到兜底自动拒绝的宽限期：25 分钟。双层超时总窗口 30 分钟。 */
 const DEFAULT_PERMISSION_EXPIRE_GRACE_MS = 25 * 60 * 1000;
 function createPermissionStore(opts = {}) {
-    const timeoutMs = opts.timeoutMs ?? DEFAULT_PERMISSION_TIMEOUT_MS;
-    const expireGraceMs = opts.expireGraceMs ?? DEFAULT_PERMISSION_EXPIRE_GRACE_MS;
+    // timeoutMs/expireGraceMs 来自用户 config（server.ts 直传，调用点只校验 > 0）：
+    // 超 32 位上限的值会被 Node 钳到 1ms——用户设「30 天」
+    // （2_592_000_000ms > 2^31-1）时权限请求注册即被「超时自动拒绝」，
+    // 根本没机会确认；宽限期同理退化成「提示后立刻拒绝」。非法/超限一律
+    // 回落默认（超限钳到上限），与 bash timeout / 更新检查间隔同口径。
+    const timeoutMs = clampTimerDelay(opts.timeoutMs, DEFAULT_PERMISSION_TIMEOUT_MS, 1);
+    const expireGraceMs = clampTimerDelay(opts.expireGraceMs, DEFAULT_PERMISSION_EXPIRE_GRACE_MS, 1);
     const pending = new Map();
     // 统一终结路径：clearTimeout → 删除条目 → resolve。
     // 三处调用（confirm、超时回调、abort 联动）都汇聚于此：

package/dist/server/routes/auth.js

@@ -14,6 +14,7 @@
 //   DELETE /api/auth/devices/:id     撤销设备（立即生效）
 import { Hono } from 'hono';
 import { apiError } from '../middleware/error.js';
+import { readJsonObject } from '../util/json-body.js';
 /** 尽力而为的请求来源：x-forwarded-for 首跳（反代场景），否则视为本地回环。仅展示/软限流。 */
 function requestSource(c) {
     const fwd = c.req.header('x-forwarded-for');
@@ -31,11 +32,15 @@ function createAuthRoute(ctx) {
         if (!ctx.authManager) {
             return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
         }
-        const body = (await c.req.json().catch(() => ({})));
-        if (!body.token) {
+        const parsed = await readJsonObject(c);
+        if (!parsed.ok)
+            return parsed.response;
+        const body = parsed.body;
+        if (typeof body.token !== 'string' || !body.token) {
             return apiError(c, 400, 'BAD_REQUEST', 'token is required');
         }
-        const result = await ctx.authManager.registerFirstDevice(body.token, body.deviceName ?? '设备');
+        const deviceName = typeof body.deviceName === 'string' && body.deviceName ? body.deviceName : '设备';
+        const result = await ctx.authManager.registerFirstDevice(body.token, deviceName);
         if (!result.ok) {
             // 区分失败原因给正确的恢复指引：链接过期 → 重启 serve 换新链接；
             // 已有设备 → 走配对审批；两者补救动作完全不同，不得混用同一文案。
@@ -52,15 +57,18 @@ function createAuthRoute(ctx) {
             return apiError(c, 403, 'STATIC_TOKEN_MODE', '静态 token 模式不支持设备注册。');
         }
         // P1-3：回传注册成功的设备名，前端展示一次性确认（用户可核对注册的是否自己）。
-        return c.json({ deviceToken: result.deviceToken, deviceName: body.deviceName ?? '设备' });
+        return c.json({ deviceToken: result.deviceToken, 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));
+        const parsed = await readJsonObject(c);
+        if (!parsed.ok)
+            return parsed.response;
+        const deviceName = parsed.body.deviceName;
+        const result = ctx.authManager.requestPairing(typeof deviceName === 'string' && deviceName ? deviceName : '新设备', requestSource(c));
         if (!result) {
             return apiError(c, 429, 'PAIRING_LIMIT', '待审批的配对请求过多，请稍后再试');
         }
@@ -98,12 +106,16 @@ function createAuthRoute(ctx) {
         if (!ctx.authManager) {
             return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
         }
-        const body = (await c.req.json().catch(() => ({})));
-        if (!body.pairingId)
+        const parsed = await readJsonObject(c);
+        if (!parsed.ok)
+            return parsed.response;
+        const pairingId = typeof parsed.body.pairingId === 'string' ? parsed.body.pairingId : '';
+        const code = typeof parsed.body.code === 'string' ? parsed.body.code : '';
+        if (!pairingId)
             return apiError(c, 400, 'BAD_REQUEST', 'pairingId is required');
-        if (!body.code)
+        if (!code)
             return apiError(c, 400, 'BAD_REQUEST', 'code is required');
-        const result = ctx.authManager.approvePairing(body.pairingId, body.code);
+        const result = ctx.authManager.approvePairing(pairingId, code);
         if (result === 'code_mismatch') {
             return apiError(c, 400, 'PAIRING_CODE_MISMATCH', '配对码不匹配：请核对新设备屏幕显示的 6 位配对码后重新输入');
         }
@@ -120,10 +132,13 @@ function createAuthRoute(ctx) {
         if (!ctx.authManager) {
             return apiError(c, 400, 'AUTH_DISABLED', '认证未启用');
         }
-        const body = (await c.req.json().catch(() => ({})));
-        if (!body.pairingId)
+        const parsed = await readJsonObject(c);
+        if (!parsed.ok)
+            return parsed.response;
+        const pairingId = typeof parsed.body.pairingId === 'string' ? parsed.body.pairingId : '';
+        if (!pairingId)
             return apiError(c, 400, 'BAD_REQUEST', 'pairingId is required');
-        const ok = ctx.authManager.denyPairing(body.pairingId);
+        const ok = ctx.authManager.denyPairing(pairingId);
         if (!ok)
             return apiError(c, 404, 'PAIRING_NOT_FOUND', '配对请求不存在或已过期');
         return c.json({ ok: true });

package/dist/server/routes/chat.js

@@ -5,10 +5,13 @@ 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 { buildRegistryFromConfig } from '../../core/provider-registry.js';
+import { discoverSkills } from '../../core/skills.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 { createDebugSpawn } from '../../dap/index.js';
 import { resolveRoute } from '../../llm/registry.js';
 import { getProject } from '../../project/project.js';
 import { enrichProjectRiskWithGlobal, projectTrustNeeded } from '../../project/trust.js';
@@ -19,7 +22,7 @@ import { PROJECT_BOUND_TOOLS, resolveEnabledToolNames } from '../../tools/index.
 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 { readJsonObject } from '../util/json-body.js';
 import { safeResolve } from '../util/safe-path.js';
 /** 按 session.projectId / worktreePath 解析 agent 工作目录：
  *  - 有 projectId → 项目 worktree（缺失/目录失效时抛错，由上层转 409）。
@@ -100,9 +103,17 @@ function createChatRoute(ctx) {
     const app = new Hono();
     // POST / — SSE 流式聊天
     app.post('/', async (c) => {
-        const body = await c.req.json().catch(() => ({}));
-        const sessionId = body.sessionId;
-        const message = body.message;
+        // 畸形 JSON / null / 非对象 body → 400（此前 null body 在 body.sessionId 处
+        // TypeError 500；数字 sessionId 会一路进 PG 的 uuid 参数 → 22P02 500）。
+        const bodyParsed = await readJsonObject(c);
+        if (!bodyParsed.ok)
+            return bodyParsed.response;
+        const { body } = bodyParsed;
+        const sessionId = typeof body.sessionId === 'string' ? body.sessionId : undefined;
+        // body 字段形状校验（P3 加固）：message 非字符串（number/object）会通过
+        // 「!message」检查后经 parseSlashInput 的 .trim() 击穿 TypeError 500——
+        // 按缺省处理落入下方空消息 400，而非 500。
+        const message = typeof body.message === 'string' ? body.message : undefined;
         const images = body.images;
         // P1-5：纯图片消息放行（Composer 允许只带图片不带文本），
         // 仅当文本与图片皆无时拒绝，错误信息说明可操作原因。
@@ -110,27 +121,41 @@ function createChatRoute(ctx) {
             return apiError(c, 400, 'BAD_REQUEST', '消息内容不能为空：请输入文字或附带图片后再发送');
         }
         // P0：图片大小/数量服务端限额（前端已限制，此为兜底——API 直调/旧客户端）。
-        if (images) {
+        // P3 加固：条目形状（对象 + string mediaType/data + image/ 前缀）显式 400——
+        // images 非数组 → for-of TypeError；[null] → 读 null.data TypeError；缺字段
+        // 条目此前静默持久化成毒化图片消息（jsonb 丢弃 undefined 字段），后续每轮
+        // 上下文重建都携带破损图片，provider 恒 400，会话无法继续。
+        if (images !== undefined) {
+            if (!Array.isArray(images)) {
+                return apiError(c, 400, 'INVALID_IMAGES', '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 (img === null ||
+                    typeof img !== 'object' ||
+                    Array.isArray(img) ||
+                    typeof img.mediaType !== 'string' ||
+                    !img.mediaType.startsWith('image/') ||
+                    typeof img.data !== 'string' ||
+                    img.data.length === 0) {
+                    return apiError(c, 400, 'INVALID_IMAGE', 'images 每项必须是 { mediaType: "image/...", data: "<base64>" }');
+                }
                 // 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`);
-                    }
+                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`);
                 }
             }
         }
@@ -293,7 +318,7 @@ function createChatRoute(ctx) {
             try {
                 workflowSession = await createSession(ctx.db, workflowSessionTitle(name), session.projectId ?? undefined, 'workflow', undefined, undefined, cwd, 
                 // 中断恢复指引需要工作流名（重启后会话内无 user 消息可重发）。
-                { workflowName: name });
+                { workflowName: name }, ctx.hookRunner);
             }
             catch (e) {
                 ctx.workflowBusyByScope.delete(scopeKey);
@@ -725,6 +750,10 @@ function createChatRoute(ctx) {
         const files = body.files;
         if (files?.length) {
             for (const p of files) {
+                // 非字符串条目（number/object）进 safeResolve 会让 node:path resolve
+                // 抛 TypeError 击穿 500——按「读取失败静默跳过」同口径忽略。
+                if (typeof p !== 'string' || p.length === 0)
+                    continue;
                 const resolved = safeResolve(cwd, p);
                 if (!resolved)
                     continue;
@@ -911,6 +940,10 @@ function createChatRoute(ctx) {
                         agentRegistry: ctx.agentRegistry,
                         registerChildRun: childRunBridge(ctx.agentManager),
                         cwd,
+                        // 技能发现（system prompt ## Loaded Skills 段数据源）。
+                        skills: discoverSkills(cwd),
+                        // DAP（spec §21）：Web 宿主注入真实适配器 spawn（与 CLI 同口径）。
+                        debugSpawn: createDebugSpawn(),
                         // P3 成本护栏：会话项目配置任一轴动作为 'pause'/'abort' 时启用预算检查。
                         // 具体 pause/abort 由 budgetOverageParts 按超支轴配置动作判定（abort >
                         // pause），此处仅注入「启用」门禁——修 P1 双轴动作坍缩（此前 pause 分支
@@ -1059,7 +1092,18 @@ function createChatRoute(ctx) {
         ? apiError(c, 409, 'RUN_STARTING', '该会话的对话正在启动，请稍后重试')
         : undefined;
     app.post('/abort', async (c) => {
-        const { sessionId } = await c.req.json();
+        // 畸形 JSON / 非对象 body / 缺 sessionId → 400（与其他写端点同口径）。
+        // 此前裸 destructure：畸形 JSON 击穿 Hono 500，null body 在解构处
+        // TypeError 500，缺 sessionId 静默回 { aborted: false }。
+        const body = (await c.req.json().catch(() => null));
+        const sessionId = body !== null &&
+            typeof body === 'object' &&
+            !Array.isArray(body) &&
+            typeof body.sessionId === 'string'
+            ? body.sessionId
+            : '';
+        if (!sessionId)
+            return apiError(c, 400, 'BAD_REQUEST', 'sessionId is required');
         // 工作流运行期间发起会话无主 run：中止请求路由到实际的工作流 run。
         const busyWorkflowId = ctx.workflowBusyBySession.get(sessionId);
         if (busyWorkflowId) {
@@ -1068,7 +1112,15 @@ function createChatRoute(ctx) {
         return runStarting(c, sessionId) ?? c.json({ aborted: ctx.agentManager.abort(sessionId) });
     });
     app.post('/pause', async (c) => {
-        const { sessionId } = await c.req.json();
+        const body = (await c.req.json().catch(() => null));
+        const sessionId = body !== null &&
+            typeof body === 'object' &&
+            !Array.isArray(body) &&
+            typeof body.sessionId === 'string'
+            ? body.sessionId
+            : '';
+        if (!sessionId)
+            return apiError(c, 400, 'BAD_REQUEST', 'sessionId is required');
         // 级联子 run（P1：子 agent 现已注册，暂停主 run 必须一并暂停——
         // 否则后台子 agent 在用户认为「已暂停」时继续执行）。
         const busyWorkflowId = ctx.workflowBusyBySession.get(sessionId);
@@ -1082,7 +1134,15 @@ function createChatRoute(ctx) {
         return c.json({ paused });
     });
     app.post('/resume', async (c) => {
-        const { sessionId } = await c.req.json();
+        const body = (await c.req.json().catch(() => null));
+        const sessionId = body !== null &&
+            typeof body === 'object' &&
+            !Array.isArray(body) &&
+            typeof body.sessionId === 'string'
+            ? body.sessionId
+            : '';
+        if (!sessionId)
+            return apiError(c, 400, 'BAD_REQUEST', 'sessionId is required');
         // 权限超时暂停工作流后，发起会话展示「恢复」按钮——路由到工作流 run 真正恢复。
         // 级联恢复子 run：暂停时子 run 一并暂停，仅恢复主 run 会让父的工具批次
         // 永远等待已暂停的子 agent（死锁）。
@@ -1097,8 +1157,14 @@ function createChatRoute(ctx) {
         return c.json({ resumed });
     });
     app.post('/steer', async (c) => {
-        const body = await c.req.json();
-        const starting = runStarting(c, body.sessionId);
+        const body = (await c.req.json().catch(() => null));
+        if (body === null || typeof body !== 'object' || Array.isArray(body)) {
+            return apiError(c, 400, 'BAD_REQUEST', '请求体必须是 JSON 对象');
+        }
+        const sessionId = typeof body.sessionId === 'string' ? body.sessionId : '';
+        if (!sessionId)
+            return apiError(c, 400, 'BAD_REQUEST', 'sessionId is required');
+        const starting = runStarting(c, sessionId);
         if (starting)
             return starting;
         const message = typeof body.message === 'string' ? body.message.trim() : '';
@@ -1106,14 +1172,14 @@ function createChatRoute(ctx) {
             return c.json({ steered: false });
         // P1 工作流路由：工作流运行期间 steer 目标为实际的 workflow run
         //（此前 steer 恒 false、指令静默丢失，用户以为已生效）。
-        const busyWorkflowId = ctx.workflowBusyBySession.get(body.sessionId);
-        const steered = ctx.agentManager.steer(busyWorkflowId ?? body.sessionId, message);
+        const busyWorkflowId = ctx.workflowBusyBySession.get(sessionId);
+        const steered = ctx.agentManager.steer(busyWorkflowId ?? sessionId, message);
         // P0 闭环：steering 持久化为会话条目——用户运行中输入追加指令曾是内存瞬态，
         // 刷新后彻底丢失；现在与消息同样入史（context 重建时作为 system 消息注入，
         // 时间线经 /messages 渲染为 user steering 块）。
         if (steered) {
             await insertEntry(ctx.db, {
-                sessionId: body.sessionId,
+                sessionId,
                 tag: 'steering',
                 content: { text: message },
             }).catch(() => {

package/dist/server/routes/config.js

@@ -10,14 +10,19 @@ import { syncRegistryFromConfig } from '../server.js';
 /** 检查每个 provider 的 apiKey 能否在本机解密（机器绑定密钥换机/容器重建后会失败）。 */
 function providerApiKeyWarnings(providers) {
     const warnings = [];
-    for (const p of providers) {
-        if (!p.apiKey || !isEncryptedSecret(p.apiKey))
+    for (const entry of providers) {
+        // 手改/旧版配置文件的畸形条目：跳过错报（registry 构建侧同口径跳过）。
+        if (entry === null || typeof entry !== 'object' || Array.isArray(entry))
+            continue;
+        const p = entry;
+        const apiKey = p.apiKey;
+        if (typeof apiKey !== 'string' || apiKey.length === 0 || !isEncryptedSecret(apiKey))
             continue;
         try {
-            decryptSecret(p.apiKey);
+            decryptSecret(apiKey);
         }
         catch {
-            warnings.push(`provider "${p.name || ''}" 的 apiKey 无法在本机解密（配置来自其他机器），请重新设置`);
+            warnings.push(`provider "${(typeof p.name === 'string' ? p.name : '') || ''}" 的 apiKey 无法在本机解密（配置来自其他机器），请重新设置`);
         }
     }
     return warnings;
@@ -133,7 +138,12 @@ function createConfigRoute(ctx) {
     // 仅当写入目标是服务启动目录项目时同步服务级内存配置与 LLM registry——
     // 其他项目的配置不污染服务级 provider 注册表（会话级按需解析）。
     app.patch('/', async (c) => {
-        const body = (await c.req.json());
+        // 畸形 JSON / 非对象 body → 400（此前裸 await c.req.json()：畸形 JSON
+        // 击穿 Hono 500，null body 在 body.scope 处 TypeError 500）。
+        const body = (await c.req.json().catch(() => null));
+        if (body === null || typeof body !== 'object' || Array.isArray(body)) {
+            return apiError(c, 400, 'BAD_REQUEST', '请求体必须是 JSON 对象');
+        }
         const scope = body.scope === 'global' ? 'global' : 'project';
         const { scope: _omit, projectId, ...patch } = body;
         // 未知顶层键拒绝：拼写错误/过时键经此路径写入只会埋雷（永不生效且难发现）。
@@ -158,9 +168,18 @@ function createConfigRoute(ctx) {
             }
         }
         // spec §24.2：provider apiKey 落盘前加密，明文不持久化。
-        // 已加密（enc: 前缀）或无 apiKey 的透传。
+        // 已加密（enc: 前缀）或无 apiKey 的透传。映射须对畸形条目空安全：
+        // [null] 此前在 p.apiKey 处 TypeError 击穿 500——畸形条目原样保留，
+        // 由下方 applyScopedPatch 的 providers 形状校验显式 400。
         if (Array.isArray(patch.providers)) {
-            patch.providers = patch.providers.map((p) => p.apiKey && !isEncryptedSecret(p.apiKey) ? { ...p, apiKey: encryptSecret(p.apiKey) } : p);
+            patch.providers = patch.providers.map((entry) => {
+                if (entry === null || typeof entry !== 'object' || Array.isArray(entry))
+                    return entry;
+                const p = entry;
+                return typeof p.apiKey === 'string' && p.apiKey.length > 0 && !isEncryptedSecret(p.apiKey)
+                    ? { ...p, apiKey: encryptSecret(p.apiKey) }
+                    : entry;
+            });
         }
         // 按作用域最小落盘：patch 只合并进指定作用域原始文件，
         // 不把合并结果（含默认值/另一作用域配置）整体序列化进文件。
@@ -169,9 +188,18 @@ function createConfigRoute(ctx) {
         if (!target)
             return apiError(c, 404, 'PROJECT_NOT_FOUND', '项目不存在');
         const scopes = loadConfigScopes(target.dir);
-        const nextScoped = scope === 'global'
-            ? applyScopedPatch(scopes.global ?? {}, patch)
-            : applyScopedPatch(scopes.project ?? {}, patch);
+        // applyScopedPatch 拒绝非有限数值（JSON 1e999 → Infinity 落盘为 null、
+        // 键被静默删除）——转成 400 明示，而非 500 或不透因。
+        let nextScoped;
+        try {
+            nextScoped =
+                scope === 'global'
+                    ? applyScopedPatch(scopes.global ?? {}, patch)
+                    : applyScopedPatch(scopes.project ?? {}, patch);
+        }
+        catch (err) {
+            return apiError(c, 400, 'INVALID_CONFIG_VALUE', err instanceof Error ? err.message : String(err));
+        }
         // P2-3：落盘失败必须反馈给前端（此前静默吞掉，UI 显示已保存但重启后丢失）。
         // 先落盘、成功后才更新内存配置与 registry，保证「已保存」反馈与磁盘状态一致。
         try {