c0de-agent 1.11.0 → 1.13.0

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 { emptyTrash, getSession, listAllSessions, listDeletedSessions, permanentlyDeleteSession, rebindSession, restoreSession, softDeleteSession, touchTrashSeen, } 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,111 @@ 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）。
+    // P2：列出即「看到」——CLI-only 用户此前无 Web 回收站可打开，trashSeenAt 永不写入，
+    // 60 天保留期永不启动（条目只能等 365 天绝对上限）。此处与 Web 打开分组同口径
+    // 标记（仅首次、全量、含孤儿）。
+    // --project <path>：把「看到」标记与列表限定到单个项目（与 Web 按项目分组一致）——
+    // 缺省全库标记会启动所有项目回收站条目的倒计时，多项目用户应显式限定作用域。
+    if (sub === 'deleted') {
+        const projectPath = ctx.args.options.project;
+        let projectId;
+        if (projectPath) {
+            const { existsSync } = await import('node:fs');
+            if (!existsSync(projectPath)) {
+                throw new Error(`sessions deleted: 项目目录不存在：${projectPath}`);
+            }
+            projectId = (await fromDirectory(ctx.db, projectPath)).id;
+        }
+        await touchTrashSeen(ctx.db, projectId ? { projectId } : {});
+        const sessions = await listDeletedSessions(ctx.db, projectId);
+        if (sessions.length === 0) {
+            write('回收站为空。\n');
+            return;
+        }
+        if (!projectId) {
+            write('（全库回收站。多项目用户建议加 --project <路径> 限定作用域：全库「看到」标记会启动所有项目条目的保留期倒计时。）\n');
+        }
+        for (const s of sessions) {
+            const when = s.deletedAt ? new Date(s.deletedAt).toISOString() : '-';
+            write(`- ${s.title}  (id: ${s.id}, deleted ${when})\n`);
+        }
+        return;
+    }
+    // 彻底删除（不可恢复）：purge <id> 单条；purge --all 清空回收站。
+    // P2：CLI 回收站闭环——此前 CLI 无永久删除途径，条目只能被动等 purge 任务。
+    // 永久操作需 --yes（与 Web 键入确认的「彻底删除/清空回收站」同强度）。
+    if (sub === 'purge') {
+        const all = ctx.args.options.all === true;
+        const yes = ctx.args.options.yes === true;
+        const id = ctx.args.positionals[1];
+        if (!all && !id) {
+            throw new Error('sessions purge: 需要会话 id（purge <id>）或 --all（清空回收站），两者均不可恢复，需 --yes 确认');
+        }
+        if (!yes) {
+            throw new Error(all
+                ? 'sessions purge --all 将永久删除回收站全部会话，不可恢复。确认执行请加 --yes。'
+                : `sessions purge ${id} 将永久删除该会话及其派生分支，不可恢复。确认执行请加 --yes。`);
+        }
+        const deleted = all
+            ? await emptyTrash(ctx.db)
+            : await permanentlyDeleteSession(ctx.db, id ?? '');
+        if (all) {
+            write(`已清空回收站（永久删除 ${deleted} 个会话）。\n`);
+        }
+        else if (deleted > 0) {
+            write(`已永久删除会话 ${id}（含 ${deleted - 1} 个派生会话）。\n`);
+        }
+        else {
+            throw new Error(`sessions purge: 会话不在回收站或不存在：${id}`);
+        }
         return;
     }
-    throw new Error(`sessions: unknown subcommand "${sub}" (expected list|delete)`);
+    throw new Error(`sessions: unknown subcommand "${sub}" (expected list|delete|restore|deleted|purge)`);
 }
 export { runSessionsCommand };

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

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

package/dist/cli/commands/trust.js

@@ -0,0 +1,31 @@
+// src/cli/commands/trust.ts — 显式信任项目（P0-2 信任边界）。
+//
+// c0de trust [目录] [--yes]：把目录解析/注册为项目并落盘 trustedAt。
+// 未信任项目携带风险配置时 Web 聊天入口被 409 门禁拦截；项目 .c0de/plugins
+// 在未信任时不加载。本命令是无 Web 场景（headless/CI 前手工审查过仓库）的信任途径。
+// P1：信任前展示即将接受的风险清单（项目风险 + 全局权限风险上下文），有风险时
+// 必须 --yes 显式确认——Web 信任弹窗逐项明示，CLI 不得盲信任。
+// 与 sessions 命令同约束：需要持久库，serve 运行期间报错引导走 Web 界面。
+import { loadConfigScopes } from '../../core/config.js';
+import { fromDirectory, trustProject } from '../../project/project.js';
+import { enrichProjectRiskWithGlobal, summarizeProjectRisk } from '../../project/trust.js';
+async function runTrustCommand(ctx) {
+    const write = ctx.write ?? ((s) => process.stdout.write(s));
+    const dir = ctx.args.positionals[0] ?? ctx.cwd;
+    const yes = ctx.args.options.yes === true;
+    // 信任前明示即将接受的风险（与 Web 信任弹窗同口径：项目风险 + 全局权限风险上下文）。
+    // dir 传入使 summarizeProjectRisk 检测 .c0de/workflows（纯文件系统风险面）。
+    const scopes = loadConfigScopes(dir);
+    const risks = enrichProjectRiskWithGlobal(summarizeProjectRisk(scopes.project, dir), scopes.global);
+    if (risks.length > 0 && !yes) {
+        const lines = risks.map((r) => `  - ${r.kind}: ${r.detail}`).join('\n');
+        throw new Error(`信任「${dir}」将接受以下风险项：\n${lines}\n` +
+            `确认已审查无误后执行 c0de trust ${dir !== ctx.cwd ? `${dir} ` : ''}--yes 显式信任。`);
+    }
+    const project = await fromDirectory(ctx.db, dir);
+    await trustProject(ctx.db, project.id);
+    const accepted = risks.length > 0 ? `（已确认 ${risks.length} 项风险）` : '（无风险项）';
+    write(`已信任项目「${project.name ?? project.worktree}」（${project.worktree}）${accepted}。\n` +
+        `该项目作用域配置（.c0de/config.json）生效，项目插件与工作流在下次启动/刷新后加载。\n`);
+}
+export { runTrustCommand };

package/dist/cli/commands/update.js

@@ -9,6 +9,10 @@ async function runUpdateCommand(ctx) {
     const out = ctx.out ?? ((s) => process.stdout.write(`${s}\n`));
     const check = ctx.checkFn ?? checkForUpdate;
     const result = await check();
+    if (result.checkError) {
+        out('检查更新失败：无法连接 npm registry，请检查网络后重试');
+        return;
+    }
     out(`当前版本 ${result.currentVersion}，最新版本 ${result.latestVersion}`);
     if (!result.hasUpdate) {
         out('已是最新版本');

package/dist/cli/deps.d.ts

@@ -9,11 +9,7 @@ import type { PermissionChecker } from '../tools/types.js';
 type PermissionStrategy = 'full-auto' | 'safe';
 /** 真正非交互模式（print/acp）：所有工具无条件放行（命令由用户显式触发）。 */
 declare const fullyAutoApproveChecker: PermissionChecker;
-/**
- * 非交互模式（print）安全策略（P1-6）：ask 工具**直接拒绝**并给出可操作提示
- * （-y 或 serve），而非返回 permission_required 让 LLM 在无确认通道下无限重试。
- * 拒绝原因作为 tool result 交给模型，模型会向用户转述。
- */
+/** 无白名单的非交互安全策略（保留导出兼容既有调用方）。 */
 declare const nonInteractiveSafeChecker: PermissionChecker;
 /** 把 config.providers 注册到新建的 LLM registry。 */
 declare function buildLLMRegistry(config: Config): Registry;
@@ -23,10 +19,17 @@ type BuildDepsOptions = {
     /** 权限策略：'full-auto' 全部放行；'safe' 只读放行、写操作 ask。不传时按
      * config.permission.defaultMode 决定（'auto'→full-auto，'default'→safe）。 */
     permissionStrategy?: PermissionStrategy;
+    /** --allow 白名单（safe 模式下 ask 工具定向放行）。 */
+    allowTools?: string[];
     /** 测试注入 mock chatStream。 */
     chatStream?: LoopDeps['chatStream'];
 };
+/**
+ * cwd 是否当前可信项目（trustedAt 非空且指纹未漂移）。与聊天门禁/插件加载同口径；
+ * CLI 工作流注册表（内置+用户级+项目级）的构建也用它决定是否 import 项目级文件。
+ */
+declare function resolveCwdProjectTrusted(db: DB, cwd: string): Promise<boolean>;
 /** 组装完整 LoopDeps（默认 safe 放行 + 默认工具注册表）。 */
 declare function buildAgentDeps(config: Config, opts: BuildDepsOptions): Promise<LoopDeps>;
 export type { BuildDepsOptions, PermissionStrategy };
-export { buildAgentDeps, buildLLMRegistry, fullyAutoApproveChecker, nonInteractiveSafeChecker };
+export { buildAgentDeps, buildLLMRegistry, fullyAutoApproveChecker, nonInteractiveSafeChecker, resolveCwdProjectTrusted, };

package/dist/cli/deps.js

@@ -1,6 +1,9 @@
+import { loadConfigScopes } from '../core/config.js';
 import { decryptSecret } from '../core/secret.js';
 import { createRegistry, overrideToCapabilities, registerProvider } from '../llm/index.js';
 import { initPlugins } from '../plugins/index.js';
+import { getByDirectory } from '../project/index.js';
+import { projectTrustCurrent } from '../project/trust.js';
 import { createDefaultRegistry, createDefaultURLRegistry } from '../tools/index.js';
 import { autoAllowChecker } from '../tools/permission.js';
 /** 真正非交互模式（print/acp）：所有工具无条件放行（命令由用户显式触发）。 */
@@ -14,20 +17,29 @@ const fullyAutoApproveChecker = {
  * 非交互模式（print）安全策略（P1-6）：ask 工具**直接拒绝**并给出可操作提示
  * （-y 或 serve），而非返回 permission_required 让 LLM 在无确认通道下无限重试。
  * 拒绝原因作为 tool result 交给模型，模型会向用户转述。
+ * `allowTools`（--allow 白名单）内的 ask 工具改为放行，提供「全拒 / 全放行」之间的
+ * 逐工具粒度；未列出的 ask 工具仍拒绝。
  */
-const nonInteractiveSafeChecker = {
-    check: async (tool, _input, _ctx) => {
-        const result = await autoAllowChecker.check(tool, _input, _ctx);
-        if (result._tag === 'ask') {
-            return {
-                _tag: 'deny',
-                reason: `非交互模式：工具 "${tool.name}" 需要确认。请加 -y 放行写操作，或使用 c0de serve 交互确认`,
-            };
-        }
-        return result;
-    },
-    confirm: autoAllowChecker.confirm,
-};
+function createNonInteractiveChecker(allowTools) {
+    const allowSet = new Set(allowTools ?? []);
+    return {
+        check: async (tool, _input, _ctx) => {
+            const result = await autoAllowChecker.check(tool, _input, _ctx);
+            if (result._tag === 'ask') {
+                if (allowSet.has(tool.name))
+                    return { _tag: 'allow' };
+                return {
+                    _tag: 'deny',
+                    reason: `非交互模式：工具 "${tool.name}" 需要确认。请加 -y 全量放行、--allow <工具名> 定向放行，或使用 c0de serve 交互确认`,
+                };
+            }
+            return result;
+        },
+        confirm: autoAllowChecker.confirm,
+    };
+}
+/** 无白名单的非交互安全策略（保留导出兼容既有调用方）。 */
+const nonInteractiveSafeChecker = createNonInteractiveChecker();
 /** 把 config.providers 注册到新建的 LLM registry。 */
 function buildLLMRegistry(config) {
     const registry = createRegistry();
@@ -53,25 +65,52 @@ function registerProviderFromConfig(registry, p) {
         ...(p.models ? { models: overrideToCapabilities(p.models) } : {}),
     });
 }
-/** 解析权限 checker：显式策略优先，否则回退到 config.permission.defaultMode。 */
-function resolvePermissionChecker(config, strategy) {
+/** 解析权限 checker：显式策略优先，否则回退到 config.permission.defaultMode。
+ *  无 --allow 白名单时返回单例 nonInteractiveSafeChecker（保持对象同一性）；有白名单
+ *  时按白名单新建 checker（--allow 只影响 ask 工具的定向放行）。 */
+function resolvePermissionChecker(config, strategy, allowTools) {
     if (strategy === 'full-auto')
         return fullyAutoApproveChecker;
+    const listed = allowTools !== undefined && allowTools.length > 0;
     if (strategy === 'safe')
-        return nonInteractiveSafeChecker;
+        return listed ? createNonInteractiveChecker(allowTools) : nonInteractiveSafeChecker;
     return config.permission.defaultMode === 'auto'
         ? fullyAutoApproveChecker
-        : nonInteractiveSafeChecker;
+        : listed
+            ? createNonInteractiveChecker(allowTools)
+            : nonInteractiveSafeChecker;
+}
+/**
+ * cwd 是否当前可信项目（trustedAt 非空且指纹未漂移）。与聊天门禁/插件加载同口径；
+ * CLI 工作流注册表（内置+用户级+项目级）的构建也用它决定是否 import 项目级文件。
+ */
+async function resolveCwdProjectTrusted(db, cwd) {
+    try {
+        const p = await getByDirectory(db, cwd);
+        if (p?.trustedAt != null) {
+            return projectTrustCurrent(loadConfigScopes(cwd).project, p.trustedAt, p.riskFingerprint, cwd);
+        }
+    }
+    catch {
+        // 查询失败 → 未信任
+    }
+    return false;
 }
 /** 组装完整 LoopDeps（默认 safe 放行 + 默认工具注册表）。 */
 async function buildAgentDeps(config, opts) {
     const llmRegistry = buildLLMRegistry(config);
     const toolRegistry = createDefaultRegistry(config);
+    // P0-2：项目插件仅在项目被显式信任后加载（c0de trust <dir>）；内存库
+    // （--temp/锁冲突降级）不含项目记录 → 未信任，项目插件不加载。
+    // P0（代码面）：已信任但指纹漂移（插件代码/MCP 参数/风险键变更）→ 不加载，
+    // 与聊天门禁同口径。
+    const projectTrusted = await resolveCwdProjectTrusted(opts.db, opts.cwd);
     const { hookRunner } = await initPlugins({
         cwd: opts.cwd,
         config,
         toolRegistry,
         llmRegistry,
+        projectTrusted,
     });
     const deps = {
         db: opts.db,
@@ -79,11 +118,19 @@ async function buildAgentDeps(config, opts) {
         toolRegistry,
         urlRegistry: createDefaultURLRegistry(),
         hookRunner,
-        permission: resolvePermissionChecker(config, opts.permissionStrategy),
+        permission: resolvePermissionChecker(config, opts.permissionStrategy, opts.allowTools),
         config,
         cwd: opts.cwd,
         ...(opts.chatStream ? { chatStream: opts.chatStream } : {}),
+        // P：预算护栏 CLI 变体——print/acp 无恢复 UI，超支中止 run（产出 error）而非
+        // 暂停永久挂起。金额与 token 任一动作='pause'/'abort' 即启用（每轮 LLM 请求前检查）。
+        ...(config.usage?.budgetAction === 'pause' ||
+            config.usage?.budgetAction === 'abort' ||
+            config.usage?.tokenBudgetAction === 'pause' ||
+            config.usage?.tokenBudgetAction === 'abort'
+            ? { budgetAbort: true }
+            : {}),
     };
     return deps;
 }
-export { buildAgentDeps, buildLLMRegistry, fullyAutoApproveChecker, nonInteractiveSafeChecker };
+export { buildAgentDeps, buildLLMRegistry, fullyAutoApproveChecker, nonInteractiveSafeChecker, resolveCwdProjectTrusted, };

package/dist/cli/index.d.ts

@@ -4,5 +4,8 @@ declare const COMMANDS: CommandSpec[];
 type DispatchOverrides = {
     runServe?: () => Promise<void>;
 };
+/** P1-2：解析 --budget-action 覆盖值。CLI 无「恢复」UI，config 的 pause 在此等效 abort；
+ *  接受 warn|abort（pause 兼容映射到 abort）。非法值抛错并提示可取值。 */
+declare function parseBudgetActionOption(value: string | undefined): 'warn' | 'abort' | undefined;
 declare function dispatch(argv: string[], overrides?: DispatchOverrides): Promise<void>;
-export { COMMANDS, dispatch };
+export { COMMANDS, dispatch, parseBudgetActionOption };

package/dist/cli/index.js

@@ -4,7 +4,8 @@ import { mkdirSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { loadConfig } from '../core/config.js';
 import { createDB, migrateDB } from '../db/index.js';
-import { acquireDevDbLock, releaseDevDbLock, resolveDbDir } from '../server/server.js';
+import { enforceProjectTrust } from '../project/index.js';
+import { acquireDevDbLock, readServeInfo, releaseDevDbLock, resolveDbDir, } from '../server/server.js';
 import { runAcpCommand } from './commands/acp.js';
 import { runAuthCommand } from './commands/auth.js';
 import { runChatCommand } from './commands/chat.js';
@@ -13,6 +14,7 @@ import { runInitCommand } from './commands/init.js';
 import { runPluginCommand } from './commands/plugin.js';
 import { runServeCommand } from './commands/serve.js';
 import { runSessionsCommand } from './commands/sessions.js';
+import { runTrustCommand } from './commands/trust.js';
 import { runUpdateCommand } from './commands/update.js';
 import { buildAgentDeps } from './deps.js';
 import { parseCommand } from './parser.js';
@@ -24,7 +26,13 @@ const COMMANDS = [
             { name: 'model', type: 'string' },
             { name: 'format', type: 'string' },
             { name: 'yes', type: 'boolean', short: 'y' },
+            { name: 'allow', type: 'string' },
             { name: 'continue', type: 'string' },
+            // P2 修复：serve 运行时持久库被占用，此前静默退化为内存库（会话不保存，
+            // 仅 stderr 一行提示极易错过）。现须显式 --temp 才允许临时模式。
+            { name: 'temp', type: 'boolean' },
+            // P1-2：CLI 无「恢复」交互，预算 pause 在此等效「超支中止」；允许本 run 覆盖。
+            { name: 'budget-action', type: 'string' },
         ],
     },
     {
@@ -32,6 +40,7 @@ const COMMANDS = [
         description: 'Start the HTTP server (default when no command given).',
         options: [
             { name: 'port', type: 'string' },
+            { name: 'host', type: 'string' },
             { name: 'open', type: 'boolean' },
             { name: 'restore', type: 'string' },
             { name: 'handoff-port', type: 'string' },
@@ -59,13 +68,27 @@ const COMMANDS = [
     },
     {
         name: 'sessions',
-        description: 'Manage CLI/web sessions (list / delete).',
-        options: [],
+        description: 'Manage CLI/web sessions (list / delete / restore / deleted / purge).',
+        options: [
+            { name: 'project', type: 'string' },
+            { name: 'yes', type: 'boolean', short: 'y' },
+            { name: 'all', type: 'boolean' },
+        ],
+    },
+    {
+        name: 'trust',
+        description: 'Trust a project directory: enable its project-scope config and plugins.',
+        options: [{ name: 'yes', type: 'boolean', short: 'y' }],
     },
     {
         name: 'acp',
         description: 'Run in Agent Client Protocol mode (editor integration).',
-        options: [],
+        options: [
+            // serve 占用持久库时的显式临时模式开关（与 chat --temp 同语义）。
+            { name: 'temp', type: 'boolean' },
+            // P1-2：ACP 同样无恢复 UI（超支中止），允许本 run 覆盖 warn/abort。
+            { name: 'budget-action', type: 'string' },
+        ],
     },
     {
         name: 'update',
@@ -84,6 +107,17 @@ function isDbLockConflict(err) {
         return true;
     return err.name === 'RuntimeError' && /abort/i.test(err.message);
 }
+/** P1-2：解析 --budget-action 覆盖值。CLI 无「恢复」UI，config 的 pause 在此等效 abort；
+ *  接受 warn|abort（pause 兼容映射到 abort）。非法值抛错并提示可取值。 */
+function parseBudgetActionOption(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === 'warn')
+        return 'warn';
+    if (value === 'abort' || value === 'pause')
+        return 'abort';
+    throw new Error(`--budget-action 仅支持 warn|abort（CLI 无恢复 UI，config 的 pause 在此等效 abort）`);
+}
 /** 封装 agent 依赖生命周期：加载配置 → 建库迁移 → 组装 deps → 使用后关库。
  *  chat / acp 两个命令复用同一套逻辑（此前在 dispatch 中各写一份）。
  *  数据库优先用全局 dataDir 持久库（会话可恢复，--continue 可用）；
@@ -92,6 +126,31 @@ function isDbLockConflict(err) {
  *  带 --continue 时内存库不含历史会话，直接报错退出而非误导性的 session not found。 */
 async function withAgentDeps(cwd, opts, fn) {
     const config = await loadConfig(cwd);
+    // P1-2：--budget-action 覆盖（warn=不中止；abort=超支中止）。
+    // 直接映射为 config 的 abort 动作（不再借 'pause' 中转）：
+    // 预算预检、buildAgentDeps 的 budgetAbort 注入、超支判定文案三处口径一致。
+    // CLI 无「恢复」UI，config 的 pause 在此等效 abort。
+    if (opts.budgetAction) {
+        const action = opts.budgetAction === 'abort' ? 'abort' : 'warn';
+        config.usage = { ...config.usage, budgetAction: action, tokenBudgetAction: action };
+    }
+    const budgetWillAbort = config.usage?.budgetAction === 'pause' ||
+        config.usage?.budgetAction === 'abort' ||
+        config.usage?.tokenBudgetAction === 'pause' ||
+        config.usage?.tokenBudgetAction === 'abort';
+    const budgetConfigured = (config.usage?.monthlyBudgetUsd ?? 0) > 0 ||
+        (config.usage?.globalMonthlyBudgetUsd ?? 0) > 0 ||
+        (config.usage?.monthlyTokenBudget ?? 0) > 0 ||
+        (config.usage?.globalMonthlyTokenBudget ?? 0) > 0;
+    if (opts.budgetAction === undefined && budgetWillAbort && budgetConfigured) {
+        // 文案按配置实际动作区分：pause 与 abort 在 CLI 下都等价于中止本次 run，
+        // 但用户应知道自己配置的是什么。
+        const effective = config.usage?.budgetAction === 'abort' || config.usage?.tokenBudgetAction === 'abort'
+            ? 'abort'
+            : 'pause';
+        process.stderr.write(`[c0de] ⚠ 预算动作为 ${effective}：CLI 无「恢复」交互，超预算将中止本次 run（无断点续跑）。` +
+            '如需仅告警不中止，加 `--budget-action warn`。\n');
+    }
     const dataDir = resolveDbDir();
     let db;
     let holdLock = false;
@@ -108,15 +167,28 @@ async function withAgentDeps(cwd, opts, fn) {
         holdLock = false;
         if (!isDbLockConflict(err))
             throw err;
+        // serve 运行时引导：读取运行中实例的端口（serve-info.json），直接给出可点击的
+        // Web 地址，而不是让用户面对「单写者限制」无从下手。
+        const info = readServeInfo(dataDir);
+        const webUrl = info && info.port > 0 ? `http://localhost:${info.port}/` : '启动日志中打印的地址';
         if (opts.requirePersistent) {
-            throw new Error('c0de serve 正在运行并占用会话库。请通过 Web UI 管理会话，或停止 serve 后重试。');
+            throw new Error(`c0de serve 正在运行并占用会话库，CLI 会话管理暂不可用（单写者限制）。\n` +
+                `  1) 在浏览器打开 ${webUrl} 管理会话；\n` +
+                `  2) 或停止 serve（Ctrl+C）后重试本命令。`);
         }
         if (opts.continueSessionId) {
             throw new Error(`无法续聊会话 ${opts.continueSessionId}：持久库被 c0de serve 占用，内存模式无法续聊。\n` +
-                `请停止 serve 后重试，或去掉 --continue 开启新会话。`);
+                `请在浏览器打开 ${webUrl} 找到该会话继续对话；或停止 serve 后重试。`);
+        }
+        if (!opts.allowTemp) {
+            // P2 修复：锁冲突不再静默降级为不保存会话的内存模式（用户极易错过 stderr
+            // 提示导致对话丢失）。必须显式 --temp 确认放弃持久化。
+            throw new Error(`c0de serve 正在运行并占用会话库，本次对话将无法保存。\n` +
+                `  1) 在浏览器打开 ${webUrl} 继续对话（推荐，会话自动保存）；\n` +
+                `  2) 或停止 serve 后重试（对话可持久化）；\n` +
+                `  3) 或加 --temp 显式接受临时模式（消息与工具调用不会保存）。`);
         }
-        process.stderr.write('[c0de] ⚠ c0de serve 正在运行：本次对话为临时模式，消息与工具调用不会保存。\n' +
-            '       停止 serve 后重试可持久化，或直接使用浏览器界面。\n');
+        process.stderr.write('[c0de] ⚠ 临时模式：消息与工具调用不会保存。停止 serve 后重试可持久化，或直接使用浏览器界面。\n');
         db = await createDB({ driver: 'pglite' });
         await migrateDB(db);
     }
@@ -125,7 +197,13 @@ async function withAgentDeps(cwd, opts, fn) {
             db,
             cwd,
             ...(opts.strategy ? { permissionStrategy: opts.strategy } : {}),
+            ...(opts.allowTools ? { allowTools: opts.allowTools } : {}),
         });
+        // P0：agent 执行路径（chat/acp）在无 Web 确认弹窗下硬拦未信任项目的风险配置，
+        // 引导 c0de trust；trust/sessions 等非 agent 命令经 skipTrustGate 跳过。
+        if (opts.skipTrustGate !== true) {
+            await enforceProjectTrust(db, cwd);
+        }
         await fn(config, deps);
     }
     finally {
@@ -154,10 +232,21 @@ async function dispatch(argv, overrides = {}) {
         case 'chat': {
             // --yes / -y 显式放行写操作；否则按 config.permission.defaultMode 决定（默认 safe）。
             const strategy = args.options.yes ? 'full-auto' : undefined;
+            const allowTools = args.options.allow
+                ? String(args.options.allow)
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter((s) => s.length > 0)
+                : undefined;
             const continueId = args.options.continue;
+            const allowTemp = args.options.temp === true;
+            const budgetAction = parseBudgetActionOption(args.options['budget-action']);
             await withAgentDeps(cwd, {
                 ...(strategy ? { strategy } : {}),
+                ...(allowTools && allowTools.length > 0 ? { allowTools } : {}),
                 ...(continueId ? { continueSessionId: continueId } : {}),
+                ...(allowTemp ? { allowTemp } : {}),
+                ...(budgetAction ? { budgetAction } : {}),
             }, (config, deps) => runChatCommand({ args, config, deps }));
             return;
         }
@@ -179,12 +268,22 @@ async function dispatch(argv, overrides = {}) {
         }
         case 'sessions': {
             // 需要持久库列出/清理会话；serve 运行时内存库不含数据，直接失败而不是列空表。
-            await withAgentDeps(cwd, { requirePersistent: true }, (_config, deps) => runSessionsCommand({ args, db: deps.db }));
+            await withAgentDeps(cwd, { requirePersistent: true, skipTrustGate: true }, (_config, deps) => runSessionsCommand({ args, db: deps.db }));
+            return;
+        }
+        case 'trust': {
+            // 与 sessions 同约束：持久库落盘 trustedAt；serve 运行时引导走 Web 信任弹窗。
+            await withAgentDeps(cwd, { requirePersistent: true, skipTrustGate: true }, (_config, deps) => runTrustCommand({ args, db: deps.db, cwd }));
             return;
         }
         case 'acp': {
             // ACP 非交互：所有工具放行（编辑器侧自行控制执行授权）。
-            await withAgentDeps(cwd, { strategy: 'full-auto' }, (config, deps) => runAcpCommand({ config, deps }));
+            const budgetAction = parseBudgetActionOption(args.options['budget-action']);
+            await withAgentDeps(cwd, {
+                strategy: 'full-auto',
+                ...(args.options.temp === true ? { allowTemp: true } : {}),
+                ...(budgetAction ? { budgetAction } : {}),
+            }, (config, deps) => runAcpCommand({ config, deps }));
             return;
         }
         case 'update': {
@@ -206,7 +305,7 @@ async function main() {
         process.exit(1);
     }
 }
-export { COMMANDS, dispatch };
+export { COMMANDS, dispatch, parseBudgetActionOption };
 // bin 入口：仅在直接执行时运行 main（非被 import）。
 const isMain = process.argv[1] === fileURLToPath(import.meta.url);
 if (isMain) {

package/dist/cli/modes/acp.js

@@ -27,31 +27,62 @@ function formatACPEvent(method, params) {
     return JSON.stringify({ jsonrpc: '2.0', method, params });
 }
 async function runAcpLoop(opts) {
+    // P2-4：chat 在后台单飞执行——loop 继续读取后续请求（abort 等）而不被阻塞。
+    // 此前串行 await 使 abort 请求永远排在 chat 完成之后，中止形同虚设。
+    let chatInFlight = null;
+    const writer = opts.writer;
     for await (const line of opts.reader) {
         const trimmed = line.trim();
         if (!trimmed)
             continue;
         const req = parseACPRequest(trimmed);
         if (!req) {
-            opts.writer(formatACPError(null, -32700, 'Parse error'));
+            writer(formatACPError(null, -32700, 'Parse error'));
             continue;
         }
         const handler = opts.handlers[req.method];
         if (!handler) {
             if (req.id !== null)
-                opts.writer(formatACPError(req.id, -32601, `Method not found: ${req.method}`));
+                writer(formatACPError(req.id, -32601, `Method not found: ${req.method}`));
             continue;
         }
-        try {
-            const result = await handler(req.params);
+        const respond = (result) => {
             if (req.id !== null)
-                opts.writer(formatACPResponse(req.id, result));
-        }
-        catch (err) {
+                writer(formatACPResponse(req.id, result));
+        };
+        const fail = (err) => {
             if (req.id !== null) {
-                opts.writer(formatACPError(req.id, -32603, err instanceof Error ? err.message : String(err)));
+                writer(formatACPError(req.id, -32603, err instanceof Error ? err.message : String(err)));
             }
+        };
+        if (req.method === 'chat') {
+            if (chatInFlight) {
+                fail(new Error('chat: another chat is already in progress (abort it first)'));
+                continue;
+            }
+            chatInFlight = (async () => {
+                try {
+                    respond(await handler(req.params));
+                }
+                catch (err) {
+                    fail(err);
+                }
+                finally {
+                    chatInFlight = null;
+                }
+            })();
+            void chatInFlight;
+            continue;
+        }
+        try {
+            respond(await handler(req.params));
+        }
+        catch (err) {
+            fail(err);
         }
     }
+    // 流结束前等最后一个在途 chat 收尾，保证响应写全。
+    if (chatInFlight)
+        await chatInFlight;
 }
 export { formatACPError, formatACPEvent, formatACPResponse, parseACPRequest, runAcpLoop };