c0de-agent 1.11.0 → 1.13.0

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

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

package/dist/server/routes/commands.js

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

package/dist/server/routes/config.js

@@ -1,6 +1,10 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { Hono } from 'hono';
-import { applyScopedPatch, 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 { getByDirectory, getProject, trustProject } from '../../project/index.js';
 import { apiError } from '../middleware/error.js';
 import { syncRegistryFromConfig } from '../server.js';
 /** 检查每个 provider 的 apiKey 能否在本机解密（机器绑定密钥换机/容器重建后会失败）。 */
@@ -13,31 +17,146 @@ function providerApiKeyWarnings(providers) {
             decryptSecret(p.apiKey);
         }
         catch {
-            warnings.push(`provider "${p.name || '(未命名)'}" 的 API Key 无法在本机解密（密钥与机器绑定）。` +
-                '若配置来自其他机器或容器重建，请重新填写 API Key。');
+            warnings.push(`provider "${p.name || ''}" 的 apiKey 无法在本机解密（配置来自其他机器），请重新设置`);
         }
     }
     return warnings;
 }
+/** 项目级配置含密钥且位于 git 仓库内时提示 .gitignore（防误提交）。 */
+function projectConfigGitWarning(project, cwd) {
+    if (!project || !containsSecrets(project))
+        return null;
+    let dir = cwd;
+    while (true) {
+        if (existsSync(join(dir, '.git'))) {
+            return ('项目级配置（.c0de/config.json）含 API Key/Token 且位于 git 仓库内，' +
+                '建议将 .c0de/ 加入 .gitignore，防止密钥被误提交。');
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+/**
+ * 解析配置读取/写入的目标目录（P1-1 多项目配置贯通）：
+ * - projectId 提供且存在 → 该项目 worktree（配置读写与设置页展示都对准该项目）。
+ * - 否则 → 服务启动目录（向后兼容：serve cwd 项目与全局作用域）。
+ */
+async function resolveConfigDir(ctx, projectId) {
+    if (projectId) {
+        const project = await getProject(ctx.db, projectId);
+        if (!project)
+            return null;
+        return { dir: project.worktree, isProjectScoped: true };
+    }
+    return { dir: ctx.cwd, isProjectScoped: false };
+}
 function createConfigRoute(ctx) {
     const app = new Hono();
-    // GET / — 合并后配置 + 作用域信息 + apiKey 解密警告
-    app.get('/', (c) => {
-        const scopes = loadConfigScopes(ctx.cwd);
+    // GET / — 合并后配置 + 作用域信息 + apiKey 解密警告 + git 误提交警告。
+    // ?projectId= 时读取该项目的 global+project 作用域（默认读取服务启动目录项目，
+    // 复用服务内存合并配置 ctx.config）。
+    app.get('/', async (c) => {
+        const projectId = c.req.query('projectId');
+        const target = await resolveConfigDir(ctx, projectId);
+        if (!target)
+            return apiError(c, 404, 'PROJECT_NOT_FOUND', '项目不存在');
+        const scopes = loadConfigScopes(target.dir);
+        const config = projectId ? mergeConfig(scopes.global, scopes.project) : ctx.config;
+        // 未知顶层键告警并入 warnings：用户在设置页即可看到拼写错误/过时键，不必看终端日志。
+        const unknownWarnings = [
+            ...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: ctx.config,
+            config,
             scopes: {
                 global: scopes.global ?? null,
                 project: scopes.project ?? null,
             },
-            warnings: providerApiKeyWarnings(ctx.config.providers),
+            warnings: [
+                ...providerApiKeyWarnings(config.providers),
+                ...globalBudgetWarnings,
+                ...securityWarnings,
+                ...unknownWarnings,
+                ...migrationWarnings,
+                ...providerWarnings,
+                ...budgetScopeWarnings,
+            ],
+            gitWarning: projectConfigGitWarning(loadProjectRawScope(target.dir), target.dir),
+            projectDir: target.isProjectScoped ? target.dir : undefined,
         });
     });
     // PATCH / — 按作用域写入。body.scope: 'global' | 'project'（默认 project，兼容旧客户端）。
+    // body.projectId：目标项目（P1-1；缺省 = 服务启动目录项目）。
+    // 仅当写入目标是服务启动目录项目时同步服务级内存配置与 LLM registry——
+    // 其他项目的配置不污染服务级 provider 注册表（会话级按需解析）。
     app.patch('/', async (c) => {
         const body = (await c.req.json());
         const scope = body.scope === 'global' ? 'global' : 'project';
-        const { scope: _omit, ...patch } = body;
+        const { scope: _omit, projectId, ...patch } = body;
+        // 未知顶层键拒绝：拼写错误/过时键经此路径写入只会埋雷（永不生效且难发现）。
+        const unknown = collectUnknownConfigKeys(patch);
+        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)) {
@@ -46,32 +165,70 @@ function createConfigRoute(ctx) {
         // 按作用域最小落盘：patch 只合并进指定作用域原始文件，
         // 不把合并结果（含默认值/另一作用域配置）整体序列化进文件。
         // null 值 = 删除该作用域中的键（回落到另一作用域/默认值）。
-        const scopes = loadConfigScopes(ctx.cwd);
+        const target = await resolveConfigDir(ctx, projectId);
+        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);
         // P2-3：落盘失败必须反馈给前端（此前静默吞掉，UI 显示已保存但重启后丢失）。
         // 先落盘、成功后才更新内存配置与 registry，保证「已保存」反馈与磁盘状态一致。
         try {
-            await saveConfigScoped(scope, ctx.cwd, nextScoped);
+            await saveConfigScoped(scope, target.dir, nextScoped);
         }
         catch (err) {
             return apiError(c, 500, 'CONFIG_SAVE_FAILED', `配置保存失败：${err instanceof Error ? err.message : String(err)}`);
         }
-        ctx.config =
-            scope === 'global'
-                ? mergeConfig(nextScoped, scopes.project)
-                : mergeConfig(scopes.global, nextScoped);
-        // providers 变更后原地同步 registry，使运行中的连接立即生效
-        syncRegistryFromConfig(ctx.llmRegistry, ctx.config);
-        // 安全类配置（token/authEnabled/allowedOrigins）由 authManager 在启动时一次性读取，
-        // 运行时修改不生效——告知前端提示重启。
-        const needsRestart = patch.security !== undefined;
+        // 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 注册表），
+            // 按服务启动目录作用域重建 ctx.config 并同步 registry。
+            const serverScopes = loadConfigScopes(ctx.cwd);
+            ctx.config = mergeConfig(serverScopes.global, serverScopes.project);
+            syncRegistryFromConfig(ctx.llmRegistry, ctx.config);
+            // P1 修复：权限默认模式运行时同步——设置页保存后立即生效，
+            // 与草稿页底栏开关（PUT /api/permissions，既持久化又即时生效）语义一致。
+            // 此前仅落盘、ctx.permissionMode 仍为启动值，UI 显示已保存但弹窗照旧。
+            ctx.permissionMode = ctx.config.permission.defaultMode;
+            // 项目级注册表基于全局作用域构建，global 变更后全部失效。
+            ctx.projectRegistries?.clear();
+        }
+        else if (projectId) {
+            // 项目作用域写入：该项目的会话级注册表缓存失效。
+            ctx.projectRegistries?.delete(projectId);
+        }
+        const freshScopes = loadConfigScopes(target.dir);
+        const merged = mergeConfig(freshScopes.global, freshScopes.project);
+        // 启动时一次性读取的配置：运行时修改不生效——告知前端提示重启。
+        //  - security：authManager/CORS 在启动时构建
+        //  - update：调度器 interval 与 handoff server 在启动时构建
+        //  - plugins：hookRunner/插件生命周期在启动时初始化
+        // 仅当写入影响运行中的服务级配置（服务启动目录项目或 global 作用域）时提示。
+        const needsRestart = (isServerCwdProject || scope === 'global') &&
+            (patch.security !== undefined || patch.update !== undefined || patch.plugins !== undefined);
         return c.json({
-            config: ctx.config,
-            scope,
+            config: merged,
+            scopes: {
+                global: freshScopes.global ?? null,
+                project: freshScopes.project ?? null,
+            },
+            warnings: providerApiKeyWarnings(merged.providers),
             needsRestart,
-            warnings: providerApiKeyWarnings(ctx.config.providers),
+            projectDir: target.isProjectScoped ? target.dir : undefined,
         });
     });
     return app;

package/dist/server/routes/files.js

@@ -3,15 +3,38 @@ import { dirname, join, relative } from 'node:path';
 import { Hono } from 'hono';
 import trash from 'trash';
 import { createSummarizer } from '../../core/compact.js';
+import { loadConfigScopes, mergeConfig } from '../../core/config.js';
+import { buildFallbackChain } from '../../llm/routing.js';
 import { getProject } from '../../project/project.js';
 import { appendToGitignore, checkIgnored, checkoutGitBranch, createGitBranch, getGitBranch, getGitDiffSummary, getGitLastCommit, getGitStatus, listGitBranches, performGitCommit, } from '../../project/resolve.js';
 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;
@@ -22,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' });
@@ -55,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',
@@ -63,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 返回空对象）
@@ -125,44 +195,54 @@ 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,
             });
         }
         // --- 默认模式：LLM 生成 message + 检查可疑文件 ---
-        const cm = ctx.config.commitModel;
-        const provider = cm?.provider ?? ctx.config.defaultProvider;
-        const model = cm?.model ?? ctx.config.defaultModel;
+        // P1-1：commitModel/defaultProvider 按项目配置解析（此前一律用服务启动目录配置）。
+        let projectConfig = ctx.config;
+        if (root !== ctx.cwd) {
+            const projectScope = loadConfigScopes(root).project;
+            if (projectScope)
+                projectConfig = mergeConfig(ctx.config, projectScope);
+        }
+        const cm = projectConfig.commitModel;
+        const provider = cm?.provider ?? projectConfig.defaultProvider;
+        const model = cm?.model ?? projectConfig.defaultModel;
         const prompt = `Based on the following git diff, generate a concise commit message in conventional-commits format (e.g. "feat: add login page").
 
 ALSO review the changed/new files: are any of them files that SHOULD be in .gitignore but are currently missing? (e.g. secrets, .env, build output, dependencies, temp files, large binaries)
@@ -175,7 +255,15 @@ If no files need ignoring, return an empty array for ignoreSuggestions.
 ${summary.diff.slice(0, 8000)}`;
         let raw;
         try {
-            const summarizer = createSummarizer(ctx.llmRegistry, provider, model, { maxTokens: 400 });
+            // P1-1：项目级 provider 注册表（项目配置的 provider 才能路由）。
+            const registry = root !== ctx.cwd && projectConfig.providers.length > 0
+                ? buildRegistryFromConfig(projectConfig)
+                : ctx.llmRegistry;
+            const fallback = buildFallbackChain(projectConfig, provider, model);
+            const summarizer = createSummarizer(registry, provider, model, {
+                maxTokens: 400,
+                ...(fallback ? { fallback } : {}),
+            });
             raw = (await summarizer(prompt)).trim();
         }
         catch (err) {
@@ -198,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);
         }
@@ -356,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');
@@ -385,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');