c0de-agent 1.11.0 → 1.12.0

package/README.md

@@ -6,14 +6,18 @@
 
 - **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` 等可配置的斜杠命令。
-- **会话回收站**：删除会话软删除入回收站，30 天内可恢复。
+- **会话回收站**：删除会话软删除入回收站，保留 60 天（自**首次在回收站看到该条目**起算——只标记一次，不随每次打开重置，倒计时稳定可预期）可恢复（按项目隔离，恢复时自动重新归属）。到期后先进入 **7 天宽限期**（回收站内明示「即将清除」，仍可恢复），宽限期满才物理清除，绝不静默清空。删除项目会将其会话移入回收站的「未归属项目」分组（跨项目可见，恢复时归属到某项目）；该分组默认折叠，展开时才启动保留期倒计时。恢复会话时仅还原同一次删除操作中一并删除的分支，漏掉的分支会在提示中显式告知数量。
+- **会话导出/导入**：会话可导出为 JSON 备份，并在任意项目重新导入（会话列表「导入」按钮），跨机器迁移或本地备份均可用。导出含权限态（自动授权/始终允许白名单）时，导入前会明示风险并让你选择是否随迁——默认剥离，避免导入他人导出的会话时静默继承对危险工具的免确认放行。导出仅含本会话与归档；有派生分支时会先提示分支内容不会随迁。
+- **看板**：项目级任务看板（与会话内 agent 待办相互独立，可把待办导出为看板卡片），支持导出/导入整板 JSON 备份——注意：删除项目会**永久**级联删除看板（会话有回收站，看板没有），删除前请先导出备份；目录只是被移动/重命名时请用「重新定位」整体迁移，不要用删除。
+- **会话用量**：会话列表每行显示累计 token 徽标；会话页「会话信息」面板提供 token/成本/消息数等完整统计（token 为服务端上报用量，成本按配置价目估算）。
 - **主题**：亮/暗/跟随系统主题。
 
 ## 安装
@@ -30,7 +34,10 @@ pnpm add -g c0de-agent
 
 ## 安全
 
+- **密钥存储**：`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` 的变更。
@@ -54,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/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 } : {}),
@@ -32,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.js

@@ -6,13 +6,21 @@ async function runConfigCommand(ctx) {
     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;
     }
@@ -23,6 +31,12 @@ async function runConfigCommand(ctx) {
             throw new Error('config set: a key is required');
         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 → 删除该键（作用域内取消覆盖，回落另一作用域/默认值）。
@@ -30,7 +44,7 @@ async function runConfigCommand(ctx) {
         const value = coerce(rawArg);
         const next = applyScopedPatch(scopeCfg ?? {}, setPathPatch(key, value));
         await saveConfigScoped(scope, ctx.cwd, next);
-        write(`${value === null ? 'Unset' : 'Set'} ${key} (scope: ${scope})\n`);
+        write(`${value === null ? '已取消设置' : '已设置'} ${key} (scope: ${scope})\n`);
         return;
     }
     throw new Error(`config: unknown subcommand "${sub ?? ''}" (expected get|set)`);

package/dist/cli/commands/sessions.js

@@ -3,7 +3,11 @@
 // c0de chat 每次运行都创建 source='cli' 会话且被 Web 会话树排除，
 // 此前无任何 CLI 途径列出/清理，垃圾数据只增不减。
 // 复用 withAgentDeps 的持久库生命周期（serve 占用时退化为内存库则明确报错）。
-import { listAllSessions, softDeleteSession } from '../../session/session.js';
+//
+// 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';
@@ -27,9 +31,64 @@ async function runSessionsCommand(ctx) {
         const ok = await softDeleteSession(ctx.db, id);
         if (!ok)
             throw new Error(`sessions delete: session not found or already deleted: ${id}`);
-        write(`已删除会话 ${id}（移入回收站，30 天内可恢复）。\n`);
+        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)`);
+    throw new Error(`sessions: unknown subcommand "${sub}" (expected list|delete|restore|deleted)`);
 }
 export { runSessionsCommand };

package/dist/cli/index.js

@@ -25,6 +25,9 @@ const COMMANDS = [
             { name: 'format', type: 'string' },
             { name: 'yes', type: 'boolean', short: 'y' },
             { name: 'continue', type: 'string' },
+            // P2 修复：serve 运行时持久库被占用，此前静默退化为内存库（会话不保存，
+            // 仅 stderr 一行提示极易错过）。现须显式 --temp 才允许临时模式。
+            { name: 'temp', type: 'boolean' },
         ],
     },
     {
@@ -59,13 +62,16 @@ const COMMANDS = [
     },
     {
         name: 'sessions',
-        description: 'Manage CLI/web sessions (list / delete).',
-        options: [],
+        description: 'Manage CLI/web sessions (list / delete / restore / deleted).',
+        options: [{ name: 'project', type: 'string' }],
     },
     {
         name: 'acp',
         description: 'Run in Agent Client Protocol mode (editor integration).',
-        options: [],
+        options: [
+            // serve 占用持久库时的显式临时模式开关（与 chat --temp 同语义）。
+            { name: 'temp', type: 'boolean' },
+        ],
     },
     {
         name: 'update',
@@ -109,14 +115,22 @@ async function withAgentDeps(cwd, opts, fn) {
         if (!isDbLockConflict(err))
             throw err;
         if (opts.requirePersistent) {
-            throw new Error('c0de serve 正在运行并占用会话库。请通过 Web UI 管理会话，或停止 serve 后重试。');
+            throw new Error('c0de serve 正在运行并占用会话库，CLI 会话管理暂不可用（单写者限制）。\n' +
+                '  1) 在 Web 界面管理会话；\n' +
+                '  2) 或停止 serve（Ctrl+C）后重试本命令。');
         }
         if (opts.continueSessionId) {
             throw new Error(`无法续聊会话 ${opts.continueSessionId}：持久库被 c0de serve 占用，内存模式无法续聊。\n` +
                 `请停止 serve 后重试，或去掉 --continue 开启新会话。`);
         }
-        process.stderr.write('[c0de] ⚠ c0de serve 正在运行：本次对话为临时模式，消息与工具调用不会保存。\n' +
-            '       停止 serve 后重试可持久化，或直接使用浏览器界面。\n');
+        if (!opts.allowTemp) {
+            // P2 修复：锁冲突不再静默降级为不保存会话的内存模式（用户极易错过 stderr
+            // 提示导致对话丢失）。必须显式 --temp 确认放弃持久化。
+            throw new Error('c0de serve 正在运行并占用会话库，本次对话将无法保存。\n' +
+                '  1) 停止 serve 后重试（对话可持久化，推荐）；\n' +
+                '  2) 或加 --temp 显式接受临时模式（消息与工具调用不会保存）。');
+        }
+        process.stderr.write('[c0de] ⚠ 临时模式：消息与工具调用不会保存。停止 serve 后重试可持久化，或直接使用浏览器界面。\n');
         db = await createDB({ driver: 'pglite' });
         await migrateDB(db);
     }
@@ -155,9 +169,11 @@ async function dispatch(argv, overrides = {}) {
             // --yes / -y 显式放行写操作；否则按 config.permission.defaultMode 决定（默认 safe）。
             const strategy = args.options.yes ? 'full-auto' : undefined;
             const continueId = args.options.continue;
+            const allowTemp = args.options.temp === true;
             await withAgentDeps(cwd, {
                 ...(strategy ? { strategy } : {}),
                 ...(continueId ? { continueSessionId: continueId } : {}),
+                ...(allowTemp ? { allowTemp } : {}),
             }, (config, deps) => runChatCommand({ args, config, deps }));
             return;
         }
@@ -184,7 +200,10 @@ async function dispatch(argv, overrides = {}) {
         }
         case 'acp': {
             // ACP 非交互：所有工具放行（编辑器侧自行控制执行授权）。
-            await withAgentDeps(cwd, { strategy: 'full-auto' }, (config, deps) => runAcpCommand({ config, deps }));
+            await withAgentDeps(cwd, {
+                strategy: 'full-auto',
+                ...(args.options.temp === true ? { allowTemp: true } : {}),
+            }, (config, deps) => runAcpCommand({ config, deps }));
             return;
         }
         case 'update': {

package/dist/cli/modes/print.js

@@ -1,6 +1,6 @@
 import { createAgent, runAgent } from '../../core/agent.js';
 import { resolveRoute } from '../../llm/registry.js';
-import { createSession, getSession } from '../../session/session.js';
+import { createSession, getSession, upgradeTemporarySession } from '../../session/session.js';
 import { resolveEnabledToolNames } from '../../tools/index.js';
 /** 从事件流累积 assistant 文本。纯函数。 */
 function collectAssistantText(events) {
@@ -24,10 +24,17 @@ async function runPrintMode(config, message, deps, opts = {}) {
         const existing = await getSession(deps.db, opts.sessionId);
         if (!existing)
             throw new Error(`session not found: ${opts.sessionId}`);
+        // 续接即升级为持久会话：30 天临时清理不再触及（P1：此前 --continue 的
+        // 会话同样会在 30 天不活动后被物理删除，用户显式续接的历史静默丢失）。
+        if (existing.agentType === 'print') {
+            await upgradeTemporarySession(deps.db, opts.sessionId);
+        }
         session = existing;
     }
     else {
-        session = await createSession(deps.db, 'cli-print', undefined, undefined, 'cli');
+        // agentType='print'：一次性 print 会话标记。purgeTemporarySessions 仅清理
+        // print/workflow 会话；普通 CLI 会话（ACP 等）与 --continue 续接的历史永不误删。
+        session = await createSession(deps.db, 'cli-print', undefined, 'print', 'cli');
     }
     const agentConfig = {
         provider: config.defaultProvider,

package/dist/core/compact.d.ts

@@ -1,10 +1,12 @@
 import type { DB } from '../db/client.js';
 import type { Registry } from '../llm/registry.js';
+import type { FallbackChain } from '../llm/routing.js';
 import type { CompactionConfig, CompactionResult, Summarizer } from '../session/types.js';
 /** Create a Summarizer backed by an LLM streaming call. */
 declare function createSummarizer(registry: Registry, provider: string, model: string, opts?: {
     maxTokens?: number;
     signal?: AbortSignal;
+    fallback?: FallbackChain;
 }): Summarizer;
 /** Run compaction on a session using the provided summarizer. */
 declare function runCompaction(db: DB, sessionId: string, summarizer: Summarizer, config?: Partial<CompactionConfig>): Promise<CompactionResult>;

package/dist/core/compact.js

@@ -13,6 +13,7 @@ function createSummarizer(registry, provider, model, opts) {
         for await (const chunk of chatStream({ registry, signal: opts?.signal }, request, {
             provider,
             model,
+            ...(opts?.fallback ? { fallback: opts.fallback } : {}),
         })) {
             if (chunk._tag === 'text') {
                 chunks.push(chunk);

package/dist/core/config.d.ts

@@ -25,8 +25,17 @@ declare function applyScopedPatch(base: Record<string, unknown> | undefined, pat
  * 用于「patch 合并进某个作用域的原始文件」后再写盘。
  */
 declare function mergeRaw(...cfgs: (Record<string, unknown> | undefined)[]): Record<string, unknown>;
-/** 把 raw JSON 写回指定作用域配置文件（不含默认值）。 */
+/** 把 raw JSON 写回指定作用域配置文件（不含默认值）。
+ *  - 落盘前对 providers[].apiKey 加密（已带 enc: 前缀/空值透传）——
+ *    CLI config set 与 /config 斜杠命令共用此路径，保证「apiKey 不明文落盘」全链路成立。
+ *  - 写入后 chmod 600：配置文件可能含 token/加密密钥，默认 0644 同机可读。 */
 declare function saveConfigScoped(scope: 'global' | 'project', projectDir: string | undefined, data: Record<string, unknown>): Promise<void>;
 declare function loadConfig(projectDir?: string): Promise<Config>;
+/** Config 全部顶层键（DEFAULT_CONFIG + 可选键）。未知顶层键校验与告警共用。 */
+declare const KNOWN_CONFIG_KEYS: Set<string>;
+/** 收集对象中不属于 Config 顶层键的未知键。 */
+declare function collectUnknownConfigKeys(data: Record<string, unknown> | undefined): string[];
+/** 加载配置时对未知顶层键告警（拼写错误/旧版键静默失效的唯一提示）。 */
+declare function warnUnknownConfigKeys(scope: 'global' | 'project', data: Record<string, unknown> | undefined): void;
 export type { AgentsConfig, CompactionConfig, Config, MCPServerConfig, PermissionConfig, SecurityConfig, ToolMetricsConfig, UpdateConfig, WebSearchConfig, };
-export { applyScopedPatch, DEFAULT_CONFIG, loadConfig, loadConfigScopes, mergeConfig, mergeRaw, saveConfigScoped, };
+export { applyScopedPatch, collectUnknownConfigKeys, DEFAULT_CONFIG, KNOWN_CONFIG_KEYS, loadConfig, loadConfigScopes, mergeConfig, mergeRaw, saveConfigScoped, warnUnknownConfigKeys, };

package/dist/core/config.js

@@ -1,6 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { encryptSecret, isEncryptedSecret } from './secret.js';
 const GLOBAL_CONFIG_DIR = '.c0de';
 const CONFIG_FILENAME = 'config.json';
 const DEFAULT_CONFIG = {
@@ -21,7 +22,9 @@ const DEFAULT_CONFIG = {
     tools: { enabled: [], disabled: [] },
     plugins: { enabled: [] },
     mcpServers: [],
-    slashCommands: { enabled: ['/compact', '/model', '/clear', '/help', '/fork', '/config'] },
+    slashCommands: {
+        enabled: ['/compact', '/model', '/clear', '/help', '/fork', '/config', '/workflow'],
+    },
     toolMetrics: { enabled: true, threshold: 0.8, minSamples: 5 },
     security: { authEnabled: true, allowedOrigins: [] },
     websearch: { provider: 'auto' },
@@ -29,7 +32,6 @@ const DEFAULT_CONFIG = {
     permission: { defaultMode: 'default' },
     update: { enabled: true, intervalMs: 60 * 60 * 1000, initialDelayMs: 10_000 },
     theme: 'system',
-    locale: 'en',
 };
 function mergeConfig(...configs) {
     const result = structuredClone(DEFAULT_CONFIG);
@@ -138,7 +140,10 @@ function mergeRaw(...cfgs) {
     }
     return result;
 }
-/** 把 raw JSON 写回指定作用域配置文件（不含默认值）。 */
+/** 把 raw JSON 写回指定作用域配置文件（不含默认值）。
+ *  - 落盘前对 providers[].apiKey 加密（已带 enc: 前缀/空值透传）——
+ *    CLI config set 与 /config 斜杠命令共用此路径，保证「apiKey 不明文落盘」全链路成立。
+ *  - 写入后 chmod 600：配置文件可能含 token/加密密钥，默认 0644 同机可读。 */
 async function saveConfigScoped(scope, projectDir, data) {
     const dir = scope === 'global'
         ? join(homedir(), GLOBAL_CONFIG_DIR)
@@ -146,13 +151,75 @@ async function saveConfigScoped(scope, projectDir, data) {
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
     const path = join(dir, CONFIG_FILENAME);
-    writeFileSync(path, JSON.stringify(data, null, 2), 'utf-8');
+    const hardened = redactSensitiveOnSave(data);
+    writeFileSync(path, JSON.stringify(hardened, null, 2), 'utf-8');
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // 平台不支持（Windows 等）时忽略；内容仍已加密。
+    }
+}
+/** 落盘前的敏感值处理：providers[].apiKey 与 websearch 后端 key 明文 → enc: 加密
+ *  （spec §24.2；此前 websearch.tavilyApiKey/braveApiKey 明文落盘，与 provider
+ *  apiKey 安全叙事不一致——git 误提交警告会命中它们，加密却不会）。 */
+function redactSensitiveOnSave(data) {
+    const out = {};
+    for (const [key, val] of Object.entries(data)) {
+        if (key === 'providers' && Array.isArray(val)) {
+            out[key] = val.map((p) => {
+                if (p === null || typeof p !== 'object')
+                    return p;
+                const apiKey = p.apiKey;
+                if (typeof apiKey === 'string' && apiKey.length > 0 && !isEncryptedSecret(apiKey)) {
+                    return { ...p, apiKey: encryptSecret(apiKey) };
+                }
+                return p;
+            });
+            continue;
+        }
+        if (key === 'websearch' && val !== null && typeof val === 'object') {
+            const ws = { ...val };
+            for (const k of ['tavilyApiKey', 'braveApiKey']) {
+                const v = ws[k];
+                if (typeof v === 'string' && v.length > 0 && !isEncryptedSecret(v)) {
+                    ws[k] = encryptSecret(v);
+                }
+            }
+            out[key] = ws;
+            continue;
+        }
+        out[key] = val;
+    }
+    return out;
 }
 async function loadConfig(projectDir) {
     const globalPath = join(homedir(), GLOBAL_CONFIG_DIR, CONFIG_FILENAME);
     const projectPath = join(projectDir ?? process.cwd(), '.c0de', CONFIG_FILENAME);
     const global = readJsonIfExists(globalPath);
     const project = readJsonIfExists(projectPath);
+    warnUnknownConfigKeys('global', global);
+    warnUnknownConfigKeys('project', project);
     return mergeConfig(global, project);
 }
-export { applyScopedPatch, DEFAULT_CONFIG, loadConfig, loadConfigScopes, mergeConfig, mergeRaw, saveConfigScoped, };
+/** Config 全部顶层键（DEFAULT_CONFIG + 可选键）。未知顶层键校验与告警共用。 */
+const KNOWN_CONFIG_KEYS = new Set([
+    ...Object.keys(DEFAULT_CONFIG),
+    // 可选键不在 DEFAULT_CONFIG 中（缺失=未配置），但属于合法键。
+    'commitModel',
+]);
+/** 收集对象中不属于 Config 顶层键的未知键。 */
+function collectUnknownConfigKeys(data) {
+    if (!data)
+        return [];
+    return Object.keys(data).filter((k) => !KNOWN_CONFIG_KEYS.has(k));
+}
+/** 加载配置时对未知顶层键告警（拼写错误/旧版键静默失效的唯一提示）。 */
+function warnUnknownConfigKeys(scope, data) {
+    const unknown = collectUnknownConfigKeys(data);
+    if (unknown.length === 0)
+        return;
+    console.warn(`[config] ${scope} 配置包含未知键：${unknown.join(', ')}。` +
+        `这些键不会生效——请检查拼写，或移除过时配置。有效顶层键：${[...KNOWN_CONFIG_KEYS].join(', ')}`);
+}
+export { applyScopedPatch, collectUnknownConfigKeys, DEFAULT_CONFIG, KNOWN_CONFIG_KEYS, loadConfig, loadConfigScopes, mergeConfig, mergeRaw, saveConfigScoped, warnUnknownConfigKeys, };

package/dist/core/loop/compaction.d.ts

@@ -27,5 +27,6 @@ export declare function recoverFromOverflow(state: AgentState, deps: LoopDeps):
  *    死锁在下一轮用户输入（agentLoop 重入）时重置。
  *  - mid-turn：midTurnEnabled 单独 opt-in（默认关闭）时按 enabled:true 阈值静默压缩，
  *    复用 shouldCompact 逻辑但不发 error/warning，压缩后刷新内存消息视图。
- *  两者都静默消费 compactContext 的 text_delta 通知（不透传给用户）。 */
+ *  两者都静默消费 compactContext 的 text_delta 通知，但把 compaction_done 透传给前端，
+ *  让用户在上下文被改写时得到提示（可在归档面板查看原始内容）。 */
 export declare function runCompactionIfNeeded(state: AgentState, deps: LoopDeps, latestMessages: Message[]): AsyncGenerator<AgentEvent>;

package/dist/core/loop/compaction.js

@@ -1,3 +1,4 @@
+import { buildFallbackChain } from '../../llm/routing.js';
 import { getMessages } from '../../session/message.js';
 import { createSummarizer, runCompaction } from '../compact.js';
 import { estimateBudget, shouldCompact } from '../context.js';
@@ -13,7 +14,13 @@ import { estimateBudget, shouldCompact } from '../context.js';
 export async function* compactContext(state, deps) {
     // summarizer 优先用 compactionModel 覆盖，否则回退当前会话 provider/model。
     const cm = state.compactionModel;
-    const summarizer = createSummarizer(deps.llmRegistry, cm ? cm.provider : state.config.provider, cm ? cm.model : state.config.model, { signal: state.abortController.signal });
+    const provider = cm ? cm.provider : state.config.provider;
+    const model = cm ? cm.model : state.config.model;
+    const fallback = buildFallbackChain(deps.config, provider, model);
+    const summarizer = createSummarizer(deps.llmRegistry, provider, model, {
+        signal: state.abortController.signal,
+        ...(fallback ? { fallback } : {}),
+    });
     const result = await runCompaction(deps.db, state.session.id, summarizer, {
         keepRecentTokens: deps.config.compaction.keepRecentTokens,
     });
@@ -77,15 +84,19 @@ export async function recoverFromOverflow(state, deps) {
  *    死锁在下一轮用户输入（agentLoop 重入）时重置。
  *  - mid-turn：midTurnEnabled 单独 opt-in（默认关闭）时按 enabled:true 阈值静默压缩，
  *    复用 shouldCompact 逻辑但不发 error/warning，压缩后刷新内存消息视图。
- *  两者都静默消费 compactContext 的 text_delta 通知（不透传给用户）。 */
+ *  两者都静默消费 compactContext 的 text_delta 通知，但把 compaction_done 透传给前端，
+ *  让用户在上下文被改写时得到提示（可在归档面板查看原始内容）。 */
 export async function* runCompactionIfNeeded(state, deps, latestMessages) {
     // 死锁时跳过自动压缩：上一轮压缩已证明无法释放足够空间，重试只会无限循环。
     if (!state.compactionDeadEnd &&
         shouldCompact(latestMessages, state.tokenBudget, deps.config.compaction)) {
         // 自动压缩：复用 compactContext；失败非致命，仅记录警告不中断主循环。
         try {
-            for await (const _ev of compactContext(state, deps)) {
-                // 静默消费压缩通知事件，不透传给用户（保持自动压缩的原有静默语义）
+            for await (const ev of compactContext(state, deps)) {
+                // 静默消费 text_delta 通知，但把 compaction_done 透传给前端——
+                // 上下文被改写，用户应被告知（可在归档面板查看原始内容），而非悄然失忆。
+                if (ev._tag === 'compaction_done')
+                    yield ev;
             }
             // 进度保护：compactContext 已重算 state.tokenBudget.used。若压缩后仍超阈值
             // （典型成因：keepRecentTokens 本身已超 historyBudget），压缩无法再释放足够
@@ -124,8 +135,10 @@ export async function* runCompactionIfNeeded(state, deps, latestMessages) {
         // 中轮压缩静默执行：compactContext 内部已发 text_delta 通知，
         // 不再 yield error/warning（与 turn-end 自动压缩的进度保护语义不同）。
         try {
-            for await (const _ev of compactContext(state, deps)) {
-                // 静默消费压缩通知，不透传给用户
+            for await (const ev of compactContext(state, deps)) {
+                // 静默消费 text_delta 通知，透传 compaction_done（与 turn-end 一致）。
+                if (ev._tag === 'compaction_done')
+                    yield ev;
             }
             // 压缩改写了消息历史 → 刷新内存视图，供下一轮上下文重建使用
             state.messages = await getMessages(deps.db, state.session.id);