c0de-agent 1.10.0 → 1.12.0

package/README.md

@@ -6,14 +6,19 @@
 
 - **Browser-Server 架构**：Hono 后端通过 SSE 推送 LLM 流式响应；React 前端单页应用。
 - **本地优先**：会话与索引存储在 PGLite（浏览器/进程内 PostgreSQL），数据随用随取。
-- **多项目**：工作区隔离的多项目管理，每个项目独立会话历史与配置。
+- **多项目**：工作区隔离的多项目管理，每个项目独立会话历史与配置。项目目录被**移动/重命名**后，顶栏「目录已失效」提示提供「重新定位」——输入新路径即可把会话与看板整体迁移过去（无需删除项目）。
 - **工具系统**：内置文件读写、bash、grep、glob、编辑等工具，可按需启用/禁用。
-- **权限模式**：`default` / `auto` 等授权模式，控制工具执行前是否需用户确认。
+- **权限模式**：`default` / `auto` 等授权模式，控制工具执行前是否需用户确认。权限确认双层超时：5 分钟未确认仅提示（可在弹窗中重新确认，不重发消息）；再过 25 分钟仍未响应则自动拒绝（run 继续执行，会话不会无限挂起）。
 - **会话可恢复**：会话快照序列化/反序列化，支持进程重启后无缝恢复。
-- **无感知热更新**：后台定期检查新版本，序列化当前会话 → npm 自更新 → 端口 handoff 接管，用户无感升级。
-- **Web 搜索**：内置 websearch 工具，支持多搜索引擎。
+- **无感知热更新**：后台定期检查新版本，安装成功后才暂停活跃会话 → 序列化会话快照 → npm 自更新 → 端口 handoff 接管。空闲会话零感知；进行中的对话会中断（界面提示后可一键重发继续），安装失败时不触碰任何会话状态。更新完成后请**刷新页面**加载新版界面（后续请求已自动落到新实例，不刷新则页面仍运行旧版前端）。
+- **追加指令**：对话进行中可注入「追加指令」（steering），立即影响下一轮模型输出，并作为会话历史的一部分持久化——刷新后不丢失。
+- **故障回退**：主 provider 失败时自动重试；启用后按配置的重试参数执行，并回退到声明了同一模型的其他 provider（设置 → 故障回退）。
 - **斜杠命令**：`/compact`、`/model`、`/clear` 等可配置的斜杠命令。
-- **主题与多语言**：亮/暗主题，简体中文 / English。
+- **会话回收站**：删除会话软删除入回收站，保留 60 天（自**首次在回收站看到该条目**起算——只标记一次，不随每次打开重置，倒计时稳定可预期）可恢复（按项目隔离，恢复时自动重新归属）。到期后先进入 **7 天宽限期**（回收站内明示「即将清除」，仍可恢复），宽限期满才物理清除，绝不静默清空。删除项目会将其会话移入回收站的「未归属项目」分组（跨项目可见，恢复时归属到某项目）；该分组默认折叠，展开时才启动保留期倒计时。恢复会话时仅还原同一次删除操作中一并删除的分支，漏掉的分支会在提示中显式告知数量。
+- **会话导出/导入**：会话可导出为 JSON 备份，并在任意项目重新导入（会话列表「导入」按钮），跨机器迁移或本地备份均可用。导出含权限态（自动授权/始终允许白名单）时，导入前会明示风险并让你选择是否随迁——默认剥离，避免导入他人导出的会话时静默继承对危险工具的免确认放行。导出仅含本会话与归档；有派生分支时会先提示分支内容不会随迁。
+- **看板**：项目级任务看板（与会话内 agent 待办相互独立，可把待办导出为看板卡片），支持导出/导入整板 JSON 备份——注意：删除项目会**永久**级联删除看板（会话有回收站，看板没有），删除前请先导出备份；目录只是被移动/重命名时请用「重新定位」整体迁移，不要用删除。
+- **会话用量**：会话列表每行显示累计 token 徽标；会话页「会话信息」面板提供 token/成本/消息数等完整统计（token 为服务端上报用量，成本按配置价目估算）。
+- **主题**：亮/暗/跟随系统主题。
 
 ## 安装
 
@@ -29,9 +34,14 @@ pnpm add -g c0de-agent
 
 ## 安全
 
-- **认证**：`security.authEnabled` 默认开启。首次启动自动生成认证 token（持久化于数据目录 `auth-token` 文件），浏览器访问时经启动打印的 URL `?token=` 参数自动保存到 localStorage 并从地址栏移除；后续 API 请求与终端 WebSocket 均携带该 token，服务端校验不通过返回 401。
+- **密钥存储**：`config.json` 写入时强制 `chmod 600`；`providers[].apiKey` 与 `websearch.tavilyApiKey/braveApiKey` 落盘前自动加密（AES-256-GCM，机器绑定，`enc:` 前缀），无论经 Web 设置、`c0de config set` 还是 `/config` 斜杠命令写入均不落明文。例外：`security.token`（静态模式专用）以明文存储，仅建议 CI/脚本场景使用，交互使用请走设备配对。`/config` 与 `c0de config get` 展示配置时对 apiKey/token 等字段自动脱敏。
+  - 项目级配置（`<项目>/.c0de/config.json`）含密钥且目录在 git 仓库内时，设置页会提示将 `.c0de/` 加入 `.gitignore`，防止误提交。
+- **认证**：`security.authEnabled` 默认开启。首次启动自动生成 bootstrap token（持久化于数据目录 `auth-token` 文件），浏览器首访凭启动打印的 URL `?token=` 注册为**首台设备**，服务端随即**轮换 bootstrap token**（旧 token 立即失效，杜绝 URL/shell 历史泄漏）并下发设备 token；后续 API 请求与终端 WebSocket 均携带设备 token。新增设备无 token 时进入**配对流程**：新设备生成 6 位配对码，由已授权设备在「设备配对」弹窗中核对并批准后下发新设备 token。显式配置 `security.token` 时为静态模式（不轮换、不配对，适合 CI/脚本）。
+  - **首设备先到先得**：任何能看见启动打印 URL 的人（同机其他用户、终端输出被截图/共享）都能抢先注册为首台设备，随后真实用户只能经其配对审批。请勿在共享主机或会被录屏的场景让 URL 暴露。默认防护：bootstrap token 生成后 **5 分钟**内有效（`security.firstDeviceTtlMs` 默认值），超时需重启 `c0de serve`（无已注册设备时重启会重新生成 bootstrap，窗口随之刷新）；共享主机/CI 等场景可显式配置更短的值。
   - token 解析优先级：`security.token` 配置 > 环境变量 `C0DE_AUTH_TOKEN` > 数据目录 token 文件 > 自动生成并持久化。
   - 显式关闭：`security.authEnabled: false`（本机单用户且端口仅本机可达时）。
+  - **设备管理**：`c0de auth list` 列出已授权设备；`c0de auth revoke <id>` 撤销设备（运行中的服务立即生效）；`c0de auth reset` 清除全部设备与 token。运行中的服务会热加载 `devices.json` 的变更。
+  - **丢失唯一设备的恢复**：若唯一设备的浏览器数据被清空（设备 token 丢失），配对流程因无已授权设备可批准而无法完成。恢复步骤：`c0de auth reset` → 重启 `c0de serve` → 打开启动日志打印的带 `?token=` 的 URL 重新注册首台设备。
 - **CORS/Origin 校验**：仅放行本机回环 origin 与 `security.allowedOrigins` 中显式配置的 origin；WebSocket 升级在服务端独立校验 Origin（浏览器 WS 不受 CORS 约束）。
 - **监听地址**：默认绑定 `0.0.0.0`（便于容器/远程访问），安全性由 token + allowedOrigins 保证；需要时可用 `security.allowedOrigins` 收紧或自行反向代理限制。
 - **热更新交接**：新实例经环境变量继承 token，请求旧实例 `/handoff` 时须携带匹配的 Bearer token，防止任意本地进程借 handoff 杀掉服务。
@@ -51,12 +61,24 @@ c0de serve --restore snapshot.json
 # 打印模式（单次问答，不启动服务）
 c0de chat "解释这段代码"
 
+# serve 运行时打印模式默认拒绝（对话无法持久化），显式接受临时模式：
+c0de chat --temp "解释这段代码"
+
 # 更新检查
 c0de update --check
 ```
 
 启动后访问 `http://localhost:3000`。
 
+> **CLI 与 Web 的会话隔离**：`c0de chat` 产生的会话标记为 `cli` 来源，不会出现在
+> Web 界面的会话树中（Web 会话树仅展示 web 会话）。CLI 侧 `c0de sessions list` 会列出
+> 全部会话（`[cli]`/`[web]` 标注），并可删除/恢复任意会话——这是 Web 会话的 CLI 恢复途径。
+> 注意：数据库为单写者，`c0de sessions` / `c0de chat`（非 `--temp`）在 serve 运行期间会报错拒绝
+> （CLI 管理需先停止 serve；运行中的服务请用 Web 界面管理）。
+> 恢复的会话若原项目目录已不存在（孤儿会话），可用 `c0de sessions restore <id> --project <路径>`
+> 显式归属到项目。两者存于同一数据库。`c0de chat --continue` 续接过的 CLI 会话不会被自动清理；
+> 未续接的一次性问答会话 30 天后自动清除。
+
 ## 开发
 
 ```bash

package/dist/cli/commands/acp.js

@@ -1,5 +1,5 @@
 import readline from 'node:readline/promises';
-import { createSession, listSessions } from '../../session/session.js';
+import { createSession, listAllSessions } from '../../session/session.js';
 import { formatACPEvent, runAcpLoop } from '../modes/acp.js';
 import { runPrintMode } from '../modes/print.js';
 /** 构造 ACP method → handler 映射。chat 复用 Print 模式。 */
@@ -7,11 +7,11 @@ function createAcpHandlers(config, deps, opts) {
     return {
         'session/create': async (params) => {
             const title = params.title ?? 'acp-session';
-            const session = await createSession(deps.db, title);
+            const session = await createSession(deps.db, title, undefined, undefined, 'cli');
             return { sessionId: session.id };
         },
         'session/list': async () => {
-            const sessions = await listSessions(deps.db);
+            const sessions = await listAllSessions(deps.db);
             return { sessions };
         },
         chat: async (params) => {

package/dist/cli/commands/auth.d.ts

@@ -0,0 +1,17 @@
+import type { CommandArgs } from '../parser.js';
+type DeviceRecord = {
+    id: string;
+    name: string;
+    tokenHash: string;
+    createdAt: number;
+};
+type AuthCommandContext = {
+    args: CommandArgs;
+    write?: (s: string) => void;
+};
+declare function devicesPath(): string;
+declare function readDevices(): DeviceRecord[];
+declare function writeDevices(devices: DeviceRecord[]): void;
+declare function runAuthCommand(ctx: AuthCommandContext): Promise<void>;
+export type { AuthCommandContext };
+export { devicesPath, readDevices, runAuthCommand, writeDevices };

package/dist/cli/commands/auth.js

@@ -0,0 +1,73 @@
+// src/cli/commands/auth.ts — 设备管理与认证恢复（P1-4/P2-5）。
+//
+// 本地终端是可信信道：唯一设备丢失（浏览器数据清空）导致配对死锁时，
+// 用户可通过 `c0de auth reset` 清除设备注册表，重启 serve 后用启动日志
+// 打印的带 token URL 重新注册首台设备。
+// 运行中的 serve 通过 authManager 的 devices.json watcher 热加载 revoke/reset 变更。
+import { existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveDbDir } from '../../server/server.js';
+function devicesPath() {
+    return join(resolveDbDir(), 'devices.json');
+}
+function authTokenPath() {
+    return join(resolveDbDir(), 'auth-token');
+}
+function readDevices() {
+    try {
+        if (!existsSync(devicesPath()))
+            return [];
+        const raw = JSON.parse(readFileSync(devicesPath(), 'utf-8'));
+        return Array.isArray(raw.devices) ? raw.devices : [];
+    }
+    catch {
+        throw new Error('auth: 无法读取设备注册表（devices.json 损坏？）');
+    }
+}
+function writeDevices(devices) {
+    const file = { version: 1, devices };
+    writeFileSync(devicesPath(), JSON.stringify(file, null, 2), 'utf-8');
+}
+async function runAuthCommand(ctx) {
+    const write = ctx.write ?? ((s) => process.stdout.write(s));
+    const sub = ctx.args.positionals[0] ?? 'list';
+    if (sub === 'list') {
+        const devices = readDevices();
+        if (devices.length === 0) {
+            write('无已授权设备。\n');
+            return;
+        }
+        for (const d of devices) {
+            write(`- ${d.name}  (id: ${d.id}, 注册于 ${new Date(d.createdAt).toISOString()})\n`);
+        }
+        return;
+    }
+    if (sub === 'revoke') {
+        const id = ctx.args.positionals[1];
+        if (!id)
+            throw new Error('auth revoke: a device id is required (use `c0de auth list`)');
+        const devices = readDevices();
+        const target = devices.find((d) => d.id === id);
+        if (!target)
+            throw new Error(`auth revoke: device not found: ${id}`);
+        writeDevices(devices.filter((d) => d.id !== id));
+        write(`已撤销设备 "${target.name}"（${id}）。运行中的 serve 将立即生效。\n`);
+        return;
+    }
+    if (sub === 'reset') {
+        // 清除设备注册表 + bootstrap：恢复到「未注册」状态。
+        // 运行中的 serve 经 watcher 热清空内存设备；bootstrap 在重启后重新生成并打印。
+        try {
+            rmSync(devicesPath(), { force: true });
+            rmSync(authTokenPath(), { force: true });
+        }
+        catch (err) {
+            throw new Error(`auth reset: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        write('已清除全部已授权设备与认证 token。\n');
+        write('恢复步骤：重启 c0de serve，然后打开启动日志中打印的带 ?token= 的 URL 注册首台设备。\n');
+        return;
+    }
+    throw new Error(`auth: unknown subcommand "${sub}" (expected list|revoke|reset)`);
+}
+export { devicesPath, readDevices, runAuthCommand, writeDevices };

package/dist/cli/commands/chat.js

@@ -1,4 +1,70 @@
 import { runPrintMode } from '../modes/print.js';
+/**
+ * CLI 斜杠命令拦截：与 Web chat 路由同语义（P1 跨端一致性）。
+ * 此前 print 模式把 /clear、/config 等当普通文本发给 LLM，模型会虚构执行结果；
+ * 现在 parseSlashInput + registry 拦截，未启用/未知命令回退与 Web 端一致。
+ * /compact 需要会话上下文，由消费方在此执行压缩并输出摘要。
+ */
+async function runSlashCommand(message, continueId, ctx) {
+    const { createSlashRegistry, parseSlashInput } = await import('../../core/slash.js');
+    const parsed = parseSlashInput(message);
+    if (!parsed)
+        return false;
+    const registry = createSlashRegistry();
+    const cmd = registry.get(parsed.name);
+    if (!cmd)
+        return false; // 未知斜杠命令：回退为正常消息发给 agent（与 Web 端一致）
+    const out = ctx.stdout ?? process.stdout.write.bind(process.stdout);
+    const err = ctx.stderr ?? process.stderr.write.bind(process.stderr);
+    const enabledList = ctx.config.slashCommands?.enabled ?? [];
+    const enabledSet = new Set(enabledList.map((n) => (n.startsWith('/') ? n.slice(1) : n)));
+    if (enabledSet.size > 0 && !enabledSet.has(parsed.name)) {
+        err(`斜杠命令 /${parsed.name} 未启用（config.slashCommands.enabled）\n`);
+        return true;
+    }
+    const { compactContext } = await import('../../core/loop.js');
+    const { createAgent } = await import('../../core/agent.js');
+    const { getSession } = await import('../../session/session.js');
+    const result = await cmd.execute(parsed.args, {
+        cwd: ctx.deps.cwd,
+        config: ctx.config,
+        deps: ctx.deps,
+        sessionId: continueId,
+        // 消费渠道：/model 等命令按渠道给指引（CLI 无底部模型选择器）。
+        channel: 'cli',
+    });
+    if (result._tag === 'compact') {
+        // /compact：消费方执行压缩（Web 端由 chat 路由消费）。需要会话上下文。
+        if (!continueId) {
+            err('/compact 需要会话上下文：请加 --continue <session-id> 指定会话\n');
+            return true;
+        }
+        const session = await getSession(ctx.deps.db, continueId);
+        if (!session) {
+            throw new Error(`session not found: ${continueId}`);
+        }
+        const agentConfig = {
+            provider: ctx.config.defaultProvider,
+            model: ctx.config.defaultModel,
+            tools: [],
+            plugins: ctx.config.plugins.enabled,
+            agentName: 'default',
+        };
+        const state = await createAgent(session, agentConfig, ctx.deps);
+        for await (const event of compactContext(state, ctx.deps)) {
+            if (event._tag === 'text_delta')
+                out(`${event.text}\n`);
+        }
+        return true;
+    }
+    if (result._tag === 'error') {
+        err(`${result.message}\n`);
+        return true;
+    }
+    const text = result._tag === 'success' ? result.message : result.text;
+    out(`${text}\n`);
+    return true;
+}
 async function runChatCommand(ctx) {
     const message = ctx.args.positionals.join(' ').trim();
     if (!message)
@@ -7,7 +73,22 @@ async function runChatCommand(ctx) {
     const err = ctx.stderr ?? process.stderr.write.bind(process.stderr);
     const format = ctx.args.options.format ?? 'text';
     const model = ctx.args.options.model;
-    const continueId = ctx.args.options.continue;
+    let continueId = ctx.args.options.continue;
+    // --continue last：续接最近一次会话，免手抄 UUID（P3 产品发现性）。
+    if (continueId === 'last') {
+        const { listAllSessions } = await import('../../session/session.js');
+        const sessions = await listAllSessions(ctx.deps.db);
+        if (sessions.length === 0) {
+            throw new Error('chat: no sessions to continue (run c0de chat once first)');
+        }
+        sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+        continueId = sessions[0]?.id;
+        if (!continueId)
+            throw new Error('chat: no sessions to continue');
+    }
+    // 斜杠命令拦截：命中则执行本地语义，不把命令文本发给 LLM。
+    if (await runSlashCommand(message, continueId, ctx))
+        return;
     const text = await runPrintMode(ctx.config, message, ctx.deps, {
         ...(model ? { model } : {}),
         ...(continueId ? { sessionId: continueId } : {}),
@@ -16,6 +97,14 @@ async function runChatCommand(ctx) {
                 err(`[tool] ${e.tool}\n`);
             else if (e._tag === 'thinking')
                 err(`[thinking] ${e.text}\n`);
+            else if (e._tag === 'tool_call_end') {
+                // P2-17：非交互模式被拒绝的工具调用，把拒绝原因直接可见地输出给用户
+                //（拒绝原因本身含 -y / serve 指引），而不是只留给模型转述。
+                const result = e.result;
+                if (result?._tag === 'deny') {
+                    err(`[tool] 工具调用已拒绝：${result.reason ?? '需要确认'}\n`);
+                }
+            }
         },
     });
     if (format === 'json') {
@@ -24,5 +113,10 @@ async function runChatCommand(ctx) {
     else {
         out(`${text}\n`);
     }
+    // P2-5：一次性 CLI 问答不进 Web 会话树，明确告知查看/续接途径，
+    // 避免「我的会话去哪了」（--continue 续接时用户已知会话存在，不提示）。
+    if (!continueId) {
+        err('此问答会话不会出现在 Web 界面；可用 `c0de sessions list` 查看，或 `c0de chat --continue` 续接。\n');
+    }
 }
 export { runChatCommand };

package/dist/cli/commands/config.d.ts

@@ -1,17 +1,10 @@
+import { coerce, getByPath, setPathPatch } from '../../core/config-path.js';
 import type { CommandArgs } from '../parser.js';
 type ConfigCommandContext = {
     args: CommandArgs;
     cwd: string;
     write?: (s: string) => void;
 };
-/** 按 a.b.c 点路径从对象取值；找不到抛错。 */
-declare function getByPath(obj: unknown, path: string): unknown;
-/** 按 a.b.c 点路径写值（创建中间对象）。 */
-declare function setByPath(obj: Record<string, unknown>, path: string, value: unknown): void;
-/** 把字符串解析为合适的标量类型。 */
-declare function coerce(value: string): unknown;
-/** 构造 a.b.c → { a: { b: { c: value } } } 的 patch 对象。 */
-declare function setPathPatch(path: string, value: unknown): Record<string, unknown>;
 declare function runConfigCommand(ctx: ConfigCommandContext): Promise<void>;
 export type { ConfigCommandContext };
-export { coerce, getByPath, runConfigCommand, setByPath, setPathPatch };
+export { coerce, getByPath, runConfigCommand, setPathPatch };

package/dist/cli/commands/config.js

@@ -1,81 +1,52 @@
-import { loadConfigScopes, mergeConfig, mergeRaw, saveConfigScoped, } from '../../core/config.js';
-/** 按 a.b.c 点路径从对象取值；找不到抛错。 */
-function getByPath(obj, path) {
-    const parts = path.split('.');
-    let cur = obj;
-    for (const p of parts) {
-        if (cur === null || typeof cur !== 'object')
-            throw new Error(`config: key "${path}" not found`);
-        cur = cur[p];
-        if (cur === undefined)
-            throw new Error(`config: key "${path}" not found`);
-    }
-    return cur;
-}
-/** 按 a.b.c 点路径写值（创建中间对象）。 */
-function setByPath(obj, path, value) {
-    const parts = path.split('.');
-    let cur = obj;
-    for (let i = 0; i < parts.length - 1; i++) {
-        const k = parts[i];
-        const next = cur[k];
-        cur[k] = (next !== null && typeof next === 'object' ? next : {});
-        cur = cur[k];
-    }
-    cur[parts[parts.length - 1]] = value;
-}
-/** 把字符串解析为合适的标量类型。 */
-function coerce(value) {
-    if (value === 'true')
-        return true;
-    if (value === 'false')
-        return false;
-    if (/^-?\d+(\.\d+)?$/.test(value))
-        return Number(value);
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return value;
-    }
-}
-/** 构造 a.b.c → { a: { b: { c: value } } } 的 patch 对象。 */
-function setPathPatch(path, value) {
-    const root = {};
-    setByPath(root, path, value);
-    return root;
-}
+import { applyScopedPatch, loadConfigScopes, mergeConfig, saveConfigScoped, } from '../../core/config.js';
+import { coerce, getByPath, setPathPatch } from '../../core/config-path.js';
 async function runConfigCommand(ctx) {
     const write = ctx.write ?? process.stdout.write.bind(process.stdout);
     const sub = ctx.args.positionals[0];
     const scopes = loadConfigScopes(ctx.cwd);
     // get 展示用合并视图（global ← project，含默认值），与 loadConfig 语义一致。
     const config = mergeConfig(scopes.global, scopes.project);
+    // 未知顶层键告警（loadConfig 只在 serve/chat 启动路径调用；config 命令走 loadConfigScopes）。
+    const { warnUnknownConfigKeys } = await import('../../core/config.js');
+    warnUnknownConfigKeys('global', scopes.global);
+    warnUnknownConfigKeys('project', scopes.project);
     if (sub === 'get') {
         const key = ctx.args.positionals[1];
+        const { redactSecrets } = await import('../../core/redact.js');
         if (!key) {
-            write(`${JSON.stringify(config, null, 2)}\n`);
+            // 展示前脱敏：apiKey/token 明文绝不输出到终端（P0 密钥暴露）。
+            write(`${JSON.stringify(redactSecrets(config), null, 2)}\n`);
             return;
         }
-        const val = getByPath(config, key);
+        // 用点路径末段作为键名参与脱敏判定：config get security.token 等单键读取同样掩码。
+        const leaf = key.split('.').pop();
+        const val = redactSecrets(getByPath(config, key), leaf);
         write(`${typeof val === 'object' ? JSON.stringify(val) : String(val)}\n`);
         return;
     }
     if (sub === 'set') {
         const key = ctx.args.positionals[1];
-        const rawValue = ctx.args.positionals[2];
+        const rawArg = ctx.args.positionals[2];
         if (!key)
             throw new Error('config set: a key is required');
-        if (rawValue === undefined)
+        if (rawArg === undefined)
             throw new Error('config set: a value is required');
+        // 顶层键校验：拒绝拼写错误/过时键，避免写入永不生效的配置（此前静默接受）。
+        const { KNOWN_CONFIG_KEYS } = await import('../../core/config.js');
+        const topKey = key.split('.')[0] ?? '';
+        if (!KNOWN_CONFIG_KEYS.has(topKey)) {
+            throw new Error(`config set: 未知的顶层配置键 "${topKey}"。有效键：${[...KNOWN_CONFIG_KEYS].join(', ')}`);
+        }
         const scope = ctx.args.options.global ? 'global' : 'project';
         // 只把 patch 合并进目标作用域的原始文件，不写入默认值与其他作用域的配置（P2-3）。
+        // 值为 null → 删除该键（作用域内取消覆盖，回落另一作用域/默认值）。
         const scopeCfg = scope === 'global' ? scopes.global : scopes.project;
-        const next = mergeRaw(scopeCfg ?? {}, setPathPatch(key, coerce(rawValue)));
+        const value = coerce(rawArg);
+        const next = applyScopedPatch(scopeCfg ?? {}, setPathPatch(key, value));
         await saveConfigScoped(scope, ctx.cwd, next);
-        write(`Set ${key} (scope: ${scope})\n`);
+        write(`${value === null ? '已取消设置' : '已设置'} ${key} (scope: ${scope})\n`);
         return;
     }
     throw new Error(`config: unknown subcommand "${sub ?? ''}" (expected get|set)`);
 }
-export { coerce, getByPath, runConfigCommand, setByPath, setPathPatch };
+export { coerce, getByPath, runConfigCommand, setPathPatch };

package/dist/cli/commands/init.js

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { DEFAULT_CONFIG, saveConfig } from '../../core/config.js';
+import { saveConfigScoped } from '../../core/config.js';
 async function runInitCommand(ctx) {
     const log = ctx.log ?? process.stdout.write.bind(process.stdout);
     const force = ctx.args.options.force ?? false;
@@ -8,7 +8,9 @@ async function runInitCommand(ctx) {
     if (existsSync(path) && !force) {
         throw new Error(`init: config already exists at ${path} (use --force to overwrite)`);
     }
-    await saveConfig(DEFAULT_CONFIG, 'project', ctx.cwd);
+    // P1-3：只写空配置——写入 DEFAULT_CONFIG 会把 providers: [] 等默认值固化进项目文件，
+    // 数组整体替换语义会覆盖全局 providers，使项目内 AI 服务失效。
+    await saveConfigScoped('project', ctx.cwd, {});
     log(`Created ${path}\n`);
 }
 export { runInitCommand };

package/dist/cli/commands/plugin.js

@@ -1,4 +1,4 @@
-import { loadConfig, saveConfig } from '../../core/config.js';
+import { applyScopedPatch, loadConfigScopes, mergeConfig } from '../../core/config.js';
 async function runPluginCommand(ctx) {
     const write = ctx.write ?? process.stdout.write.bind(process.stdout);
     const discover = ctx.discover ?? (async () => []);
@@ -18,11 +18,15 @@ async function runPluginCommand(ctx) {
         const name = ctx.args.positionals[1];
         if (!name)
             throw new Error('plugin install: a plugin name is required');
-        const config = await loadConfig(ctx.cwd);
-        const enabled = config.plugins.enabled;
+        // P1-2：只把 plugins.enabled 合并进 project 作用域文件，不整体落盘
+        //（saveConfig 全量写入会把默认值与全局配置固化进项目文件）。
+        const scopes = loadConfigScopes(ctx.cwd);
+        const enabled = [...(mergeConfig(scopes.global, scopes.project).plugins?.enabled ?? [])];
         if (!enabled.includes(name))
             enabled.push(name);
-        await saveConfig(config, 'project', ctx.cwd);
+        const next = applyScopedPatch(scopes.project ?? {}, { plugins: { enabled } });
+        const { saveConfigScoped } = await import('../../core/config.js');
+        await saveConfigScoped('project', ctx.cwd, next);
         write(`Enabled plugin "${name}".\n`);
         return;
     }

package/dist/cli/commands/sessions.d.ts

@@ -0,0 +1,10 @@
+import type { DB } from '../../db/client.js';
+import type { CommandArgs } from '../parser.js';
+type SessionsCommandContext = {
+    args: CommandArgs;
+    db: DB;
+    write?: (s: string) => void;
+};
+declare function runSessionsCommand(ctx: SessionsCommandContext): Promise<void>;
+export type { SessionsCommandContext };
+export { runSessionsCommand };

package/dist/cli/commands/sessions.js

@@ -0,0 +1,94 @@
+// src/cli/commands/sessions.ts — CLI 会话管理（P3：清理 print 模式积累的 CLI 会话）。
+//
+// c0de chat 每次运行都创建 source='cli' 会话且被 Web 会话树排除，
+// 此前无任何 CLI 途径列出/清理，垃圾数据只增不减。
+// 复用 withAgentDeps 的持久库生命周期（serve 占用时退化为内存库则明确报错）。
+//
+// P1 闭环修复：delete 移入回收站后必须有 CLI 恢复途径（此前文案承诺
+// 「60 天内可恢复」但 CLI 无 restore 子命令，恢复只能绕道 Web 界面）。
+import { fromDirectory } from '../../project/project.js';
+import { getSession, listAllSessions, listDeletedSessions, rebindSession, restoreSession, softDeleteSession, } from '../../session/session.js';
+async function runSessionsCommand(ctx) {
+    const write = ctx.write ?? ((s) => process.stdout.write(s));
+    const sub = ctx.args.positionals[0] ?? 'list';
+    if (sub === 'list') {
+        const sessions = await listAllSessions(ctx.db);
+        if (sessions.length === 0) {
+            write('无会话。\n');
+            return;
+        }
+        for (const s of sessions) {
+            const source = s.source === 'cli' ? 'cli' : 'web';
+            const when = new Date(s.updatedAt).toISOString();
+            write(`- [${source}] ${s.title}  (id: ${s.id}, updated ${when})\n`);
+        }
+        return;
+    }
+    if (sub === 'delete') {
+        const id = ctx.args.positionals[1];
+        if (!id)
+            throw new Error('sessions delete: a session id is required (use `c0de sessions list`)');
+        const ok = await softDeleteSession(ctx.db, id);
+        if (!ok)
+            throw new Error(`sessions delete: session not found or already deleted: ${id}`);
+        write(`已删除会话 ${id}（移入回收站，60 天内可用 \`c0de sessions restore ${id}\` 恢复）。\n`);
+        return;
+    }
+    if (sub === 'restore') {
+        const id = ctx.args.positionals[1];
+        if (!id)
+            throw new Error('sessions restore: a session id is required (use `c0de sessions list`)');
+        const ok = await restoreSession(ctx.db, id);
+        if (!ok)
+            throw new Error(`sessions restore: session not found or not deleted: ${id}`);
+        // P2-2：与 Web restore 对齐——会话项目已删除（FK set null）时按 worktreePath
+        // 重建归属，避免恢复成功但在 Web 各项目视图不可达。
+        // P2 修复：--project <path> 提供显式归属出口（Web 有「归属到当前项目」，
+        // CLI 此前只有警告、用户自己修不了）。
+        const projectPath = ctx.args.options.project;
+        const session = await getSession(ctx.db, id);
+        if (session && !session.projectId && (session.worktreePath || projectPath)) {
+            try {
+                const { existsSync } = await import('node:fs');
+                const target = projectPath ?? session.worktreePath;
+                if (target && existsSync(target)) {
+                    const project = await fromDirectory(ctx.db, target);
+                    await rebindSession(ctx.db, id, project);
+                    write(`已恢复会话 ${id}（已重新归属到项目 ${project.id}）。\n`);
+                    return;
+                }
+                if (projectPath) {
+                    throw new Error(`项目目录不存在：${projectPath}`);
+                }
+                write(`已恢复会话 ${id}（警告：原项目目录不存在，会话未归属任何项目，Web 不可见）。\n`);
+                write(`提示：c0de sessions restore ${id} --project <项目路径> 可显式归属。\n`);
+                return;
+            }
+            catch (error) {
+                write(`已恢复会话 ${id}（警告：项目归属失败——${error instanceof Error ? error.message : String(error)}，会话可能不可见）。\n`);
+                return;
+            }
+        }
+        if (session?.projectId && projectPath) {
+            write(`已恢复会话 ${id}（会话已有项目归属，忽略 --project）。\n`);
+            return;
+        }
+        write(`已恢复会话 ${id}。\n`);
+        return;
+    }
+    // 回收站列表：软删除会话 + 剩余保留信息（辅助 restore）
+    if (sub === 'deleted') {
+        const sessions = await listDeletedSessions(ctx.db);
+        if (sessions.length === 0) {
+            write('回收站为空。\n');
+            return;
+        }
+        for (const s of sessions) {
+            const when = s.deletedAt ? new Date(s.deletedAt).toISOString() : '-';
+            write(`- ${s.title}  (id: ${s.id}, deleted ${when})\n`);
+        }
+        return;
+    }
+    throw new Error(`sessions: unknown subcommand "${sub}" (expected list|delete|restore|deleted)`);
+}
+export { runSessionsCommand };

package/dist/cli/commands/update.js

@@ -1,4 +1,4 @@
-import { checkForUpdate, performHotUpdate, serializeSessions, } from '../../update/index.js';
+import { checkForUpdate, performHotUpdate, performInstall, serializeSessions, } from '../../update/index.js';
 /**
  * `c0de update`：检查 npm registry 新版本。
  * - 默认：check-only，报告有无更新。
@@ -19,16 +19,24 @@ async function runUpdateCommand(ctx) {
         out(`发现新版本 ${result.latestVersion}。加 --apply 执行热更新。`);
         return;
     }
+    // P2-7：无 db（独立 CLI，无活跃 serve）→ 仅安装，不 spawn `serve`。
+    // 此前会拉起一个用户未请求的常驻服务；活跃 serve 的热更新走 /api/update/apply。
+    if (!ctx.db) {
+        out(`发现新版本 ${result.latestVersion}，开始安装…`);
+        const r = await performInstall(ctx.updateOpts);
+        if (r._tag === 'success') {
+            out('安装完成。若 c0de serve 正在运行，请在页面顶部的更新横幅中应用热更新，或重启 serve。');
+        }
+        else if (r._tag === 'install_failed') {
+            out(`安装失败：${r.error}`);
+        }
+        else {
+            out(`无法自动安装（${r.error}）。请手动执行：${r.command}`);
+        }
+        return;
+    }
     out(`发现新版本 ${result.latestVersion}，开始热更新…`);
-    const snapshot = ctx.db
-        ? await serializeSessions(ctx.db, ctx.config)
-        : {
-            version: result.currentVersion,
-            sessions: [],
-            entries: [],
-            config: ctx.config ?? null,
-            timestamp: Date.now(),
-        };
+    const snapshot = await serializeSessions(ctx.db, ctx.config);
     const r = await performHotUpdate(snapshot, ctx.updateOpts);
     if (r._tag === 'success') {
         out(`热更新完成，快照写入 ${r.snapshotPath}。新实例将接管。`);