c0de-agent 1.12.0 → 1.13.0

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

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

package/dist/server/routes/commands.js

@@ -1,17 +1,15 @@
 import { Hono } from 'hono';
-import { createSlashRegistry } from '../../core/slash.js';
+import { createSlashRegistry, isSlashCommandEnabled } from '../../core/slash.js';
 /** GET / — 返回内置斜杠命令列表（name/description/argsHint）。
- *  按 config.slashCommands.enabled 过滤：enabled 为空 = 全部启用；
- *  否则只返回启用项，保证弹窗发现性 = 可执行性（避免展示必被拒的命令）。 */
+ *  按 config.slashCommands.enabled 过滤：enabled 为空 = 全部禁用（fail-closed）；
+ *  含 ['*'] = 全部启用；否则只返回启用项，保证弹窗发现性 = 可执行性（避免展示必被拒的命令）。 */
 function createCommandsRoute(ctx) {
     const app = new Hono();
     app.get('/', (c) => {
         const registry = createSlashRegistry();
-        const enabledList = ctx.config.slashCommands?.enabled ?? [];
-        const enabledSet = new Set(enabledList.map((n) => (n.startsWith('/') ? n.slice(1) : n)));
         const commands = registry
             .list()
-            .filter((cmd) => enabledSet.size === 0 || enabledSet.has(cmd.name))
+            .filter((cmd) => isSlashCommandEnabled(ctx.config.slashCommands?.enabled, cmd.name))
             .map((cmd) => ({
             name: cmd.name,
             description: cmd.description,

package/dist/server/routes/config.js

@@ -1,10 +1,10 @@
 import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { Hono } from 'hono';
-import { applyScopedPatch, collectUnknownConfigKeys, KNOWN_CONFIG_KEYS, loadConfigScopes, mergeConfig, saveConfigScoped, } from '../../core/config.js';
+import { applyScopedPatch, collectConfigMigrationWarnings, collectUnknownConfigKeys, GLOBAL_ONLY_USAGE_KEYS, KNOWN_CONFIG_KEYS, loadConfigScopes, loadProjectRawScope, mergeConfig, projectGlobalOnlyUsageKeys, projectSecurityKeys, saveConfigScoped, } from '../../core/config.js';
 import { containsSecrets } from '../../core/redact.js';
 import { decryptSecret, encryptSecret, isEncryptedSecret } from '../../core/secret.js';
-import { getProject } from '../../project/project.js';
+import { getByDirectory, getProject, trustProject } from '../../project/index.js';
 import { apiError } from '../middleware/error.js';
 import { syncRegistryFromConfig } from '../server.js';
 /** 检查每个 provider 的 apiKey 能否在本机解密（机器绑定密钥换机/容器重建后会失败）。 */
@@ -69,14 +69,62 @@ function createConfigRoute(ctx) {
             ...collectUnknownConfigKeys(scopes.global).map((k) => `全局配置含未知键 "${k}"，不会生效`),
             ...collectUnknownConfigKeys(scopes.project).map((k) => `项目配置含未知键 "${k}"，不会生效`),
         ];
+        // 作用域收敛：项目配置里遗留的全局口径预算键加载时已被剥离（不再生效），在此明示。
+        const strippedGlobalKeys = projectGlobalOnlyUsageKeys(target.dir);
+        const globalBudgetWarnings = strippedGlobalKeys.map((k) => `项目配置含全局口径预算键 "${k}"，已忽略（该键仅在全局作用域生效，请改在全局配置设置）`);
+        // P：security 收敛为 global-only（此前克隆仓库可静默改写服务端鉴权/CORS 参数）。
+        const strippedSecurityKeys = projectSecurityKeys(target.dir);
+        const securityWarnings = strippedSecurityKeys.length > 0
+            ? [
+                `项目配置含 security 键（${strippedSecurityKeys.join('、')}，服务端全局参数），已忽略——` +
+                    '请在设置页切换到「全局」作用域修改安全设置。',
+            ]
+            : [];
+        // P：未归属调用（CLI 临时会话/未绑定项目的续接会话）只受全局口径预算兜底。
+        // 仅设项目预算、未设全局预算时这些调用零护栏——在设置页明示而非静默裸奔。
+        const budgetScopeWarnings = [];
+        const hasProjectBudget = (config.usage.monthlyBudgetUsd ?? 0) > 0 || (config.usage.monthlyTokenBudget ?? 0) > 0;
+        const hasGlobalBudget = (config.usage.globalMonthlyBudgetUsd ?? 0) > 0 ||
+            (config.usage.globalMonthlyTokenBudget ?? 0) > 0;
+        if (hasProjectBudget && !hasGlobalBudget) {
+            budgetScopeWarnings.push('已设置项目预算但未设置全局预算：CLI（c0de chat）与未归属项目的调用不受任何预算护栏约束。' +
+                '建议在设置页切换到「全局」作用域补充全局月度预算。');
+        }
+        // P0-1：语义翻转/易混键（tools.enabled/slashCommands.enabled 空数组）在 Web 可见。
+        const migrationWarnings = [
+            ...collectConfigMigrationWarnings('global', scopes.global),
+            ...collectConfigMigrationWarnings('project', scopes.project),
+        ];
+        // P2-1 / P2-2：无可用 provider 与项目 providers 空数组覆盖本机全局 providers。
+        const providerWarnings = [];
+        if (config.providers.length === 0) {
+            providerWarnings.push('尚未配置任何 AI 服务（providers 为空）。请到「设置 → Provider」添加并测试连接，否则无法发起对话。');
+        }
+        const projProviders = scopes.project?.providers;
+        const globalProviders = scopes.global?.providers;
+        if (Array.isArray(projProviders) &&
+            projProviders.length === 0 &&
+            Array.isArray(globalProviders) &&
+            globalProviders.length > 0) {
+            providerWarnings.push(`项目配置的 providers 为空数组，会整体替换本机全局 providers（${globalProviders.length} 项），` +
+                '导致无可用服务。请删除项目配置中的 providers 键，或在项目配置中显式填写服务。');
+        }
         return c.json({
             config,
             scopes: {
                 global: scopes.global ?? null,
                 project: scopes.project ?? null,
             },
-            warnings: [...providerApiKeyWarnings(config.providers), ...unknownWarnings],
-            gitWarning: projectConfigGitWarning(scopes.project, target.dir),
+            warnings: [
+                ...providerApiKeyWarnings(config.providers),
+                ...globalBudgetWarnings,
+                ...securityWarnings,
+                ...unknownWarnings,
+                ...migrationWarnings,
+                ...providerWarnings,
+                ...budgetScopeWarnings,
+            ],
+            gitWarning: projectConfigGitWarning(loadProjectRawScope(target.dir), target.dir),
             projectDir: target.isProjectScoped ? target.dir : undefined,
         });
     });
@@ -93,6 +141,22 @@ function createConfigRoute(ctx) {
         if (unknown.length > 0) {
             return apiError(c, 400, 'UNKNOWN_CONFIG_KEYS', `未知配置键：${unknown.join(', ')}。有效顶层键：${[...KNOWN_CONFIG_KEYS].join(', ')}`);
         }
+        // 作用域收敛：security 是服务端全局参数，仅 global 作用域生效（项目作用域读取时被剥离）。
+        // 项目作用域写入会被静默忽略，与其落盘后再丢弃，不如直接拒绝并给出正解路径。
+        if (scope === 'project' && patch.security !== undefined) {
+            return apiError(c, 400, 'SECURITY_IN_PROJECT_SCOPE', 'security 是服务端全局参数，仅在全局作用域生效。请在设置页切换到「全局」作用域后再修改。');
+        }
+        // 作用域收敛：usage 的全局口径预算键仅 global 作用域生效（项目作用域读取时被剥离）。
+        // 项目作用域写入这些键会被静默忽略，与其落盘后再丢弃，不如直接拒绝并给出正解路径。
+        if (scope === 'project' &&
+            typeof patch.usage === 'object' &&
+            patch.usage !== null &&
+            !Array.isArray(patch.usage)) {
+            const offending = GLOBAL_ONLY_USAGE_KEYS.filter((k) => k in patch.usage);
+            if (offending.length > 0) {
+                return apiError(c, 400, 'GLOBAL_BUDGET_IN_PROJECT_SCOPE', `「${offending.join(' / ')}」是全局口径预算，仅在全局作用域生效。请在设置页切换到「全局」作用域后再修改。`);
+            }
+        }
         // spec §24.2：provider apiKey 落盘前加密，明文不持久化。
         // 已加密（enc: 前缀）或无 apiKey 的透传。
         if (Array.isArray(patch.providers)) {
@@ -116,6 +180,19 @@ function createConfigRoute(ctx) {
         catch (err) {
             return apiError(c, 500, 'CONFIG_SAVE_FAILED', `配置保存失败：${err instanceof Error ? err.message : String(err)}`);
         }
+        // P1：项目作用域写入是用户经产品入口的显式操作——已信任项目刷新风险指纹
+        //（与工作流 create/delete 同口径）。不刷新会让用户自己的设置修改触发
+        // trust-drift 复检，「信任 → 改设置 → 再信任」自锁循环。
+        if (scope === 'project') {
+            try {
+                const p = await getByDirectory(ctx.db, target.dir);
+                if (p?.trustedAt != null)
+                    await trustProject(ctx.db, p.id);
+            }
+            catch {
+                // 指纹刷新失败不阻塞配置保存（最坏回到 fail-closed 复检路径）
+            }
+        }
         const isServerCwdProject = target.dir === ctx.cwd;
         if (isServerCwdProject || scope === 'global') {
             // global 作用域写入影响所有项目（含服务级 provider 注册表），

package/dist/server/routes/files.js

@@ -10,11 +10,31 @@ import { appendToGitignore, checkIgnored, checkoutGitBranch, createGitBranch, ge
 import { apiError } from '../middleware/error.js';
 import { buildRegistryFromConfig } from '../registry-config.js';
 import { safeResolve } from '../util/safe-path.js';
-/** 递归搜索时跳过的目录（体积大/为元数据噪音，避免递归进入）。 */
-const SEARCH_SKIP_DIRS = new Set(['.git', 'node_modules']);
-/** 递归收集文件列表（用于搜索）。 */
-async function collectFiles(dir, basePath, maxDepth = 5) {
-    if (maxDepth < 0)
+/** 递归搜索时跳过的目录（体积大/为元数据噪音，避免递归进入）。
+ *  P3：补齐常见构建/缓存产物目录——此前只跳 .git/node_modules，
+ *  大仓库每击键全量 walk 时 dist/.cache 等目录拖垮延迟。 */
+const SEARCH_SKIP_DIRS = new Set([
+    '.git',
+    'node_modules',
+    'dist',
+    'build',
+    '.cache',
+    'coverage',
+    '.next',
+    '.nuxt',
+    '.turbo',
+    '.parcel-cache',
+    '.vite',
+    'target',
+    'vendor',
+    '__pycache__',
+]);
+/** P3-14：递归收集的结果上限——大仓库无上限返回会拖垮前端渲染。 */
+const SEARCH_MAX_RESULTS = 5000;
+/** 递归收集文件列表（用于搜索）。P3：深度上限 5 → 8，深层文件此前搜不到。
+ *  P3-14：达结果上限即停止遍历，防大仓库全量 walk。 */
+async function collectFiles(dir, basePath, maxDepth = 8, budget = SEARCH_MAX_RESULTS) {
+    if (maxDepth < 0 || budget <= 0)
         return [];
     const results = [];
     let entries;
@@ -25,13 +45,16 @@ async function collectFiles(dir, basePath, maxDepth = 5) {
         return [];
     }
     for (const entry of entries) {
+        if (results.length >= budget)
+            break;
         if (entry.isDirectory() && SEARCH_SKIP_DIRS.has(entry.name))
             continue;
         const fullPath = join(dir, entry.name);
         const relPath = relative(basePath, fullPath);
         if (entry.isDirectory()) {
             results.push({ path: relPath, type: 'directory' });
-            results.push(...(await collectFiles(fullPath, basePath, maxDepth - 1)));
+            const rest = await collectFiles(fullPath, basePath, maxDepth - 1, budget - results.length);
+            results.push(...rest);
         }
         else {
             results.push({ path: relPath, type: 'file' });
@@ -58,7 +81,6 @@ function contentTypeFor(name) {
         webm: 'video/webm',
         mov: 'video/quicktime',
         json: 'application/json; charset=utf-8',
-        html: 'text/html; charset=utf-8',
         md: 'text/markdown; charset=utf-8',
         txt: 'text/plain; charset=utf-8',
         ts: 'text/plain; charset=utf-8',
@@ -66,6 +88,51 @@ function contentTypeFor(name) {
     };
     return map[ext] ?? 'application/octet-stream';
 }
+/** P3：.gitignore 追加条目的白名单式校验。suggestions 源自 LLM 输出并经前端
+ *  「批准」回传——服务端兜底拒绝换行注入（一条变多条）、全局通配（`*` 直接
+ *  忽略整个仓库）与超长/超量条目。合法返回规范化的 trim 后数组，非法返回 null。 */
+function sanitizeIgnoreSuggestions(raw) {
+    if (!Array.isArray(raw))
+        return null;
+    if (raw.length === 0 || raw.length > 100)
+        return null;
+    const out = [];
+    for (const item of raw) {
+        if (typeof item !== 'string')
+            return null;
+        const p = item.trim();
+        if (p.length === 0 || p.length > 200)
+            return null;
+        if (p.includes('\n') || p.includes('\r'))
+            return null;
+        if (p === '*' || p === '/*' || p === '/')
+            return null;
+        out.push(p);
+    }
+    return out.length > 0 ? out : null;
+}
+function checkCommitMessage(raw) {
+    if (typeof raw !== 'string')
+        return { ok: false, reason: 'EMPTY' };
+    const message = raw.trim();
+    if (!message)
+        return { ok: false, reason: 'EMPTY' };
+    if (message.length > 500)
+        return { ok: false, reason: 'TOO_LONG' };
+    if (/[\r\n]/.test(message))
+        return { ok: false, reason: 'MULTILINE' };
+    return { ok: true, message };
+}
+/** force/append-ignore 模式的 message 校验错误码映射（保持既有 API 契约）。 */
+function rejectCommitMessage(c, reason, mode) {
+    if (reason === 'EMPTY') {
+        return apiError(c, 400, 'MISSING_MESSAGE', `mode=${mode} requires a message`);
+    }
+    if (reason === 'TOO_LONG') {
+        return apiError(c, 400, 'MESSAGE_TOO_LONG', 'commit message must be at most 500 characters');
+    }
+    return apiError(c, 400, 'BAD_REQUEST', 'commit message must be a single line');
+}
 function createFilesRoute(ctx) {
     const app = new Hono();
     // git 状态：返回 path → 状态分类 的映射（非 git 返回空对象）
@@ -128,36 +195,39 @@ function createFilesRoute(ctx) {
             .catch(() => ({}));
         // --- mode: force — 跳过检查，用传入 message 直接提交 ---
         if (body.mode === 'force') {
-            if (!body.message) {
-                return apiError(c, 400, 'MISSING_MESSAGE', 'mode=force requires a message');
-            }
-            const result = performGitCommit(root, body.message);
+            const check = checkCommitMessage(body.message);
+            if (!check.ok)
+                return rejectCommitMessage(c, check.reason, 'force');
+            const message = check.message;
+            const result = performGitCommit(root, message);
             if ('error' in result) {
                 return apiError(c, 500, 'COMMIT_FAILED', result.error);
             }
             return c.json({
                 committed: true,
-                message: body.message,
+                message,
                 hash: result.hash,
                 fileCount: summary.fileCount,
             });
         }
         // --- mode: append-ignore — 追加 .gitignore 后提交 ---
         if (body.mode === 'append-ignore') {
-            if (!body.message) {
-                return apiError(c, 400, 'MISSING_MESSAGE', 'mode=append-ignore requires a message');
-            }
-            if (!body.suggestions || body.suggestions.length === 0) {
-                return apiError(c, 400, 'MISSING_SUGGESTIONS', 'mode=append-ignore requires suggestions');
+            const check = checkCommitMessage(body.message);
+            if (!check.ok)
+                return rejectCommitMessage(c, check.reason, 'append-ignore');
+            // P3：suggestions 服务端白名单校验（换行注入/全局通配/超量直接 400）。
+            const suggestions = sanitizeIgnoreSuggestions(body.suggestions);
+            if (!suggestions) {
+                return apiError(c, 400, 'INVALID_SUGGESTIONS', 'mode=append-ignore requires valid suggestions (non-empty paths, no newlines, no global wildcards)');
             }
-            appendToGitignore(root, body.suggestions);
-            const result = performGitCommit(root, body.message);
+            appendToGitignore(root, suggestions);
+            const result = performGitCommit(root, check.message);
             if ('error' in result) {
                 return apiError(c, 500, 'COMMIT_FAILED', result.error);
             }
             return c.json({
                 committed: true,
-                message: body.message,
+                message: check.message,
                 hash: result.hash,
                 fileCount: summary.fileCount,
             });
@@ -216,13 +286,19 @@ ${summary.diff.slice(0, 8000)}`;
         if (!message) {
             return apiError(c, 502, 'EMPTY_MESSAGE', 'LLM returned empty commit message');
         }
+        // P2 修复：与 force 模式同口径校验（长度/单行）——LLM 生成物同样不得
+        // 把多行/超长内容写入仓库历史。
+        const check = checkCommitMessage(message);
+        if (!check.ok) {
+            return apiError(c, 502, 'INVALID_LLM_MESSAGE', `LLM returned invalid commit message: ${check.reason === 'TOO_LONG' ? '超过 500 字符' : '包含换行'}`);
+        }
         const suggestions = Array.isArray(parsed.ignoreSuggestions) ? parsed.ignoreSuggestions : [];
         // LLM 检测到可疑文件 → 阻断提交，返回供前端审查
         if (suggestions.length > 0) {
-            return c.json({ needsReview: true, message, suggestions });
+            return c.json({ needsReview: true, message: check.message, suggestions });
         }
         // 无可疑文件 → 直接提交
-        const result = performGitCommit(root, message);
+        const result = performGitCommit(root, check.message);
         if ('error' in result) {
             return apiError(c, 500, 'COMMIT_FAILED', result.error);
         }
@@ -374,9 +450,20 @@ ${summary.diff.slice(0, 8000)}`;
         try {
             if (raw) {
                 const buf = await readFile(resolved);
+                // P2 加固：raw 同源直出，nosniff 防「工作区内 html/svg 被浏览器当
+                // 活动文档执行」的同源 XSS 面；html 已改 octet-stream（见 contentTypeFor），
+                // svg 保留 image/svg+xml 供 <img> 预览（img 上下文中不执行脚本），
+                // 仅对 svg 附加沙箱 CSP 兜底「直接导航打开」场景。
+                const contentType = contentTypeFor(filePath);
                 return c.body(buf, 200, {
-                    'Content-Type': contentTypeFor(filePath),
+                    'Content-Type': contentType,
                     'Cache-Control': 'no-store',
+                    'X-Content-Type-Options': 'nosniff',
+                    ...(contentType === 'image/svg+xml'
+                        ? {
+                            'Content-Security-Policy': "sandbox; default-src 'none'; img-src data:; style-src 'unsafe-inline'",
+                        }
+                        : {}),
                 });
             }
             const content = await readFile(resolved, 'utf-8');
@@ -403,7 +490,16 @@ ${summary.diff.slice(0, 8000)}`;
         if (!resolved) {
             return apiError(c, 403, 'FORBIDDEN', 'Path outside workspace');
         }
-        const body = await c.req.json();
+        // P3-14：content 必须是字符串（此前 undefined/非字符串 → writeFile 抛
+        // 类型错误 → 500）；空串合法（清空文件）；超大写入给出明确错误而非 OOM。
+        const body = (await c.req.json().catch(() => null));
+        if (typeof body?.content !== 'string') {
+            return apiError(c, 400, 'BAD_REQUEST', 'content must be a string');
+        }
+        const MAX_WRITE_BYTES = 20 * 1024 * 1024;
+        if (Buffer.byteLength(body.content, 'utf8') > MAX_WRITE_BYTES) {
+            return apiError(c, 400, 'FILE_TOO_LARGE', '文件超过 20MB 上限，请用本地工具处理');
+        }
         try {
             await mkdir(dirname(resolved), { recursive: true });
             await writeFile(resolved, body.content, 'utf-8');

package/dist/server/routes/kanban.js

@@ -1,10 +1,97 @@
 // REST routes for the kanban board — frontend UI uses these for drag-and-drop
 // card operations, board config, and initial load.
+// P2-5：/deleted* 为看板回收站端点（必须注册在 /:projectId 之前避免被参数路由吞掉）。
+import { existsSync } from 'node:fs';
 import { Hono } from 'hono';
-import { createKanbanStore, KanbanColumnInUseError } from '../../kanban/index.js';
+import { createKanbanStore, getDeletedKanbanBoard, KanbanCardNotFoundError, KanbanColumnInUseError, KanbanColumnNotFoundError, KanbanInvalidPriorityError, listDeletedKanbanBoards, mergeKanbanBoard, permanentlyDeleteKanbanBoard, restoreKanbanBoard, } from '../../kanban/index.js';
+import { fromDirectory, getProject } from '../../project/index.js';
 import { apiError } from '../middleware/error.js';
 function createKanbanRoute(ctx) {
     const app = new Hono();
+    // GET /deleted — 回收站看板列表（项目删除软删除的看板，60 天保留期）。
+    app.get('/deleted', async (c) => {
+        return c.json({ boards: await listDeletedKanbanBoards(ctx.db) });
+    });
+    // POST /deleted/:boardId/restore — 恢复到指定项目，或「重建原项目」恢复。
+    // P1 修复：merge=true 时目标已有看板不再 409——缺失列与卡片并入现有看板
+    // （目标无板时等价普通恢复）。此前 409 指引「删除目标看板」但产品无此能力，
+    // 恢复是死胡同。
+    app.post('/deleted/:boardId/restore', async (c) => {
+        const body = (await c.req.json().catch(() => ({})));
+        const boardId = c.req.param('boardId');
+        const merge = body.merge === true;
+        // 重建原项目：目录仍存在时重建项目记录并恢复到该目录（与会话存储同语义）。
+        if (body.rebuild === true) {
+            const board = await getDeletedKanbanBoard(ctx.db, boardId);
+            if (!board)
+                return apiError(c, 404, 'BOARD_NOT_FOUND', '看板不存在或不在回收站');
+            if (!board.deletedProjectWorktree) {
+                return apiError(c, 400, 'NO_ORIGINAL_WORKTREE', '该看板未记录原项目目录，无法重建原项目；请改为恢复到现有项目');
+            }
+            if (!existsSync(board.deletedProjectWorktree)) {
+                return apiError(c, 409, 'ORIGINAL_DIR_MISSING', '原项目目录已不存在，无法重建；请改为恢复到现有项目');
+            }
+            const project = await fromDirectory(ctx.db, board.deletedProjectWorktree);
+            if (merge) {
+                const result = await mergeKanbanBoard(ctx.db, boardId, project.id);
+                if (result.ok) {
+                    return c.json({
+                        ok: true,
+                        merged: result,
+                        recreatedProject: { id: project.id, name: project.name },
+                    });
+                }
+                return apiError(c, 404, 'BOARD_NOT_FOUND', '看板不存在或不在回收站');
+            }
+            const result = await restoreKanbanBoard(ctx.db, boardId, project.id);
+            if (result.ok) {
+                return c.json({ ok: true, recreatedProject: { id: project.id, name: project.name } });
+            }
+            if (result.reason === 'TARGET_HAS_BOARD') {
+                return apiError(c, 409, 'TARGET_HAS_BOARD', '原项目已存在看板，无法覆盖');
+            }
+            return apiError(c, 404, 'BOARD_NOT_FOUND', '看板不存在或不在回收站');
+        }
+        const projectId = typeof body.projectId === 'string' && body.projectId ? body.projectId : '';
+        if (!projectId)
+            return apiError(c, 400, 'PROJECT_REQUIRED', '恢复目标项目（projectId）必填');
+        // P2 修复：目标项目必须存在（与会话恢复口径一致）——此前不校验，
+        // 可恢复出挂在不存在项目下、任何视图都不可见的看板。
+        const target = await getProject(ctx.db, projectId);
+        if (!target)
+            return apiError(c, 404, 'PROJECT_NOT_FOUND', '恢复目标项目不存在');
+        if (merge) {
+            const result = await mergeKanbanBoard(ctx.db, boardId, projectId);
+            if (result.ok)
+                return c.json({ ok: true, merged: result });
+            return apiError(c, 404, 'BOARD_NOT_FOUND', '看板不存在或不在回收站');
+        }
+        const result = await restoreKanbanBoard(ctx.db, boardId, projectId);
+        if (result.ok)
+            return c.json({ ok: true });
+        if (result.reason === 'TARGET_HAS_BOARD') {
+            return apiError(c, 409, 'TARGET_HAS_BOARD', '目标项目已有看板，请先导出/删除目标看板后再恢复');
+        }
+        return apiError(c, 404, 'BOARD_NOT_FOUND', '看板不存在或不在回收站');
+    });
+    // DELETE /deleted/:boardId — 彻底删除回收站看板（不可恢复）。
+    app.delete('/deleted/:boardId', async (c) => {
+        const count = await permanentlyDeleteKanbanBoard(ctx.db, c.req.param('boardId'));
+        if (count === 0)
+            return apiError(c, 404, 'BOARD_NOT_FOUND', '看板不存在或不在回收站');
+        return c.json({ ok: true });
+    });
+    // P1 修复：所有 /:projectId* 端点的项目存在守卫（注册在 /deleted* 之后）。
+    // 此前不存在的项目会穿透到 getOrCreateBoardId 的 insert，FK violation 抛 500
+    // 且错误信息回显 SQL——应为 404。
+    const guardProject = async (c, next) => {
+        const project = await getProject(ctx.db, c.req.param('projectId') ?? '');
+        if (!project)
+            return apiError(c, 404, 'PROJECT_NOT_FOUND', '项目不存在');
+        await next();
+    };
+    app.use('/:projectId', guardProject);
+    app.use('/:projectId/*', guardProject);
     // GET /:projectId — full board with cards
     app.get('/:projectId', async (c) => {
         const projectId = c.req.param('projectId');
@@ -14,10 +101,14 @@ function createKanbanRoute(ctx) {
     });
     // GET /:projectId/export — 看板 JSON 导出（项目删除会永久级联删除看板，
     // 会话有 60 天回收站而看板没有——导出是唯一的备份途径）。
+    // peek 语义：纯读不懒建板——导出从未初始化看板的项目此前会凭空产生空板行。
     app.get('/:projectId/export', async (c) => {
         const projectId = c.req.param('projectId');
         const store = createKanbanStore(ctx.db, projectId);
-        const board = await store.getBoard();
+        const board = await store.peekBoard();
+        if (!board) {
+            return apiError(c, 404, 'BOARD_NOT_FOUND', '该项目尚未初始化看板');
+        }
         return c.json({
             version: 1,
             exportedAt: new Date().toISOString(),
@@ -34,6 +125,20 @@ function createKanbanRoute(ctx) {
         if (body?.version !== 1 || !Array.isArray(body.columns) || !Array.isArray(body.cards)) {
             return apiError(c, 400, 'INVALID_EXPORT', '无效的看板导出 JSON：需要 version/columns/cards 字段');
         }
+        // P3：导入体积上限——与会话导入（messages/archives 上限）同口径。
+        // 无上限的数组会让 replaceBoard 的单事务逐条重建 OOM/长事务拖垮 PGLite。
+        const MAX_IMPORT_COLUMNS = 100;
+        const MAX_IMPORT_LABELS = 200;
+        const MAX_IMPORT_CARDS = 20000;
+        if (body.columns.length > MAX_IMPORT_COLUMNS) {
+            return apiError(c, 400, 'IMPORT_TOO_LARGE', `导入列数 ${body.columns.length} 超过上限 ${MAX_IMPORT_COLUMNS}`);
+        }
+        if (Array.isArray(body.labels) && body.labels.length > MAX_IMPORT_LABELS) {
+            return apiError(c, 400, 'IMPORT_TOO_LARGE', `导入标签数 ${body.labels.length} 超过上限 ${MAX_IMPORT_LABELS}`);
+        }
+        if (body.cards.length > MAX_IMPORT_CARDS) {
+            return apiError(c, 400, 'IMPORT_TOO_LARGE', `导入卡片数 ${body.cards.length} 超过上限 ${MAX_IMPORT_CARDS}`);
+        }
         const columns = body.columns;
         const labels = Array.isArray(body.labels) ? body.labels : [];
         // 宽松校验卡片：只保留结构完整的条目（导入宁少勿坏，与会话导入一致）。
@@ -93,14 +198,25 @@ function createKanbanRoute(ctx) {
         if (!title)
             return apiError(c, 400, 'INVALID_INPUT', 'title is required');
         const store = createKanbanStore(ctx.db, projectId);
-        const card = await store.addCard({
-            title,
-            description: body.description ?? null,
-            columnId: body.columnId,
-            priority: body.priority,
-            labels: body.labels,
-        });
-        return c.json(card, 201);
+        try {
+            const card = await store.addCard({
+                title,
+                description: body.description ?? null,
+                columnId: body.columnId,
+                priority: body.priority,
+                labels: body.labels,
+            });
+            return c.json(card, 201);
+        }
+        catch (err) {
+            if (err instanceof KanbanColumnNotFoundError) {
+                return apiError(c, 400, 'KANBAN_COLUMN_NOT_FOUND', err.message);
+            }
+            if (err instanceof KanbanInvalidPriorityError) {
+                return apiError(c, 400, 'INVALID_PRIORITY', err.message);
+            }
+            throw err;
+        }
     });
     // PATCH /:projectId/cards/:cardId — update card fields or move
     app.patch('/:projectId/cards/:cardId', async (c) => {
@@ -108,20 +224,34 @@ function createKanbanRoute(ctx) {
         const cardId = c.req.param('cardId');
         const body = await c.req.json().catch(() => ({}));
         const store = createKanbanStore(ctx.db, projectId);
-        // columnId + position → moveCard; otherwise field update.
-        if (body.columnId !== undefined) {
-            const card = await store.moveCard(cardId, body.columnId, body.position);
+        try {
+            // columnId + position → moveCard; otherwise field update.
+            if (body.columnId !== undefined) {
+                const card = await store.moveCard(cardId, body.columnId, body.position);
+                return c.json(card);
+            }
+            const card = await store.updateCard(cardId, {
+                ...(body.title !== undefined && { title: body.title }),
+                ...(body.description !== undefined && {
+                    description: body.description,
+                }),
+                ...(body.priority !== undefined && { priority: body.priority }),
+                ...(body.labels !== undefined && { labels: body.labels }),
+            });
             return c.json(card);
         }
-        const card = await store.updateCard(cardId, {
-            ...(body.title !== undefined && { title: body.title }),
-            ...(body.description !== undefined && {
-                description: body.description,
-            }),
-            ...(body.priority !== undefined && { priority: body.priority }),
-            ...(body.labels !== undefined && { labels: body.labels }),
-        });
-        return c.json(card);
+        catch (err) {
+            if (err instanceof KanbanCardNotFoundError) {
+                return apiError(c, 404, 'CARD_NOT_FOUND', err.message);
+            }
+            if (err instanceof KanbanColumnNotFoundError) {
+                return apiError(c, 400, 'KANBAN_COLUMN_NOT_FOUND', err.message);
+            }
+            if (err instanceof KanbanInvalidPriorityError) {
+                return apiError(c, 400, 'INVALID_PRIORITY', err.message);
+            }
+            throw err;
+        }
     });
     // DELETE /:projectId/cards/:cardId — delete a card
     app.delete('/:projectId/cards/:cardId', async (c) => {

package/dist/server/routes/permissions.js

@@ -1,6 +1,7 @@
 import { eq } from 'drizzle-orm';
 import { Hono } from 'hono';
 import { sessions } from '../../db/schema.js';
+import { getSession } from '../../session/session.js';
 import { apiError } from '../middleware/error.js';
 /** GET/PUT /api/permissions — 授权模式（default 逐个确认 / auto 自动放行 ask 工具）。
  *  - 根路径：全局默认模式（启动时取 config.permission.defaultMode；
@@ -104,6 +105,12 @@ function createPermissionsRoute(ctx) {
     // PUT /:sessionId — 设置会话级覆盖；不传 mode 则清除覆盖。P2：落库持久化。
     app.put('/:sessionId', async (c) => {
         const sessionId = c.req.param('sessionId');
+        // P3-11 修复：校验会话存在——此前对不存在的 id 设置 auto 也返回成功，
+        // 用户以为已生效，重启后无任何痕迹。回收站会话同口径 404。
+        const session = await getSession(ctx.db, sessionId);
+        if (!session || session.deletedAt) {
+            return apiError(c, 404, 'NOT_FOUND', '会话不存在或已删除');
+        }
         const body = (await c.req.json().catch(() => null));
         const mode = body?.mode;
         if (mode !== undefined && mode !== 'default' && mode !== 'auto') {