c0de-agent 1.10.0 → 1.12.0

package/dist/server/routes/commands.js

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

package/dist/server/routes/config.js

@@ -1,30 +1,158 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { Hono } from 'hono';
-import { loadConfigScopes, mergeConfig, mergeRaw, saveConfigScoped } from '../../core/config.js';
-import { encryptSecret, isEncryptedSecret } from '../../core/secret.js';
+import { applyScopedPatch, collectUnknownConfigKeys, KNOWN_CONFIG_KEYS, loadConfigScopes, mergeConfig, 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 { apiError } from '../middleware/error.js';
 import { syncRegistryFromConfig } from '../server.js';
+/** 检查每个 provider 的 apiKey 能否在本机解密（机器绑定密钥换机/容器重建后会失败）。 */
+function providerApiKeyWarnings(providers) {
+    const warnings = [];
+    for (const p of providers) {
+        if (!p.apiKey || !isEncryptedSecret(p.apiKey))
+            continue;
+        try {
+            decryptSecret(p.apiKey);
+        }
+        catch {
+            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();
-    app.get('/', (c) => {
-        return c.json(ctx.config);
+    // 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}"，不会生效`),
+        ];
+        return c.json({
+            config,
+            scopes: {
+                global: scopes.global ?? null,
+                project: scopes.project ?? null,
+            },
+            warnings: [...providerApiKeyWarnings(config.providers), ...unknownWarnings],
+            gitWarning: projectConfigGitWarning(scopes.project, 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 patch = (await c.req.json());
+        const body = (await c.req.json());
+        const scope = body.scope === 'global' ? 'global' : 'project';
+        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(', ')}`);
+        }
         // spec §24.2：provider apiKey 落盘前加密，明文不持久化。
         // 已加密（enc: 前缀）或无 apiKey 的透传。
         if (Array.isArray(patch.providers)) {
             patch.providers = patch.providers.map((p) => p.apiKey && !isEncryptedSecret(p.apiKey) ? { ...p, apiKey: encryptSecret(p.apiKey) } : p);
         }
-        // 按作用域最小落盘：patch 只合并进项目作用域原始文件，
-        // 不把合并结果（含默认值/global 配置）整体序列化进项目文件。
-        const scopes = loadConfigScopes(ctx.cwd);
-        const nextProject = mergeRaw(scopes.project ?? {}, patch);
-        ctx.config = mergeConfig(scopes.global, nextProject);
-        // providers 变更后原地同步 registry，使运行中的连接立即生效
-        syncRegistryFromConfig(ctx.llmRegistry, ctx.config);
-        await saveConfigScoped('project', ctx.cwd, nextProject).catch(() => {
-            // 保存失败不影响内存配置
+        // 按作用域最小落盘：patch 只合并进指定作用域原始文件，
+        // 不把合并结果（含默认值/另一作用域配置）整体序列化进文件。
+        // null 值 = 删除该作用域中的键（回落到另一作用域/默认值）。
+        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, target.dir, nextScoped);
+        }
+        catch (err) {
+            return apiError(c, 500, 'CONFIG_SAVE_FAILED', `配置保存失败：${err instanceof Error ? err.message : String(err)}`);
+        }
+        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: merged,
+            scopes: {
+                global: freshScopes.global ?? null,
+                project: freshScopes.project ?? null,
+            },
+            warnings: providerApiKeyWarnings(merged.providers),
+            needsRestart,
+            projectDir: target.isProjectScoped ? target.dir : undefined,
         });
-        return c.json(ctx.config);
     });
     return app;
 }

package/dist/server/routes/files.js

@@ -3,9 +3,12 @@ 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']);
@@ -160,9 +163,16 @@ function createFilesRoute(ctx) {
             });
         }
         // --- 默认模式：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 +185,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) {

package/dist/server/routes/kanban.js

@@ -1,7 +1,7 @@
 // REST routes for the kanban board — frontend UI uses these for drag-and-drop
 // card operations, board config, and initial load.
 import { Hono } from 'hono';
-import { createKanbanStore } from '../../kanban/index.js';
+import { createKanbanStore, KanbanColumnInUseError } from '../../kanban/index.js';
 import { apiError } from '../middleware/error.js';
 function createKanbanRoute(ctx) {
     const app = new Hono();
@@ -12,16 +12,78 @@ function createKanbanRoute(ctx) {
         const board = await store.getBoard();
         return c.json(board);
     });
+    // GET /:projectId/export — 看板 JSON 导出（项目删除会永久级联删除看板，
+    // 会话有 60 天回收站而看板没有——导出是唯一的备份途径）。
+    app.get('/:projectId/export', async (c) => {
+        const projectId = c.req.param('projectId');
+        const store = createKanbanStore(ctx.db, projectId);
+        const board = await store.getBoard();
+        return c.json({
+            version: 1,
+            exportedAt: new Date().toISOString(),
+            projectId,
+            columns: board.columns,
+            labels: board.labels,
+            cards: board.cards.map(({ id: _id, boardId: _b, createdAt: _c, updatedAt: _u, ...card }) => card),
+        });
+    });
+    // POST /:projectId/import — 导入/替换整板（列+标签+卡片原子重建）。
+    app.post('/:projectId/import', async (c) => {
+        const projectId = c.req.param('projectId');
+        const body = (await c.req.json().catch(() => null));
+        if (body?.version !== 1 || !Array.isArray(body.columns) || !Array.isArray(body.cards)) {
+            return apiError(c, 400, 'INVALID_EXPORT', '无效的看板导出 JSON：需要 version/columns/cards 字段');
+        }
+        const columns = body.columns;
+        const labels = Array.isArray(body.labels) ? body.labels : [];
+        // 宽松校验卡片：只保留结构完整的条目（导入宁少勿坏，与会话导入一致）。
+        const cards = body.cards
+            .filter((card) => card !== null &&
+            typeof card === 'object' &&
+            typeof card.title === 'string' &&
+            card.title.length > 0 &&
+            typeof card.columnId === 'string' &&
+            typeof card.priority === 'string')
+            .map((card) => ({
+            title: card.title,
+            description: typeof card.description === 'string' ? card.description : null,
+            columnId: card.columnId,
+            priority: (card.priority === 'high' || card.priority === 'medium' || card.priority === 'low'
+                ? card.priority
+                : 'medium'),
+            position: typeof card.position === 'number' ? card.position : 0,
+            labels: Array.isArray(card.labels)
+                ? card.labels.filter((l) => typeof l === 'string')
+                : [],
+        }));
+        // 卡片只能落在导入的列上——悬空列会导致卡片静默不可见（与列删除保护同理）。
+        const columnIds = new Set(columns.map((col) => col.id));
+        const orphanCards = cards.filter((card) => !columnIds.has(card.columnId));
+        if (orphanCards.length > 0) {
+            return apiError(c, 400, 'INVALID_CARDS', `${orphanCards.length} 张卡片引用了不存在的列（${[...new Set(orphanCards.map((x) => x.columnId))].join(', ')}）`);
+        }
+        const store = createKanbanStore(ctx.db, projectId);
+        const board = await store.replaceBoard({ columns, labels, cards });
+        return c.json({ ok: true, cardCount: board.cards.length });
+    });
     // PATCH /:projectId — update board columns/labels config
     app.patch('/:projectId', async (c) => {
         const projectId = c.req.param('projectId');
         const body = await c.req.json().catch(() => ({}));
         const store = createKanbanStore(ctx.db, projectId);
-        const board = await store.updateBoard({
-            ...(body.columns !== undefined && { columns: body.columns }),
-            ...(body.labels !== undefined && { labels: body.labels }),
-        });
-        return c.json(board);
+        try {
+            const board = await store.updateBoard({
+                ...(body.columns !== undefined && { columns: body.columns }),
+                ...(body.labels !== undefined && { labels: body.labels }),
+            });
+            return c.json(board);
+        }
+        catch (err) {
+            if (err instanceof KanbanColumnInUseError) {
+                return apiError(c, 409, 'KANBAN_COLUMN_IN_USE', err.message);
+            }
+            throw err;
+        }
     });
     // POST /:projectId/cards — add a card
     app.post('/:projectId/cards', async (c) => {

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

@@ -1,5 +1,4 @@
 import { Hono } from 'hono';
 import type { ServerContext } from '../types.js';
-/** GET/PUT /api/permissions — 全局授权模式（default 逐个确认 / auto 自动放行 ask 工具）。 */
 declare function createPermissionsRoute(ctx: ServerContext): Hono;
 export { createPermissionsRoute };

package/dist/server/routes/permissions.js

@@ -1,14 +1,76 @@
+import { eq } from 'drizzle-orm';
 import { Hono } from 'hono';
+import { sessions } from '../../db/schema.js';
 import { apiError } from '../middleware/error.js';
-/** GET/PUT /api/permissions — 全局授权模式（default 逐个确认 / auto 自动放行 ask 工具）。 */
+/** GET/PUT /api/permissions — 授权模式（default 逐个确认 / auto 自动放行 ask 工具）。
+ *  - 根路径：全局默认模式（启动时取 config.permission.defaultMode；
+ *    PUT / 持久化到 global 作用域 config，重启后仍生效）
+ *  - /:sessionId：会话级覆盖（P1-5 按会话隔离 auto 高风险状态）。
+ *    P2：会话级覆盖持久化到 session.metadata.permissionMode，重启后经 GET 或
+ *    chat 路由懒加载恢复——此前仅内存 Map，重启静默回退 default，用户困惑。
+ *  - /:sessionId/always-allow：会话级「始终允许」工具白名单（P2 权限疲劳治理），
+ *    持久化到 session.metadata.alwaysAllow，checker 经 getter 实时读取。
+ */
+/** 懒加载会话级权限覆盖到内存 Map（幂等；查询失败静默回退默认语义）。 */
+async function ensureSessionModeLoaded(ctx, sessionId) {
+    if (ctx.sessionPermissionModes.has(sessionId))
+        return;
+    try {
+        const [row] = await ctx.db.db
+            .select({ metadata: sessions.metadata })
+            .from(sessions)
+            .where(eq(sessions.id, sessionId));
+        const mode = row?.metadata
+            ?.permissionMode;
+        if (mode === 'auto' || mode === 'default') {
+            ctx.sessionPermissionModes.set(sessionId, mode);
+        }
+    }
+    catch {
+        // 会话不存在/查询失败：回退默认模式
+    }
+}
+/** 懒加载会话级始终允许白名单到内存 Map（幂等；失败回退空列表）。 */
+async function ensureSessionAllowLoaded(ctx, sessionId) {
+    if (ctx.sessionAlwaysAllow.has(sessionId))
+        return;
+    try {
+        const [row] = await ctx.db.db
+            .select({ metadata: sessions.metadata })
+            .from(sessions)
+            .where(eq(sessions.id, sessionId));
+        const list = row?.metadata?.alwaysAllow;
+        ctx.sessionAlwaysAllow.set(sessionId, Array.isArray(list) ? list.filter((t) => typeof t === 'string') : []);
+    }
+    catch {
+        ctx.sessionAlwaysAllow.set(sessionId, []);
+    }
+}
+/** 持久化会话 metadata（失败不致命：内存态本次运行仍生效）。 */
+async function persistSessionMetadata(ctx, sessionId, mutate) {
+    try {
+        const [row] = await ctx.db.db
+            .select({ metadata: sessions.metadata })
+            .from(sessions)
+            .where(eq(sessions.id, sessionId));
+        if (!row)
+            return;
+        const meta = { ...(row.metadata ?? {}) };
+        mutate(meta);
+        await ctx.db.db.update(sessions).set({ metadata: meta }).where(eq(sessions.id, sessionId));
+    }
+    catch {
+        // 持久化失败不致命
+    }
+}
 function createPermissionsRoute(ctx) {
     const app = new Hono();
-    // GET / — 当前授权模式
+    // GET / — 默认授权模式
     app.get('/', (c) => {
         return c.json({ mode: ctx.permissionMode });
     });
-    // PUT / — 运行时切换授权模式（仅本次运行生效，不回写 config；
-    // 重启后回到 config.permission.defaultMode 持久化默认值）
+    // PUT / — 设置全局默认授权模式（P1-4：持久化到 global 作用域 config）。
+    // 此前仅本次运行生效、重启静默回退，与同款控件在会话页的持久化语义相悖。
     app.put('/', async (c) => {
         const body = (await c.req.json().catch(() => null));
         const mode = body?.mode;
@@ -16,8 +78,95 @@ function createPermissionsRoute(ctx) {
             return apiError(c, 400, 'INVALID_MODE', "mode 必须是 'default' 或 'auto'");
         }
         ctx.permissionMode = mode;
+        try {
+            const { applyScopedPatch, loadConfigScopes, saveConfigScoped } = await import('../../core/config.js');
+            const scopes = loadConfigScopes(ctx.cwd);
+            const next = applyScopedPatch(scopes.global ?? {}, {
+                permission: { defaultMode: mode },
+            });
+            await saveConfigScoped('global', ctx.cwd, next);
+        }
+        catch {
+            // 持久化失败不致命：本次运行仍生效（与 /:sessionId 覆盖的降级语义一致）
+        }
         return c.json({ mode: ctx.permissionMode });
     });
+    // GET /:sessionId — 会话实际生效模式（覆盖优先，回退默认）+ 始终允许白名单
+    app.get('/:sessionId', async (c) => {
+        const sessionId = c.req.param('sessionId');
+        await ensureSessionModeLoaded(ctx, sessionId);
+        await ensureSessionAllowLoaded(ctx, sessionId);
+        return c.json({
+            mode: ctx.sessionPermissionModes.get(sessionId) ?? ctx.permissionMode,
+            alwaysAllow: ctx.sessionAlwaysAllow.get(sessionId) ?? [],
+        });
+    });
+    // PUT /:sessionId — 设置会话级覆盖；不传 mode 则清除覆盖。P2：落库持久化。
+    app.put('/:sessionId', async (c) => {
+        const sessionId = c.req.param('sessionId');
+        const body = (await c.req.json().catch(() => null));
+        const mode = body?.mode;
+        if (mode !== undefined && mode !== 'default' && mode !== 'auto') {
+            return apiError(c, 400, 'INVALID_MODE', "mode 必须是 'default' 或 'auto'");
+        }
+        if (mode === undefined) {
+            ctx.sessionPermissionModes.delete(sessionId);
+        }
+        else {
+            ctx.sessionPermissionModes.set(sessionId, mode);
+        }
+        // 持久化：写 session.metadata.permissionMode（无该字段时删除，回退全局默认）。
+        // 失败仅影响重启后的恢复，本次运行的 Map 状态仍生效。
+        await persistSessionMetadata(ctx, sessionId, (meta) => {
+            if (mode === undefined) {
+                delete meta.permissionMode;
+            }
+            else {
+                meta.permissionMode = mode;
+            }
+        });
+        return c.json({ mode: ctx.sessionPermissionModes.get(sessionId) ?? ctx.permissionMode });
+    });
+    // GET /:sessionId/pending — 查询会话当前挂起的权限请求（P1：挂起期间切换页面/
+    // 刷新后前端重挂确认弹窗，恢复被阻塞 run 的可操作路径。无挂起返回 pending: null。
+    app.get('/:sessionId/pending', (c) => {
+        const sessionId = c.req.param('sessionId');
+        const pending = ctx.permissionStore.pendingForSession(sessionId);
+        return c.json({ pending });
+    });
+    // POST /:sessionId/always-allow — 追加工具到会话白名单（幂等）
+    app.post('/:sessionId/always-allow', async (c) => {
+        const sessionId = c.req.param('sessionId');
+        const body = (await c.req.json().catch(() => null));
+        const tool = body?.tool;
+        if (typeof tool !== 'string' || tool.length === 0) {
+            return apiError(c, 400, 'BAD_REQUEST', 'tool is required');
+        }
+        await ensureSessionAllowLoaded(ctx, sessionId);
+        const list = ctx.sessionAlwaysAllow.get(sessionId) ?? [];
+        if (!list.includes(tool))
+            list.push(tool);
+        ctx.sessionAlwaysAllow.set(sessionId, list);
+        await persistSessionMetadata(ctx, sessionId, (meta) => {
+            meta.alwaysAllow = list;
+        });
+        return c.json({ alwaysAllow: list });
+    });
+    // DELETE /:sessionId/always-allow/:tool — 从会话白名单移除
+    app.delete('/:sessionId/always-allow/:tool', async (c) => {
+        const sessionId = c.req.param('sessionId');
+        const tool = c.req.param('tool');
+        await ensureSessionAllowLoaded(ctx, sessionId);
+        const list = (ctx.sessionAlwaysAllow.get(sessionId) ?? []).filter((t) => t !== tool);
+        ctx.sessionAlwaysAllow.set(sessionId, list);
+        await persistSessionMetadata(ctx, sessionId, (meta) => {
+            if (list.length === 0)
+                delete meta.alwaysAllow;
+            else
+                meta.alwaysAllow = list;
+        });
+        return c.json({ alwaysAllow: list });
+    });
     return app;
 }
 export { createPermissionsRoute };

package/dist/server/routes/project.js

@@ -1,10 +1,17 @@
+// src/server/routes/project.ts
+import { existsSync } from 'node:fs';
+import { and, eq, isNull } from 'drizzle-orm';
 import { Hono } from 'hono';
-import { fromDirectory, getProject, listProjects, resolveProject, updateProjectName, } from '../../project/index.js';
+import { kanbanBoards, projects, sessions } from '../../db/schema.js';
+import { fromDirectory, getProject, listProjects, relocateProject, resolveProject, updateProjectName, } from '../../project/index.js';
+import { clearTrashMarks } from '../../session/session.js';
+import { generateId } from '../../shared/index.js';
 import { apiError } from '../middleware/error.js';
 import { expandPath } from './filesystem.js';
-/** 实时取 git 分支（分支随时变，不存 DB）。 */
+/** 实时取 git 分支（分支随时变，不存 DB）。worktree 不存在时标记缺失。 */
 function withBranch(project) {
-    return { ...project, gitBranch: resolveProject(project.worktree).gitBranch };
+    const worktreeMissing = !existsSync(project.worktree);
+    return { ...project, gitBranch: resolveProject(project.worktree).gitBranch, worktreeMissing };
 }
 function createProjectRoute(ctx) {
     const app = new Hono();
@@ -46,6 +53,102 @@ function createProjectRoute(ctx) {
             return apiError(c, 404, 'NOT_FOUND', 'Project not found');
         return c.json(withBranch(project));
     });
+    // A1：项目重新定位——目录被移动/重命名后的恢复通道。
+    // 整体迁移会话与看板到新目录身份（替代「删项目 + 逐条恢复 + 看板丢失」）。
+    // 目标目录已注册为另一项目 → 409；有活跃 run → 拒绝（agent 工作目录悬空）。
+    app.post('/:id/relocate', async (c) => {
+        const id = c.req.param('id');
+        const body = (await c.req.json().catch(() => ({})));
+        const directory = typeof body.directory === 'string' ? body.directory.trim() : '';
+        if (!directory)
+            return apiError(c, 400, 'DIRECTORY_REQUIRED', 'directory is required');
+        if (!existsSync(directory)) {
+            return apiError(c, 400, 'DIRECTORY_MISSING', `目录不存在或不可访问：${directory}`);
+        }
+        // 活跃 run 守卫（与 DELETE 同语义）
+        const rows = await ctx.db.db
+            .select({ id: sessions.id })
+            .from(sessions)
+            .where(eq(sessions.projectId, id));
+        const activeCount = rows.filter((r) => ctx.agentManager.get(r.id)).length;
+        if (activeCount > 0) {
+            return apiError(c, 409, 'PROJECT_HAS_ACTIVE_SESSIONS', `项目下有 ${activeCount} 个进行中的对话，请先中止后再重新定位`);
+        }
+        try {
+            const project = await relocateProject(ctx.db, id, directory);
+            return c.json({ ok: true, project: withBranch(project) });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg === 'PROJECT_NOT_FOUND')
+                return apiError(c, 404, 'PROJECT_NOT_FOUND', '项目不存在');
+            if (msg.startsWith('TARGET_OCCUPIED')) {
+                return apiError(c, 409, 'TARGET_OCCUPIED', msg.replace('TARGET_OCCUPIED: ', ''));
+            }
+            return apiError(c, 500, 'RELOCATE_FAILED', msg);
+        }
+    });
+    // P1-9 + P2-2：删除项目记录（看板级联删除）。
+    // 会话不再留孤儿（FK set null 后在任何项目视图都不可见且 cwd 回退 serve 目录）：
+    // 删除前把该项目全部未删除会话软删除进回收站（30 天内可恢复），
+    // 并把 worktreePath 落盘——恢复后 resolveAgentCwd 仍能解析原工作目录。
+    // 有活跃 run 绑定该项目时拒绝删除，避免 agent 工作目录悬空。
+    app.delete('/:id', async (c) => {
+        const id = c.req.param('id');
+        const project = await getProject(ctx.db, id);
+        if (!project)
+            return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+        // 活跃 run 守卫：任一活跃会话归属于该项目 → 拒绝
+        const activeSessionIds = new Set();
+        for (const run of ctx.agentManager.children(id)) {
+            activeSessionIds.add(run.sessionId);
+        }
+        if (activeSessionIds.size === 0) {
+            // 检查该项目下是否有正在进行（含占位）的会话
+            const rows = await ctx.db.db
+                .select({ id: sessions.id, projectId: sessions.projectId })
+                .from(sessions)
+                .where(and(eq(sessions.projectId, id)));
+            const active = rows.filter((r) => ctx.agentManager.get(r.id));
+            if (active.length > 0) {
+                return apiError(c, 409, 'PROJECT_HAS_ACTIVE_SESSIONS', `项目下有 ${active.length} 个进行中的对话，请先中止后再删除`);
+            }
+        }
+        let deletedSessions = 0;
+        await ctx.db.db.transaction(async (tx) => {
+            // 该项目下所有未删除会话：记录 worktreePath（若尚无）并软删除进回收站。
+            // A2：删除项目是一次用户操作——全部会话共享同一 deletedBatchId，
+            // 恢复任一会话时其 fork 子树一并还原（与 softDeleteSession 语义对齐），
+            // 不再因批次断裂导致分支滞留回收站被静默清除。
+            const now = new Date();
+            const batchId = generateId();
+            const bound = await tx
+                .select({
+                id: sessions.id,
+                worktreePath: sessions.worktreePath,
+                metadata: sessions.metadata,
+            })
+                .from(sessions)
+                .where(and(eq(sessions.projectId, id), isNull(sessions.deletedAt)));
+            for (const s of bound) {
+                // A3：软删除清除回收站倒计时/宽限期标记（恢复后重删须重新看到才起算）。
+                const metadata = clearTrashMarks((s.metadata ?? {}));
+                await tx
+                    .update(sessions)
+                    .set({
+                    worktreePath: s.worktreePath ?? project.worktree,
+                    deletedAt: now,
+                    deletedBatchId: batchId,
+                    metadata,
+                })
+                    .where(eq(sessions.id, s.id));
+                deletedSessions += 1;
+            }
+            await tx.delete(kanbanBoards).where(eq(kanbanBoards.projectId, id));
+            await tx.delete(projects).where(eq(projects.id, id));
+        });
+        return c.json({ ok: true, deletedSessions });
+    });
     return app;
 }
 export { createProjectRoute };