c0de-agent 1.10.0 → 1.11.0

package/dist/server/routes/config.js

@@ -1,30 +1,78 @@
 import { Hono } from 'hono';
-import { loadConfigScopes, mergeConfig, mergeRaw, saveConfigScoped } from '../../core/config.js';
-import { encryptSecret, isEncryptedSecret } from '../../core/secret.js';
+import { applyScopedPatch, loadConfigScopes, mergeConfig, saveConfigScoped, } from '../../core/config.js';
+import { decryptSecret, encryptSecret, isEncryptedSecret } from '../../core/secret.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 || '(未命名)'}" 的 API Key 无法在本机解密（密钥与机器绑定）。` +
+                '若配置来自其他机器或容器重建，请重新填写 API Key。');
+        }
+    }
+    return warnings;
+}
 function createConfigRoute(ctx) {
     const app = new Hono();
+    // GET / — 合并后配置 + 作用域信息 + apiKey 解密警告
     app.get('/', (c) => {
-        return c.json(ctx.config);
+        const scopes = loadConfigScopes(ctx.cwd);
+        return c.json({
+            config: ctx.config,
+            scopes: {
+                global: scopes.global ?? null,
+                project: scopes.project ?? null,
+            },
+            warnings: providerApiKeyWarnings(ctx.config.providers),
+        });
     });
+    // PATCH / — 按作用域写入。body.scope: 'global' | 'project'（默认 project，兼容旧客户端）。
     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, ...patch } = body;
         // 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 配置）整体序列化进项目文件。
+        // 按作用域最小落盘：patch 只合并进指定作用域原始文件，
+        // 不把合并结果（含默认值/另一作用域配置）整体序列化进文件。
+        // null 值 = 删除该作用域中的键（回落到另一作用域/默认值）。
         const scopes = loadConfigScopes(ctx.cwd);
-        const nextProject = mergeRaw(scopes.project ?? {}, patch);
-        ctx.config = mergeConfig(scopes.global, nextProject);
+        const nextScoped = scope === 'global'
+            ? applyScopedPatch(scopes.global ?? {}, patch)
+            : applyScopedPatch(scopes.project ?? {}, patch);
+        // P2-3：落盘失败必须反馈给前端（此前静默吞掉，UI 显示已保存但重启后丢失）。
+        // 先落盘、成功后才更新内存配置与 registry，保证「已保存」反馈与磁盘状态一致。
+        try {
+            await saveConfigScoped(scope, ctx.cwd, 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);
-        await saveConfigScoped('project', ctx.cwd, nextProject).catch(() => {
-            // 保存失败不影响内存配置
+        // 安全类配置（token/authEnabled/allowedOrigins）由 authManager 在启动时一次性读取，
+        // 运行时修改不生效——告知前端提示重启。
+        const needsRestart = patch.security !== undefined;
+        return c.json({
+            config: ctx.config,
+            scope,
+            needsRestart,
+            warnings: providerApiKeyWarnings(ctx.config.providers),
         });
-        return c.json(ctx.config);
     });
     return app;
 }

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

@@ -1,5 +1,8 @@
 import { Hono } from 'hono';
 import type { ServerContext } from '../types.js';
-/** GET/PUT /api/permissions — 全局授权模式（default 逐个确认 / auto 自动放行 ask 工具）。 */
+/** GET/PUT /api/permissions — 授权模式（default 逐个确认 / auto 自动放行 ask 工具）。
+ *  - 根路径：默认模式（全局，启动时取 config.permission.defaultMode）
+ *  - /:sessionId：会话级覆盖（P1-5 按会话隔离 auto 高风险状态）
+ */
 declare function createPermissionsRoute(ctx: ServerContext): Hono;
 export { createPermissionsRoute };

package/dist/server/routes/permissions.js

@@ -1,14 +1,16 @@
 import { Hono } from 'hono';
 import { apiError } from '../middleware/error.js';
-/** GET/PUT /api/permissions — 全局授权模式（default 逐个确认 / auto 自动放行 ask 工具）。 */
+/** GET/PUT /api/permissions — 授权模式（default 逐个确认 / auto 自动放行 ask 工具）。
+ *  - 根路径：默认模式（全局，启动时取 config.permission.defaultMode）
+ *  - /:sessionId：会话级覆盖（P1-5 按会话隔离 auto 高风险状态）
+ */
 function createPermissionsRoute(ctx) {
     const app = new Hono();
-    // GET / — 当前授权模式
+    // GET / — 默认授权模式
     app.get('/', (c) => {
         return c.json({ mode: ctx.permissionMode });
     });
-    // PUT / — 运行时切换授权模式（仅本次运行生效，不回写 config；
-    // 重启后回到 config.permission.defaultMode 持久化默认值）
+    // PUT / — 运行时切换默认模式（仅本次运行生效，不回写 config）
     app.put('/', async (c) => {
         const body = (await c.req.json().catch(() => null));
         const mode = body?.mode;
@@ -18,6 +20,27 @@ function createPermissionsRoute(ctx) {
         ctx.permissionMode = mode;
         return c.json({ mode: ctx.permissionMode });
     });
+    // GET /:sessionId — 会话实际生效模式（覆盖优先，回退默认）
+    app.get('/:sessionId', (c) => {
+        const sessionId = c.req.param('sessionId');
+        return c.json({ mode: ctx.sessionPermissionModes.get(sessionId) ?? ctx.permissionMode });
+    });
+    // PUT /:sessionId — 设置会话级覆盖；不传 mode 则清除覆盖
+    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);
+        }
+        return c.json({ mode: ctx.sessionPermissionModes.get(sessionId) ?? ctx.permissionMode });
+    });
     return app;
 }
 export { createPermissionsRoute };

package/dist/server/routes/project.js

@@ -1,10 +1,15 @@
+// src/server/routes/project.ts
+import { existsSync } from 'node:fs';
+import { and, eq, isNull } from 'drizzle-orm';
 import { Hono } from 'hono';
+import { kanbanBoards, projects, sessions } from '../../db/schema.js';
 import { fromDirectory, getProject, listProjects, resolveProject, updateProjectName, } from '../../project/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 +51,55 @@ function createProjectRoute(ctx) {
             return apiError(c, 404, 'NOT_FOUND', 'Project not found');
         return c.json(withBranch(project));
     });
+    // 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（若尚无）并软删除进回收站
+            const now = new Date();
+            const bound = await tx
+                .select({ id: sessions.id, worktreePath: sessions.worktreePath })
+                .from(sessions)
+                .where(and(eq(sessions.projectId, id), isNull(sessions.deletedAt)));
+            for (const s of bound) {
+                if (!s.worktreePath) {
+                    await tx
+                        .update(sessions)
+                        .set({ worktreePath: project.worktree })
+                        .where(eq(sessions.id, s.id));
+                }
+                await tx.update(sessions).set({ deletedAt: now }).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 };

package/dist/server/routes/session.js

@@ -4,7 +4,7 @@ import { fromDirectory } from '../../project/index.js';
 import { archiveOriginalEntries } from '../../session/archive.js';
 import { BranchPointOutOfRangeError, forkSession, getBranches, getTree, } from '../../session/branch.js';
 import { deleteEntriesByIds, getMessages, insertEntry } from '../../session/message.js';
-import { createSession, deleteSession, getLLMSegments, getSession, listSessions, listSessionsByProject, touchLastOpened, } from '../../session/session.js';
+import { createSession, getLLMSegments, getSession, listDeletedSessions, listSessions, listSessionsByProject, restoreSession, softDeleteSession, touchLastOpened, } 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';
@@ -41,6 +41,11 @@ function createSessionRoute(ctx) {
         const tree = await getTree(ctx.db);
         return c.json(tree);
     });
+    // 回收站：已软删除的会话列表（必须注册在 /:id 之前，避免被参数路由吞掉）
+    app.get('/deleted', async (c) => {
+        const sessions = await listDeletedSessions(ctx.db);
+        return c.json(sessions);
+    });
     // 获取会话详情
     app.get('/:id', async (c) => {
         try {
@@ -54,11 +59,18 @@ function createSessionRoute(ctx) {
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
         }
     });
-    // 分支会话
+    // 分支会话：未指定 messageIndex 时默认在最新一条消息处分叉（fork=完整副本语义）
     app.post('/:id/fork', async (c) => {
         const id = c.req.param('id');
         const body = await c.req.json().catch(() => ({}));
-        const messageIndex = body.messageIndex ?? 0;
+        let messageIndex = body.messageIndex;
+        if (messageIndex === undefined || !Number.isFinite(messageIndex)) {
+            const messages = await getMessages(ctx.db, id);
+            if (messages.length === 0) {
+                return apiError(c, 400, 'EMPTY_SESSION', '空会话无法分支');
+            }
+            messageIndex = messages.length - 1;
+        }
         try {
             const forked = await forkSession(ctx.db, id, messageIndex);
             return c.json(forked, 201);
@@ -71,11 +83,20 @@ function createSessionRoute(ctx) {
             return apiError(c, 404, 'NOT_FOUND', 'Session not found');
         }
     });
-    // 删除会话
+    // 删除会话（软删除：级联其 fork 后代进入回收站，30 天后物理清除）
     app.delete('/:id', async (c) => {
-        await deleteSession(ctx.db, c.req.param('id'));
+        const ok = await softDeleteSession(ctx.db, c.req.param('id'));
+        if (!ok)
+            return apiError(c, 404, 'NOT_FOUND', 'Session not found');
         return c.body(null, 204);
     });
+    // 恢复会话（从回收站还原；仅还原该会话本身）
+    app.post('/:id/restore', async (c) => {
+        const ok = await restoreSession(ctx.db, c.req.param('id'));
+        if (!ok)
+            return apiError(c, 404, 'NOT_FOUND', '会话不存在或未删除');
+        return c.json({ ok: true });
+    });
     // 获取消息列表
     app.get('/:id/messages', async (c) => {
         const messages = await getMessages(ctx.db, c.req.param('id'));
@@ -117,13 +138,16 @@ function createSessionRoute(ctx) {
         }
     });
     // 获取会话状态：内存有活跃 run → 返回其 status；否则查 DB lastRun。
-    // lastRun.status='running' 但无活跃 run → 服务重启被中断。
+    // lastRun.status='running' 且无活跃 run → 服务重启被中断。
+    // lastRun.status='paused' 但无活跃 run（热更新/重启后 run 状态未迁移）→ 同样按中断处理：
+    // agent 内存态已丢失，resume 端点无法恢复，唯一可行路径是重发上一条消息。
     app.get('/:id/status', async (c) => {
         const run = ctx.agentManager.get(c.req.param('id'));
         if (run)
             return c.json(run.state.status);
         const session = await getSession(ctx.db, c.req.param('id'));
-        if (session?.metadata.lastRun?.status === 'running') {
+        if (session?.metadata.lastRun?.status === 'running' ||
+            session?.metadata.lastRun?.status === 'paused') {
             return c.json({ _tag: 'interrupted' });
         }
         return c.json({ _tag: 'idle' });

package/dist/server/routes/terminal.js

@@ -1,6 +1,8 @@
 // src/server/routes/terminal.ts
+import { existsSync } from 'node:fs';
 import { isAbsolute } from 'node:path';
 import { Hono } from 'hono';
+import { getProject } from '../../project/index.js';
 import { apiError } from '../middleware/error.js';
 /** 允许的 shell 白名单（P2-6：拒绝路径分隔符与任意二进制）。 */
 const ALLOWED_SHELLS = new Set(['bash', 'zsh', 'fish', 'sh']);
@@ -15,12 +17,25 @@ function createTerminalRoute(ctx) {
     // 创建新 PTY 会话
     app.post('/', async (c) => {
         const body = await c.req.json().catch(() => ({}));
-        const cwd = typeof body.cwd === 'string' && body.cwd.length > 0 ? body.cwd : ctx.cwd;
+        const projectId = typeof body.projectId === 'string' && body.projectId.length > 0 ? body.projectId : undefined;
+        // P2-13：未显式传 cwd 且带 projectId 时，默认目录跟随项目 worktree
+        // （与 chat 的 resolveAgentCwd 行为一致；项目缺失/目录失效时回退 ctx.cwd）。
+        let defaultCwd = ctx.cwd;
+        if (!(typeof body.cwd === 'string' && body.cwd.length > 0) && projectId) {
+            try {
+                const project = await getProject(ctx.db, projectId);
+                if (project && existsSync(project.worktree))
+                    defaultCwd = project.worktree;
+            }
+            catch {
+                // db 不可用（测试桩/临时故障）：保持 ctx.cwd
+            }
+        }
+        const cwd = typeof body.cwd === 'string' && body.cwd.length > 0 ? body.cwd : defaultCwd;
         const cols = Number.isFinite(body.cols) ? Number(body.cols) : undefined;
         const rows = Number.isFinite(body.rows) ? Number(body.rows) : undefined;
         const title = typeof body.title === 'string' ? body.title : undefined;
         const shell = typeof body.shell === 'string' && body.shell.length > 0 ? body.shell : undefined;
-        const projectId = typeof body.projectId === 'string' && body.projectId.length > 0 ? body.projectId : undefined;
         // 入参校验（P2-6）：shell 白名单；cwd 必须为绝对路径。
         if (shell !== undefined) {
             if (shell.includes('/') || shell.includes('\\') || !ALLOWED_SHELLS.has(shell)) {

package/dist/server/routes/update.js

@@ -15,6 +15,12 @@ import { apiError } from '../middleware/error.js';
 function createUpdateRoute(ctx) {
     const app = new Hono();
     app.get('/', (c) => {
+        // P2-8：update.enabled=false 时无 handoff server，apply 必然 409。
+        // 不再触发 checkNow，也不返回 hasUpdate，避免横幅出现一个点了必失败的应用按钮。
+        if (ctx.config.update.enabled === false) {
+            const v = getCurrentVersion();
+            return c.json({ hasUpdate: false, disabled: true, currentVersion: v, latestVersion: v });
+        }
         const cached = ctx.updateScheduler.getLastResult();
         if (cached)
             return c.json(cached);
@@ -36,17 +42,33 @@ function createUpdateRoute(ctx) {
         if (!result.hasUpdate) {
             return apiError(c, 409, 'NO_UPDATE', '已是最新版本，无需热更新');
         }
+        // P1-8：热更新前先暂停所有活跃 run，等其到达安全暂停点（原子操作完成）。
+        // 暂停状态已持久化（lastRun.status='paused'），新实例接管后可恢复继续执行。
+        const pauseTimeoutMs = ctx.config.update.pauseTimeoutMs ?? 30_000;
+        const pauseResult = await ctx.agentManager.pauseAll(pauseTimeoutMs);
         const snapshot = await serializeSessions(ctx.db, ctx.config);
         const r = await performHotUpdate(snapshot, {
             handoffPort: ctx.handoff.port,
             port: ctx.port,
-            authToken: ctx.authToken,
+            // P2-16：传当前 bootstrap（轮换后 ctx.authToken 可能已过期）；
+            // 旧实例 handoff 端点经 verifyHandoff 接受当前/历史 bootstrap 与设备 token。
+            authToken: ctx.authManager?.bootstrap ?? ctx.authToken,
         });
         if (r._tag === 'success') {
             return c.json({
                 ok: true,
                 snapshotPath: r.snapshotPath,
                 latestVersion: result.latestVersion,
+                installMethod: r.installMethod,
+                pausedSessions: pauseResult.paused,
+                forcedAbort: pauseResult.forcedAbort,
+            });
+        }
+        if (r._tag === 'manual_install_required') {
+            // P0-2：无法自动安装（未知安装方式/自动安装失败/等待超时）→ 引导手动更新
+            return apiError(c, 409, 'MANUAL_UPDATE_REQUIRED', r.error, {
+                command: r.command,
+                snapshotPath: r.snapshotPath,
             });
         }
         return apiError(c, 500, 'HOT_UPDATE_FAILED', `${r._tag}: ${'error' in r ? r.error : 'unknown'}`);

package/dist/server/server.js

@@ -1,6 +1,6 @@
 // src/server/server.ts
-import { cpSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { randomBytes } from 'node:crypto';
+import { cpSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { connect as tcpConnect } from 'node:net';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
@@ -13,10 +13,12 @@ import { createAndPopulateRegistry } from '../core/workflows/index.js';
 import { createDB, migrateDB } from '../db/index.js';
 import { createRegistry, overrideToCapabilities, rebuildRegistry, registerProvider, } from '../llm/registry.js';
 import { initPlugins } from '../plugins/index.js';
+import { purgeDeletedSessions } from '../session/session.js';
 import { createDefaultRegistry, createDefaultURLRegistry } from '../tools/index.js';
 import { checkForUpdate, createHandoffServer, createUpdateScheduler, requestHandoff, restoreSessions, } from '../update/index.js';
 import { createAgentManager } from './agent-manager.js';
 import { createApp } from './app.js';
+import { createAuthManager } from './auth-manager.js';
 import { isAllowedOrigin } from './middleware/cors.js';
 import { createPermissionStore } from './permission/store.js';
 import { PTYManager } from './terminal/pty-manager.js';
@@ -185,6 +187,16 @@ async function buildServerContext(db, opts = {}) {
     // 工作流注册表：三级发现（builtin → global → project），eager 初始化。
     // 此前是惰性 getter 只注册 builtin，导致项目级 .c0de/workflows/*.js 永远不可见。
     const workflowRegistry = await createAndPopulateRegistry(cwd);
+    const dataDir = resolveDbDir();
+    // 先解析/生成 bootstrap token（落盘），再创建 authManager 读取——
+    // 首启时文件由 resolveAuthToken 生成，顺序颠倒会导致 bootstrap 读到空值。
+    const resolvedToken = resolveAuthToken(config, dataDir);
+    const authManager = createAuthManager({
+        dataDir,
+        ...(config.security.token && config.security.token.length > 0
+            ? { staticToken: config.security.token }
+            : {}),
+    });
     const ctx = {
         db,
         config,
@@ -196,7 +208,9 @@ async function buildServerContext(db, opts = {}) {
         agentManager: createAgentManager(),
         permissionStore: createPermissionStore(),
         permissionMode: config.permission.defaultMode,
-        authToken: resolveAuthToken(config, resolveDbDir()),
+        sessionPermissionModes: new Map(),
+        authToken: resolvedToken,
+        authManager: config.security.authEnabled === false ? undefined : authManager,
         // Agent 注册表：内置 4 个默认 agent；项目/用户自定义 agent 可在启动后补充加载。
         agentRegistry: (() => {
             const reg = createAgentRegistry();
@@ -220,11 +234,12 @@ async function buildServerContext(db, opts = {}) {
         ctx,
         dispose: async () => {
             // dev 重建前调用：中止活跃 run + settle pending permission +
-            // 停 scheduler。**不 close db**（调用方持有）。
+            // 停 scheduler + 关 devices.json watcher。**不 close db**（调用方持有）。
             ctx.agentManager.dispose();
             ctx.permissionStore.dispose();
             ctx.updateScheduler.stop();
             ctx.ptyManager.dispose();
+            ctx.authManager?.dispose();
         },
     };
 }
@@ -331,9 +346,26 @@ async function bootstrapServerContext(opts = {}) {
         db = await createDevDb(cwd);
     }
     const { ctx, dispose } = await buildServerContext(db, opts);
+    // 回收站清理：启动时清一次 + 每 24h 清一次（软删除保留 30 天）。
+    // fire-and-forget：清理失败不阻塞服务启动。
+    void purgeDeletedSessions(db).catch(() => { });
+    const purgeTimer = setInterval(() => {
+        void purgeDeletedSessions(db).catch(() => { });
+    }, 24 * 60 * 60 * 1000);
+    purgeTimer.unref();
+    // P2-15：PGLite WAL 周期刷盘（30s），缩短 kill -9 等突然停机时的已提交数据丢失窗口。
+    const syncTimer = db.sync
+        ? setInterval(() => {
+            void db.sync?.().catch(() => { });
+        }, 30_000)
+        : null;
+    syncTimer?.unref();
     return {
         ctx,
         close: async () => {
+            clearInterval(purgeTimer);
+            if (syncTimer)
+                clearInterval(syncTimer);
             await dispose();
             if (ownsDb)
                 await db.close();
@@ -396,7 +428,6 @@ async function startServer(opts = {}) {
     // WebSocket：终端双向流。Hono v2 无原生 WS，用 ws 包直接挂载到 HTTP server。
     // 匹配 /api/terminal/:id/ws → ptyManager.attachWebSocket
     const wss = new WebSocketServer({ noServer: true });
-    const expectedToken = ctx.authToken;
     server.on('upgrade', (req, socket, head) => {
         const url = new URL(req.url ?? '', `http://${req.headers.host ?? 'localhost'}`);
         const match = url.pathname.match(/^\/api\/terminal\/([^/]+)\/ws$/);
@@ -412,10 +443,14 @@ async function startServer(opts = {}) {
             socket.destroy();
             return;
         }
-        // 认证：token 通过 query 参数传递（浏览器 WS 无法设置 Authorization header）
-        if (expectedToken) {
+        // 认证：token 通过 query 参数传递（浏览器 WS 无法设置 Authorization header）。
+        // P2-16：优先 authManager 校验（设备 token）；回退 ctx.authToken 兼容测试上下文。
+        if (ctx.authManager || ctx.authToken) {
             const token = url.searchParams.get('token');
-            if (token !== expectedToken) {
+            const ok = ctx.authManager
+                ? ctx.authManager.verify(token ?? undefined)
+                : token === ctx.authToken;
+            if (!ok) {
                 socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
                 socket.destroy();
                 return;
@@ -454,7 +489,11 @@ async function startServer(opts = {}) {
     if (ctx.config.update.enabled && !opts.skipHandoff) {
         const createHandoff = opts.createHandoffFn ?? createHandoffServer;
         handoffServer = await createHandoff(closeMain, {
-            expectedToken: ctx.authToken,
+            // P2-16：token 轮换后新旧实例 bootstrap 可能不同，用 verifyHandoff 接受
+            // 当前/历史 bootstrap 与设备 token；无 authManager 回退字符串比较。
+            ...(ctx.authManager
+                ? { verify: (t) => ctx.authManager?.verifyHandoff(t) ?? false }
+                : { expectedToken: ctx.authToken }),
             exitAfterResponse: true,
         });
         ctx.handoff = { port: handoffServer.port, server: handoffServer };

package/dist/server/types.d.ts

@@ -9,6 +9,7 @@ import type { URLRegistry } from '../shared/types/tool.js';
 import type { ToolRegistry } from '../tools/types.js';
 import type { HandoffServer, UpdateScheduler } from '../update/index.js';
 import type { AgentManager } from './agent-manager.js';
+import type { AuthManager } from './auth-manager.js';
 import type { PermissionStore } from './permission/store.js';
 import type { PTYManager } from './terminal/pty-manager.js';
 /** 持有所有服务依赖的不可变上下文（config 字段可变用于 PATCH 更新）。 */
@@ -26,14 +27,20 @@ type ServerContext = {
     agentManager: AgentManager;
     /** 全局权限确认 store（单例），独立于 agent run 生命周期。 */
     permissionStore: PermissionStore;
-    /** 全局授权模式（运行时可临时切换）：'default' 逐个确认；'auto' 自动放行 ask 工具（YOLO）。启动时取 config.permission.defaultMode，PUT /api/permissions 临时切换不回写 config。 */
+    /** 默认授权模式（config.permission.defaultMode）。 */
     permissionMode: 'default' | 'auto';
+    /** 会话级授权模式覆盖：Map<sessionId, mode>。会话未覆盖时回退 permissionMode。
+     *  P1-5：auto 是高风险状态，按会话隔离避免一个标签页切换影响全部会话。 */
+    sessionPermissionModes: Map<string, 'default' | 'auto'>;
     /**
      * API Bearer token（认证未显式关闭时必存在）。
      * 用户配置 security.token 优先；否则自动生成并持久化到数据目录 auth-token 文件
      * （跨重启/热更新稳定，浏览器首访经 ?token= URL 获取后本地保存）。
+     * P2-16：bootstrap token 仅用于首设备注册；注册后轮换，API 请求认设备 token。
      */
     authToken?: string;
+    /** 认证管理器（token 轮换 + 设备配对审批，P2-16）。authEnabled=false 或测试上下文为 undefined。 */
+    authManager?: AuthManager;
     /** 主 HTTP 服务实际绑定端口（startServer 绑定后回填；热更新 spawn 新实例复用）。 */
     port?: number;
     /** Agent 类型注册表（spec: multi-agent-design）。注入 agent loop 的 runSubAgent。 */

package/dist/session/archive.d.ts

@@ -1,7 +1,7 @@
 import type { DB } from '../db/client.js';
 import type { ArchiveRef, CompactionArchive, SessionEntry } from './types.js';
 /** Archive original entries before compaction/squash. Returns the archive id. */
-declare function archiveOriginalEntries(handle: DB, sessionId: string, entries: SessionEntry[], archiveType: 'compaction' | 'squash' | 'shake', summary: string, compactionId: string): Promise<string>;
+declare function archiveOriginalEntries(handle: DB, sessionId: string, entries: SessionEntry[], archiveType: 'compaction' | 'squash' | 'shake' | 'clear', summary: string, compactionId: string): Promise<string>;
 /** Get an archive by id. Returns null for invalid or non-existent ids. */
 declare function getArchive(handle: DB, id: string): Promise<CompactionArchive | null>;
 /** Get the original entries stored in an archive. */

package/dist/session/branch.d.ts

@@ -14,6 +14,7 @@ declare function forkSession(handle: DB, sessionId: string, messageIndex: number
 declare function getBranches(handle: DB, sessionId: string): Promise<Session[]>;
 /** Build a full session tree from root sessions down.
  * 每层按 metadata.lastOpenedAt 降序（fallback updatedAt、createdAt）。
+ * 排除软删除会话与 CLI 来源会话（Web 树仅展示 web 会话）。
  */
 declare function getTree(handle: DB): Promise<SessionTreeNode[]>;
 export { BranchPointOutOfRangeError, forkSession, getBranches, getTree };

package/dist/session/branch.js

@@ -1,5 +1,5 @@
-import { eq } from 'drizzle-orm';
-import { sessionEntries, sessions } from '../db/schema.js';
+import { and, eq, isNull, ne, or } from 'drizzle-orm';
+import { sessions } from '../db/schema.js';
 import { generateId } from '../shared/index.js';
 import { getEntries, insertEntry } from './message.js';
 import { createSession, getSession, rowToSession } from './session.js';
@@ -82,7 +82,7 @@ async function forkSession(handle, sessionId, messageIndex) {
     // 中途失败整体回滚，不残留永久可见的半成品分支（同 compactSession/squashRecent 写法）。
     const updated = await handle.db.transaction(async (tx) => {
         const txHandle = { db: tx, close: handle.close };
-        const forked = await createSession(txHandle, `Branch of ${source.title}`, source.projectId ?? undefined);
+        const forked = await createSession(txHandle, `Branch of ${source.title}`, source.projectId ?? undefined, undefined, source.source === 'cli' ? 'cli' : 'web');
         await tx
             .update(sessions)
             .set({ parentId: sessionId, branchPoint: messageIndex })
@@ -110,14 +110,21 @@ async function forkSession(handle, sessionId, messageIndex) {
 }
 /** Get direct child sessions (branches) of a session. */
 async function getBranches(handle, sessionId) {
-    const rows = await handle.db.select().from(sessions).where(eq(sessions.parentId, sessionId));
+    const rows = await handle.db
+        .select()
+        .from(sessions)
+        .where(and(eq(sessions.parentId, sessionId), isNull(sessions.deletedAt)));
     return rows.map(rowToSession);
 }
 /** Build a full session tree from root sessions down.
  * 每层按 metadata.lastOpenedAt 降序（fallback updatedAt、createdAt）。
+ * 排除软删除会话与 CLI 来源会话（Web 树仅展示 web 会话）。
  */
 async function getTree(handle) {
-    const rows = await handle.db.select().from(sessions);
+    const rows = await handle.db
+        .select()
+        .from(sessions)
+        .where(and(isNull(sessions.deletedAt), or(isNull(sessions.source), ne(sessions.source, 'cli'))));
     const byParent = new Map();
     for (const row of rows) {
         const session = rowToSession(row);

package/dist/session/index.d.ts

@@ -3,7 +3,7 @@ export { forkSession, getBranches, getTree } from './branch.js';
 export { buildCompactionPrompt, compactSession, extractHotFiles, findSafeCutPoint, } from './compaction.js';
 export { entriesToChatMessages, getSessionContext, injectSnapshots, messageToChatMessage, } from './context.js';
 export { appendMessage, deleteEntriesByIds, deleteMessagesAfter, getEntries, getMessageCount, getMessages, insertEntry, } from './message.js';
-export { createSession, deleteSession, getLLMSegments, getSession, listSessions, migrateLegacyDetails, saveLLMSegments, segmentFingerprint, touchSession, updateSessionTitle, } from './session.js';
+export { createSession, getLLMSegments, getSession, listDeletedSessions, listSessions, migrateLegacyDetails, purgeDeletedSessions, restoreSession, saveLLMSegments, segmentFingerprint, softDeleteSession, touchSession, updateSessionTitle, } from './session.js';
 export { checkFileSnapshot, getFileSnapshots, getLatestFileSnapshot, upsertFileSnapshot, } from './snapshot.js';
 export { squashRecent } from './squash.js';
 export { estimateMessageTokens, estimateTokens } from './token.js';

package/dist/session/index.js

@@ -4,7 +4,7 @@ export { forkSession, getBranches, getTree } from './branch.js';
 export { buildCompactionPrompt, compactSession, extractHotFiles, findSafeCutPoint, } from './compaction.js';
 export { entriesToChatMessages, getSessionContext, injectSnapshots, messageToChatMessage, } from './context.js';
 export { appendMessage, deleteEntriesByIds, deleteMessagesAfter, getEntries, getMessageCount, getMessages, insertEntry, } from './message.js';
-export { createSession, deleteSession, getLLMSegments, getSession, listSessions, migrateLegacyDetails, saveLLMSegments, segmentFingerprint, touchSession, updateSessionTitle, } from './session.js';
+export { createSession, getLLMSegments, getSession, listDeletedSessions, listSessions, migrateLegacyDetails, purgeDeletedSessions, restoreSession, saveLLMSegments, segmentFingerprint, softDeleteSession, touchSession, updateSessionTitle, } from './session.js';
 export { checkFileSnapshot, getFileSnapshots, getLatestFileSnapshot, upsertFileSnapshot, } from './snapshot.js';
 export { squashRecent } from './squash.js';
 export { estimateMessageTokens, estimateTokens } from './token.js';