c0de-agent 1.12.0 → 1.13.0

package/dist/server/routes/project.js

@@ -1,13 +1,24 @@
 // src/server/routes/project.ts
-import { existsSync } from 'node:fs';
+import { existsSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { parse } from 'node:path';
 import { and, eq, isNull } from 'drizzle-orm';
 import { Hono } from 'hono';
 import { kanbanBoards, projects, sessions } from '../../db/schema.js';
-import { fromDirectory, getProject, listProjects, relocateProject, resolveProject, updateProjectName, } from '../../project/index.js';
+import { fromDirectory, getByDirectory, getProject, listProjects, relocateProject, resolveProject, trustProject, 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';
+/** realpath 失败（目录不存在等）时返回 null，调用方回退原路径。 */
+function realpathSafe(p) {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return null;
+    }
+}
 /** 实时取 git 分支（分支随时变，不存 DB）。worktree 不存在时标记缺失。 */
 function withBranch(project) {
     const worktreeMissing = !existsSync(project.worktree);
@@ -30,8 +41,21 @@ function createProjectRoute(ctx) {
         const list = await listProjects(ctx.db);
         return c.json(list.map(withBranch));
     });
-    // 解析服务端 cwd 对应的项目（未注册则自动创建）
+    // 解析服务端 cwd 对应的项目（未注册则自动创建）。
+    // 注册过滤（P2）：serve 在 home/文件系统根目录启动时不做自动注册——home 不是项目，
+    // 自动注册只会把 home 变成污染项目列表的假项目。已显式注册（/from-directory）的
+    // 目录照常返回，用户主动添加 home 为项目的选择被尊重。
     app.get('/current', async (c) => {
+        const existing = await getByDirectory(ctx.db, ctx.cwd);
+        if (existing)
+            return c.json(withBranch(existing), 200);
+        const dir = realpathSafe(ctx.cwd) ?? ctx.cwd;
+        const home = realpathSafe(homedir());
+        const root = parse(dir).root;
+        if ((home && dir === home) || dir === root) {
+            return apiError(c, 404, 'PROJECT_DIR_REQUIRED', '当前目录（home 目录）不是项目，未自动注册。请在项目目录启动 c0de serve，' +
+                '或在项目列表中显式添加该目录。');
+        }
         const project = await fromDirectory(ctx.db, ctx.cwd);
         return c.json(withBranch(project), 200);
     });
@@ -53,6 +77,14 @@ function createProjectRoute(ctx) {
             return apiError(c, 404, 'NOT_FOUND', 'Project not found');
         return c.json(withBranch(project));
     });
+    // P0-2：显式信任项目——用户在信任确认弹窗中批准项目作用域配置/插件后调用。
+    // 信任是一次性动作（trustedAt 落盘）；此后聊天入口不再拦截本项目。
+    app.post('/:id/trust', async (c) => {
+        const project = await trustProject(ctx.db, c.req.param('id'));
+        if (!project)
+            return apiError(c, 404, 'NOT_FOUND', 'Project not found');
+        return c.json({ ok: true, project: withBranch(project) });
+    });
     // A1：项目重新定位——目录被移动/重命名后的恢复通道。
     // 整体迁移会话与看板到新目录身份（替代「删项目 + 逐条恢复 + 看板丢失」）。
     // 目标目录已注册为另一项目 → 409；有活跃 run → 拒绝（agent 工作目录悬空）。
@@ -65,15 +97,21 @@ function createProjectRoute(ctx) {
         if (!existsSync(directory)) {
             return apiError(c, 400, 'DIRECTORY_MISSING', `目录不存在或不可访问：${directory}`);
         }
-        // 活跃 run 守卫（与 DELETE 同语义）
+        // 活跃 run 守卫（与 DELETE 同语义；含 starting 占位态）
         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;
+        const activeCount = rows.filter((r) => ctx.agentManager.get(r.id) !== undefined || ctx.agentManager.isStarting(r.id)).length;
         if (activeCount > 0) {
             return apiError(c, 409, 'PROJECT_HAS_ACTIVE_SESSIONS', `项目下有 ${activeCount} 个进行中的对话，请先中止后再重新定位`);
         }
+        // P2-5：打开的终端守卫——终端绑定项目 worktree，重定位后 shell 仍留在旧目录，
+        // cwd 身份悬空。与活跃 run 同语义：先关闭再操作。
+        const openTerminals = ctx.ptyManager.list().filter((t) => t.projectId === id);
+        if (openTerminals.length > 0) {
+            return apiError(c, 409, 'PROJECT_HAS_OPEN_TERMINALS', `项目下有 ${openTerminals.length} 个打开的终端，请先关闭终端后再重新定位`);
+        }
         try {
             const project = await relocateProject(ctx.db, id, directory);
             return c.json({ ok: true, project: withBranch(project) });
@@ -88,31 +126,35 @@ function createProjectRoute(ctx) {
             return apiError(c, 500, 'RELOCATE_FAILED', msg);
         }
     });
-    // P1-9 + P2-2：删除项目记录（看板级联删除）。
+    // P1-9 + P2-2：删除项目记录。
     // 会话不再留孤儿（FK set null 后在任何项目视图都不可见且 cwd 回退 serve 目录）：
-    // 删除前把该项目全部未删除会话软删除进回收站（30 天内可恢复），
+    // 删除前把该项目全部未删除会话软删除进回收站（60 天内可恢复），
     // 并把 worktreePath 落盘——恢复后 resolveAgentCwd 仍能解析原工作目录。
+    // P2-5：看板同步软删除进回收站（可恢复/重新归属），不再永久级联销毁。
     // 有活跃 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);
+        // 活跃 run 守卫：该项目下任一进行中（含占位 isStarting）的会话 → 拒绝。
+        // P1 修复：原实现先查 agentManager.children(projectId)——children 按
+        // parentSessionId（子 agent 归属）过滤，项目 id 恒不命中属死代码；且回退
+        // 检查只用 get() 漏掉 tryAcquire 后的 starting 占位态，窗口内删除会让 run
+        // 继续向已软删除会话写消息。现在直接按项目会话查 get()+isStarting()。
+        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) !== undefined || ctx.agentManager.isStarting(r.id));
+        if (active.length > 0) {
+            return apiError(c, 409, 'PROJECT_HAS_ACTIVE_SESSIONS', `项目下有 ${active.length} 个进行中的对话，请先中止后再删除`);
         }
-        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} 个进行中的对话，请先中止后再删除`);
-            }
+        // P2-5：打开的终端守卫——项目删除后其 worktree 上的 PTY 仍继续运行，
+        // cwd 指向已注销身份的目录。与活跃 run 同语义：先关闭再删除。
+        const openTerminals = ctx.ptyManager.list().filter((t) => t.projectId === id);
+        if (openTerminals.length > 0) {
+            return apiError(c, 409, 'PROJECT_HAS_OPEN_TERMINALS', `项目下有 ${openTerminals.length} 个打开的终端，请先关闭终端后再删除项目`);
         }
         let deletedSessions = 0;
         await ctx.db.db.transaction(async (tx) => {
@@ -144,7 +186,19 @@ function createProjectRoute(ctx) {
                     .where(eq(sessions.id, s.id));
                 deletedSessions += 1;
             }
-            await tx.delete(kanbanBoards).where(eq(kanbanBoards.projectId, id));
+            // P2-5：看板不再永久级联销毁——标记软删除（记录原项目名），项目行删除后
+            // FK set null 使其进入回收站「未归属看板」分组，60 天后随清理任务物理清除；
+            // 恢复端点可重新归属到任意项目。
+            await tx
+                .update(kanbanBoards)
+                .set({
+                deletedAt: now,
+                deletedProjectName: project.name ?? project.worktree,
+                deletedProjectWorktree: project.worktree,
+                purgePendingAt: null,
+                updatedAt: now,
+            })
+                .where(and(eq(kanbanBoards.projectId, id), isNull(kanbanBoards.deletedAt)));
             await tx.delete(projects).where(eq(projects.id, id));
         });
         return c.json({ ok: true, deletedSessions });

package/dist/server/routes/provider.js

@@ -100,6 +100,12 @@ function createProviderRoute(ctx) {
         const { baseURL, apiKey } = body;
         if (!baseURL)
             return apiError(c, 400, 'BAD_REQUEST', 'baseURL is required');
+        // P3：仅允许 http/https——服务端按调用方提供的 URL 发起请求，非 http 协议
+        // 不应由「测试连接」端点代理（本机 localhost/Ollama 等 http 服务不受影响）。
+        const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(baseURL)?.[1]?.toLowerCase();
+        if (!scheme || (scheme !== 'http' && scheme !== 'https')) {
+            return apiError(c, 400, 'BAD_REQUEST', 'baseURL must be an http(s) URL');
+        }
         // apiKey 可能是 Settings 页回传的 enc: 密文（保存后刷新、未重输时）：探测前解密，
         // 否则把 enc: 串当 Bearer token 发给上游必然 401，造成「保存了却测试失败」的误判。
         const secret = apiKey ? decryptSecret(apiKey) : '';

package/dist/server/routes/session.js

@@ -11,13 +11,13 @@ import { archiveOriginalEntries, listArchives } from '../../session/archive.js';
 import { BranchPointOutOfRangeError, forkSession, getBranches, getTree, } from '../../session/branch.js';
 import { importSessionData } from '../../session/import.js';
 import { deleteEntriesByIds, getMessages, getSteeringAsMessages, insertEntry, } from '../../session/message.js';
-import { createSession, emptyTrash, getLLMSegments, getSession, listDeletedSessions, listOrphanDeletedSessions, listSessions, listSessionsByProject, permanentlyDeleteSession, rebindSession, restoreSessionCore, searchSessions, softDeleteSession, touchLastOpened, touchTrashSeen, updateSessionTitle, } from '../../session/session.js';
+import { createSession, emptyTrash, getLLMSegments, getSession, listDeletedSessions, listOrphanDeletedSessions, listSessions, listSessionsByProject, permanentlyDeleteSession, purgeEmptySession, rebindSession, restoreSessionCore, searchSessions, softDeleteSession, touchLastOpened, touchTrashSeen, updateSessionTitle, } from '../../session/session.js';
 import { applyShakeRegions, collectShakeRegions, DEFAULT_SHAKE_CONFIG, toRegionViews, } from '../../session/shake.js';
 import { estimateMessageTokens } from '../../session/token.js';
 import { generateId } from '../../shared/index.js';
 import { apiError } from '../middleware/error.js';
 import { buildRegistryFromConfig } from '../registry-config.js';
-import { resolveAgentCwd } from './chat.js';
+import { hasBusySession, resolveAgentCwd } from './chat.js';
 function createSessionRoute(ctx) {
     const app = new Hono();
     // 会话导入：GET /:id/export 的逆操作（数据备份/迁移闭环）。
@@ -29,6 +29,16 @@ function createSessionRoute(ctx) {
         if (body?.version !== 1 || !body?.session || !Array.isArray(body?.messages)) {
             return apiError(c, 400, 'INVALID_EXPORT', '无效的会话导出 JSON：需要 version/session/messages 字段');
         }
+        // P3：导入体积上限——导出文件可任意大，无上限的数组会让服务端
+        // 逐条插入时 OOM/长事务。上限按合理会话规模取 20 倍余量。
+        const MAX_IMPORT_MESSAGES = 20000;
+        const MAX_IMPORT_ARCHIVES = 2000;
+        if (body.messages.length > MAX_IMPORT_MESSAGES) {
+            return apiError(c, 400, 'IMPORT_TOO_LARGE', `导入消息数 ${body.messages.length} 超过上限 ${MAX_IMPORT_MESSAGES}`);
+        }
+        if (Array.isArray(body.archives) && body.archives.length > MAX_IMPORT_ARCHIVES) {
+            return apiError(c, 400, 'IMPORT_TOO_LARGE', `导入归档数 ${body.archives.length} 超过上限 ${MAX_IMPORT_ARCHIVES}`);
+        }
         const projectId = typeof body.projectId === 'string' && body.projectId ? body.projectId : '';
         if (!projectId) {
             return apiError(c, 400, 'PROJECT_REQUIRED', '导入会话必须指定目标项目（projectId）');
@@ -56,6 +66,44 @@ function createSessionRoute(ctx) {
                 }
             }
         }
+        // P2：携带用量 segments（会话信息面板/徽标显示历史成本与 token）。
+        // 与权限态不同，segments 是纯统计数据无安全含义，默认随迁。
+        // 宽松校验形状：非法调用静默丢弃，不阻塞导入。
+        // P0-1：导入的调用从未对本机 API key 计费——剥离 calls[].id 使
+        // backfillUsageEvents 自然跳过它们（要求 id 非空），成本账本保持
+        // 「本机真实消费」语义；cost/usage 字段保留，展示继承成本不受影响。
+        // P2-7：calls 按导入消息时间窗裁剪——导出后原会话新增的调用不属于本副本。
+        const importedMsgs = body.messages;
+        let maxMsgTs = 0;
+        for (const m of importedMsgs) {
+            const raw = m?.createdAt;
+            const ts = typeof raw === 'number' && Number.isFinite(raw) && raw > 0
+                ? raw
+                : typeof raw === 'string'
+                    ? Date.parse(raw)
+                    : Number.NaN;
+            if (Number.isFinite(ts) && ts > maxMsgTs)
+                maxMsgTs = ts;
+        }
+        const srcMetaAny = body.session?.metadata;
+        if (maxMsgTs > 0 && Array.isArray(srcMetaAny?.segments)) {
+            metadata.segments = srcMetaAny.segments
+                .filter((seg) => !!seg &&
+                typeof seg === 'object' &&
+                !Array.isArray(seg) &&
+                typeof seg.provider === 'string' &&
+                typeof seg.model === 'string' &&
+                Array.isArray(seg.calls))
+                .map((seg) => ({
+                ...seg,
+                calls: seg.calls
+                    .filter((c) => {
+                    const ts = c?.timestamp;
+                    return typeof ts === 'number' && ts > 0 && ts <= maxMsgTs;
+                })
+                    .map(({ id: _stripped, ...rest }) => rest),
+            }));
+        }
         // P2：导出含分支树结构（parentId），导入为独立根会话——告知前端提示扁平化。
         const flattened = typeof body.session.parentId === 'string' && body.session.parentId.length > 0;
         const result = await importSessionData(ctx.db, {
@@ -171,16 +219,34 @@ function createSessionRoute(ctx) {
         const session = await getSession(ctx.db, id);
         if (!session)
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        // P3 口径统一：回收站会话不可改名（与 GET /:id、/messages 的 404 语义一致）。
+        if (session.deletedAt) {
+            return apiError(c, 404, 'NOT_FOUND', '会话不存在或已删除');
+        }
         await updateSessionTitle(ctx.db, id, title);
         return c.json({ ok: true, title });
     });
     // 分支会话：未指定 messageIndex 时默认在最新一条消息处分叉（fork=完整副本语义）
     app.post('/:id/fork', async (c) => {
         const id = c.req.param('id');
+        // P3：回收站会话不可分支——与 GET /:id、PATCH /:id 的 404 口径一致，
+        // 否则 API 直调 fork 已删除会话即可复活其内容、绕过回收站语义。
+        const existing = await getSession(ctx.db, id);
+        if (!existing)
+            return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        if (existing.deletedAt) {
+            return apiError(c, 404, 'NOT_FOUND', '会话不存在或已删除');
+        }
         // P3：fork 复制消息树，与正在写库的活跃 run 存在竞态——先拒绝。
-        if (ctx.agentManager.get(id)) {
+        // 守卫与斜杠 /fork 同口径（hasBusySession）：此前只查 get()，
+        // 漏 tryAcquire→register 占位窗口与工作流运行期。
+        const busy = hasBusySession(ctx, id);
+        if (busy === 'run' || busy === 'workflow') {
             return apiError(c, 409, 'RUN_ACTIVE', '该会话已有进行中的对话，请等待完成或中止后再分支');
         }
+        if (busy === 'starting') {
+            return apiError(c, 409, 'RUN_STARTING', '该会话的对话正在启动，请稍后重试');
+        }
         const body = await c.req.json().catch(() => ({}));
         let messageIndex = body.messageIndex;
         if (messageIndex === undefined || !Number.isFinite(messageIndex)) {
@@ -202,11 +268,25 @@ function createSessionRoute(ctx) {
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
         }
     });
-    // 删除会话（软删除：级联其 fork 后代进入回收站，30 天后物理清除）。
+    // 删除会话（软删除：级联其 fork 后代进入回收站，60 天后物理清除）。
     // P2 修复：删除运行中的会话前先中止其活跃 run（含子 agent）——
     // 否则 run 继续向已删除会话写入消息，用户以为已删除而 agent 仍在执行。
+    // P1 工作流路由：发起会话有进行中的工作流时一并中止 workflow run
+    //（此前仅中止会话自身 run + 子 agent，工作流继续后台执行且 busy 映射悬挂）。
     app.delete('/:id', async (c) => {
         const id = c.req.param('id');
+        // starting 占位无法 abort（尚无 run）——删除会让随后 register 的 run 写入
+        // 已软删除会话。与控制端点同口径：占位期 409，稍后重试。
+        if (ctx.agentManager.isStarting(id)) {
+            return apiError(c, 409, 'RUN_STARTING', '该会话的对话正在启动，请稍后重试');
+        }
+        const busyWorkflowId = ctx.workflowBusyBySession.get(id);
+        if (busyWorkflowId) {
+            ctx.agentManager.abort(busyWorkflowId);
+            for (const child of ctx.agentManager.children(busyWorkflowId)) {
+                ctx.agentManager.abort(child.sessionId);
+            }
+        }
         ctx.agentManager.abort(id);
         for (const child of ctx.agentManager.children(id)) {
             ctx.agentManager.abort(child.sessionId);
@@ -229,6 +309,16 @@ function createSessionRoute(ctx) {
             return apiError(c, 404, 'NOT_FOUND', '会话不存在或不在回收站');
         return c.json({ ok: true, deleted: count });
     });
+    // P3-9：物理删除真空会话（无消息且无子会话）——首条消息发送失败后的前端
+    // 清理路径。此前走 DELETE /:id 软删除，空壳进回收站污染列表；非空会话 409，
+    // 物理删除不绕过回收站语义。
+    app.delete('/:id/empty', async (c) => {
+        const ok = await purgeEmptySession(ctx.db, c.req.param('id'));
+        if (!ok) {
+            return apiError(c, 409, 'SESSION_NOT_EMPTY', '会话不存在或非空（请使用常规删除，移入回收站）');
+        }
+        return c.json({ ok: true });
+    });
     // 会话归档列表（compaction/squash/shake/clear 的原始内容）；?q= 搜索归档文本
     app.get('/:id/archives', async (c) => {
         const id = c.req.param('id');
@@ -257,14 +347,40 @@ function createSessionRoute(ctx) {
         }
         if (!session)
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
+        // P3 口径统一：回收站会话不可导出——与 GET /:id、PATCH /:id、/messages、
+        // /llm-details 的 404 语义一致。回收站内容经「恢复」后即可导出。
+        if (session.deletedAt) {
+            return apiError(c, 404, 'NOT_FOUND', '会话不存在或已删除');
+        }
         const messages = await getMessages(ctx.db, id);
         const archives = await listArchives(ctx.db, id);
+        // P2-6：归档的 fileSnapshots 含被压缩进上下文的文件内容——导出 JSON 常被
+        // 分享/迁移，默认剥离（隐私优先）；显式 ?includeSnapshots=1 才携带。
+        const includeSnapshots = c.req.query('includeSnapshots') === '1';
+        // P2-1：权限态（permissionMode/alwaysAllow）与 fileSnapshots 同口径默认剥离。
+        // 导出 JSON 被分享时不应携带用户的工具授权白名单结构；显式
+        // ?includePermissions=1 才保留（配合导入侧 importPermissions=true 完成
+        // 同机备份/迁移的权限态闭环——两开关对称）。
+        const includePermissions = c.req.query('includePermissions') === '1';
+        const exportSession = includePermissions
+            ? session
+            : {
+                ...session,
+                metadata: (() => {
+                    const m = { ...(session.metadata ?? {}) };
+                    delete m.permissionMode;
+                    delete m.alwaysAllow;
+                    return m;
+                })(),
+            };
         return c.json({
             version: 1,
             exportedAt: new Date().toISOString(),
-            session,
+            session: exportSession,
             messages,
-            archives,
+            archives: includeSnapshots
+                ? archives
+                : archives.map((a) => ({ ...a, fileSnapshots: undefined })),
         });
     });
     // 恢复会话（从回收站还原；仅还原该会话本身）。
@@ -272,23 +388,31 @@ function createSessionRoute(ctx) {
     // 项目记录并重新归属——否则恢复成功但会话不属于任何项目视图，UI 不可达。
     // P1-2：body.projectId 提供时（当前项目视图），目录失效无法重建归属的孤儿
     // 会话直接归属到该请求项目，恢复即可达。
+    // P1-3：静默重建项目改为明示——响应带 recreatedProject（重建的项目信息），
+    // 前端据此展示「已重新创建项目 X」；同时支持 restoreMode='current-project'
+    // 显式跳过重建、直接归属到请求项目（用户在确认框中二选一）。
     app.post('/:id/restore', async (c) => {
         const id = c.req.param('id');
         const body = (await c.req.json().catch(() => ({})));
         const requestProjectId = typeof body.projectId === 'string' && body.projectId ? body.projectId : undefined;
+        const preferCurrentProject = body.restoreMode === 'current-project';
         const result = await restoreSessionCore(ctx.db, id);
         if (!result.restored)
             return apiError(c, 404, 'NOT_FOUND', '会话不存在或未删除');
         const session = await getSession(ctx.db, id);
         let rebound = false;
         let orphaned = false;
+        let recreatedProject = null;
         if (session && !session.projectId) {
             const wt = session.worktreePath;
-            if (wt && existsSync(wt)) {
+            // P1-3：用户选择「归属到当前项目」时跳过自动重建（删除项目是用户意图，
+            // 不静默复活）。否则目录仍存在则重建项目记录（明示在响应中）。
+            if (!preferCurrentProject && wt && existsSync(wt)) {
                 try {
                     const project = await fromDirectory(ctx.db, wt);
                     await ctx.db.db.update(sessions).set({ projectId: project.id }).where(eq(sessions.id, id));
                     rebound = true;
+                    recreatedProject = { id: project.id, name: project.name };
                 }
                 catch {
                     orphaned = true;
@@ -297,7 +421,8 @@ function createSessionRoute(ctx) {
             else {
                 orphaned = true;
             }
-            // P1-2：目录失效且请求方提供了项目上下文 → 归属到该请求项目
+            // P1-2：目录失效且请求方提供了项目上下文 → 归属到该请求项目；
+            // P1-3：restoreMode='current-project' 时无论目录是否存在都归属请求项目。
             if (orphaned && requestProjectId) {
                 const project = await getProject(ctx.db, requestProjectId);
                 if (project) {
@@ -311,6 +436,7 @@ function createSessionRoute(ctx) {
             ok: true,
             rebound,
             orphaned,
+            recreatedProject,
             restoredAncestorCount: result.restoredAncestorCount,
             crossedBatchAncestor: result.crossedBatchAncestor,
             // A2：批次不同的已删后代滞留在回收站，显式告知数量供前端提示单独恢复。
@@ -320,6 +446,15 @@ function createSessionRoute(ctx) {
     // 会话归属变更（P1-2）：孤儿会话归属到指定项目，恢复后即可达。
     app.post('/:id/rebind', async (c) => {
         const id = c.req.param('id');
+        // P3 口径统一：归属变更与 fork/compact/shake 同用 hasBusySession 守卫——
+        // 活跃 run 的 cwd 在启动时解析，rebind 会改变后续轮次的工作目录语义。
+        const busy = hasBusySession(ctx, id);
+        if (busy === 'run' || busy === 'workflow') {
+            return apiError(c, 409, 'RUN_ACTIVE', '该会话已有进行中的对话，请等待完成或中止后再更改归属');
+        }
+        if (busy === 'starting') {
+            return apiError(c, 409, 'RUN_STARTING', '该会话的对话正在启动，请稍后重试');
+        }
         const body = (await c.req.json().catch(() => ({})));
         const projectId = typeof body.projectId === 'string' && body.projectId ? body.projectId : '';
         if (!projectId)
@@ -353,6 +488,11 @@ function createSessionRoute(ctx) {
         const run = ctx.agentManager.get(c.req.param('id'));
         if (run)
             return c.json(run.state.segments);
+        const session = await getSession(ctx.db, c.req.param('id'));
+        // P3 口径统一：回收站会话的持久化分段不再下发（会话本身已 404）。
+        if (!session || session.deletedAt) {
+            return apiError(c, 404, 'NOT_FOUND', '会话不存在或已删除');
+        }
         const persisted = await getLLMSegments(ctx.db, c.req.param('id'));
         return c.json(persisted);
     });
@@ -360,10 +500,15 @@ function createSessionRoute(ctx) {
     // P1 多项目：keepRecentTokens 按会话项目配置解析（此前用启动目录配置）。
     app.post('/:id/compact', async (c) => {
         const id = c.req.param('id');
-        // P3：压缩改写消息树，与活跃 run 的并发写入存在竞态——先拒绝。
-        if (ctx.agentManager.get(id)) {
+        // P2-5 修复：守卫收敛 hasBusySession（与斜杠 /compact、REST fork 同口径）——
+        // 此前只查 get()，漏 tryAcquire→register 占位窗口与工作流运行期两态。
+        const busy = hasBusySession(ctx, id);
+        if (busy === 'run' || busy === 'workflow') {
             return apiError(c, 409, 'RUN_ACTIVE', '该会话已有进行中的对话，请等待完成或中止后再压缩');
         }
+        if (busy === 'starting') {
+            return apiError(c, 409, 'RUN_STARTING', '该会话的对话正在启动，请稍后重试');
+        }
         let session;
         try {
             session = await getSession(ctx.db, id);
@@ -410,10 +555,18 @@ function createSessionRoute(ctx) {
         }
     });
     // 获取会话状态：内存有活跃 run → 返回其 status；否则查 DB lastRun。
+    // P1 工作流路由：发起会话在 workflowBusyBySession 中时状态取实际 workflow run
+    //（此前工作流运行期间状态栏显示 idle）。
     // lastRun.status='running' 且无活跃 run → 服务重启被中断。
     // lastRun.status='paused' 但无活跃 run（热更新/重启后 run 状态未迁移）→ 同样按中断处理：
     // agent 内存态已丢失，resume 端点无法恢复，唯一可行路径是重发上一条消息。
     app.get('/:id/status', async (c) => {
+        const busyWorkflowId = ctx.workflowBusyBySession.get(c.req.param('id'));
+        if (busyWorkflowId) {
+            const wfRun = ctx.agentManager.get(busyWorkflowId);
+            if (wfRun)
+                return c.json(wfRun.state.status);
+        }
         const run = ctx.agentManager.get(c.req.param('id'));
         if (run)
             return c.json(run.state.status);
@@ -447,10 +600,15 @@ function createSessionRoute(ctx) {
     // shake apply：归档原始内容 + 原位替换
     app.post('/:id/shake/apply', async (c) => {
         const id = c.req.param('id');
-        // P3：shake 原位改写消息，与活跃 run 的并发写入存在竞态——先拒绝。
-        if (ctx.agentManager.get(id)) {
+        // P2-5 修复：守卫收敛 hasBusySession（与 compact/fork 同口径），
+        // 补 starting 占位与工作流运行期两态。
+        const busy = hasBusySession(ctx, id);
+        if (busy === 'run' || busy === 'workflow') {
             return apiError(c, 409, 'RUN_ACTIVE', '该会话已有进行中的对话，请等待完成或中止后再 Shake');
         }
+        if (busy === 'starting') {
+            return apiError(c, 409, 'RUN_STARTING', '该会话的对话正在启动，请稍后重试');
+        }
         let session;
         try {
             session = await getSession(ctx.db, id);
@@ -500,7 +658,13 @@ function createSessionRoute(ctx) {
     });
     // 记录会话打开（更新 metadata.lastOpenedAt，用于会话列表按最近打开排序）
     app.post('/:id/open', async (c) => {
-        await touchLastOpened(ctx.db, c.req.param('id'));
+        const id = c.req.param('id');
+        // P3 口径统一：不存在/回收站会话不再静默返回成功（与 GET /:id 404 一致）。
+        const session = await getSession(ctx.db, id);
+        if (!session || session.deletedAt) {
+            return apiError(c, 404, 'NOT_FOUND', '会话不存在或已删除');
+        }
+        await touchLastOpened(ctx.db, id);
         return c.json({ ok: true });
     });
     // 获取分支

package/dist/server/routes/tool.js

@@ -1,18 +1,37 @@
 import { Hono } from 'hono';
+import { loadConfigScopes, mergeConfig } from '../../core/config.js';
+import { getProject } from '../../project/project.js';
+import { resolveEnabledToolNames } from '../../tools/index.js';
 import { listTools } from '../../tools/registry.js';
 import { apiError } from '../middleware/error.js';
 function createToolRoute(ctx) {
     const app = new Hono();
-    // 列出可用工具（不含 execute 函数）
-    app.get('/', (c) => {
-        const tools = listTools(ctx.toolRegistry, { config: {}, cwd: ctx.cwd });
-        const serializable = tools.map((t) => ({
+    // 列出可用工具（不含 execute 函数）。
+    // P2 交集语义配套：列表按 config.tools.enabled 过滤——设置页禁用某工具后，
+    // 输入区工具开关不再提供该工具，避免「勾选了却被服务端静默丢弃」的脱节。
+    // ?projectId= 时按该项目合并配置过滤（与 chat 路由的工具解析同口径）。
+    app.get('/', async (c) => {
+        let config = ctx.config;
+        const projectId = c.req.query('projectId');
+        if (projectId) {
+            const project = await getProject(ctx.db, projectId);
+            if (!project)
+                return apiError(c, 404, 'PROJECT_NOT_FOUND', '项目不存在');
+            const projectScope = loadConfigScopes(project.worktree).project;
+            if (projectScope)
+                config = mergeConfig(ctx.config, projectScope);
+        }
+        const enabledNames = resolveEnabledToolNames(ctx.toolRegistry, config);
+        const enabledSet = new Set(enabledNames);
+        const tools = listTools(ctx.toolRegistry, { config: {}, cwd: ctx.cwd })
+            .filter((t) => enabledSet.has(t.name))
+            .map((t) => ({
             name: t.name,
             description: t.description,
             parameters: t.parameters,
             permission: t.permission,
         }));
-        return c.json(serializable);
+        return c.json(tools);
     });
     // 确认工具执行权限
     app.post('/confirm', async (c) => {