c0de-agent 1.12.0 → 1.13.0

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,10 +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' },
         ],
     },
     {
@@ -35,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' },
@@ -62,8 +68,17 @@ const COMMANDS = [
     },
     {
         name: 'sessions',
-        description: 'Manage CLI/web sessions (list / delete / restore / deleted).',
-        options: [{ name: 'project', type: 'string' }],
+        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',
@@ -71,6 +86,8 @@ const COMMANDS = [
         options: [
             // serve 占用持久库时的显式临时模式开关（与 chat --temp 同语义）。
             { name: 'temp', type: 'boolean' },
+            // P1-2：ACP 同样无恢复 UI（超支中止），允许本 run 覆盖 warn/abort。
+            { name: 'budget-action', type: 'string' },
         ],
     },
     {
@@ -90,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 可用）；
@@ -98,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;
@@ -114,21 +167,26 @@ 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 正在运行并占用会话库，CLI 会话管理暂不可用（单写者限制）。\n' +
-                '  1) 在 Web 界面管理会话；\n' +
-                '  2) 或停止 serve（Ctrl+C）后重试本命令。');
+            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) 停止 serve 后重试（对话可持久化，推荐）；\n' +
-                '  2) 或加 --temp 显式接受临时模式（消息与工具调用不会保存）。');
+            throw new Error(`c0de serve 正在运行并占用会话库，本次对话将无法保存。\n` +
+                `  1) 在浏览器打开 ${webUrl} 继续对话（推荐，会话自动保存）；\n` +
+                `  2) 或停止 serve 后重试（对话可持久化）；\n` +
+                `  3) 或加 --temp 显式接受临时模式（消息与工具调用不会保存）。`);
         }
         process.stderr.write('[c0de] ⚠ 临时模式：消息与工具调用不会保存。停止 serve 后重试可持久化，或直接使用浏览器界面。\n');
         db = await createDB({ driver: 'pglite' });
@@ -139,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 {
@@ -168,12 +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;
         }
@@ -195,14 +268,21 @@ 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 非交互：所有工具放行（编辑器侧自行控制执行授权）。
+            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;
         }
@@ -225,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 };

package/dist/cli/modes/print.d.ts

@@ -9,6 +9,9 @@ type PrintOptions = {
     sessionId?: string;
     /** 事件观察回调（CLI 用于把 tool/thinking 写到 stderr）。 */
     onEvent?: (event: AgentEvent) => void;
+    /** P2-4：外部中止信号（ACP abort）——触发即中止 run 并抛错，
+     *  让调用方如实返回失败而非谎报 ok。 */
+    abortSignal?: AbortSignal;
 };
 /** 从事件流累积 assistant 文本。纯函数。 */
 declare function collectAssistantText(events: AgentEvent[]): string;

package/dist/cli/modes/print.js

@@ -1,7 +1,9 @@
-import { createAgent, runAgent } from '../../core/agent.js';
+import { resolve } from 'node:path';
+import { abortAgent, createAgent, runAgent } from '../../core/agent.js';
 import { resolveRoute } from '../../llm/registry.js';
+import { getByDirectory } from '../../project/index.js';
 import { createSession, getSession, upgradeTemporarySession } from '../../session/session.js';
-import { resolveEnabledToolNames } from '../../tools/index.js';
+import { PROJECT_BOUND_TOOLS, resolveEnabledToolNames } from '../../tools/index.js';
 /** 从事件流累积 assistant 文本。纯函数。 */
 function collectAssistantText(events) {
     let text = '';
@@ -24,9 +26,25 @@ 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}`);
+        // M2：会话在回收站（Web 已删除）时拒绝续接——否则消息会写入一个 Web 树
+        // 不可见的会话，与「删除」心智模型冲突。给出可操作的恢复途径。
+        if (existing.deletedAt) {
+            throw new Error(`该会话在回收站中（已删除）。请先在 Web 界面回收站中恢复，` +
+                `或停止 serve 后运行 \`c0de sessions restore ${opts.sessionId}\` 恢复，再续接。`);
+        }
+        // P2-6 修复：cwd 与会话 worktree 不一致时拒绝——文件工具在 cwd 执行，
+        // 而 kanban/预算等绑定 session.projectId，同一会话上下文会分裂到两个目录，
+        // 且毫无提示。给出切换目录的可操作指引，避免用户在错误目录误改文件。
+        const worktree = existing.worktreePath;
+        if (worktree && resolve(worktree) !== resolve(deps.cwd)) {
+            throw new Error(`该会话的工作目录（${worktree}）与当前目录（${deps.cwd}）不一致。` +
+                `请先切换到会话目录再续接：\n  cd "${worktree}"\n` +
+                `（会话绑定项目时，工具必须在原目录执行，否则看板与文件操作会分裂到两个目录）`);
+        }
         // 续接即升级为持久会话：30 天临时清理不再触及（P1：此前 --continue 的
         // 会话同样会在 30 天不活动后被物理删除，用户显式续接的历史静默丢失）。
-        if (existing.agentType === 'print') {
+        // P1-3：workflow 会话同口径——Web 继续追问的 workflow 会话此前无升级路径。
+        if (existing.agentType === 'print' || existing.agentType === 'workflow') {
             await upgradeTemporarySession(deps.db, opts.sessionId);
         }
         session = existing;
@@ -34,31 +52,76 @@ async function runPrintMode(config, message, deps, opts = {}) {
     else {
         // agentType='print'：一次性 print 会话标记。purgeTemporarySessions 仅清理
         // print/workflow 会话；普通 CLI 会话（ACP 等）与 --continue 续接的历史永不误删。
-        session = await createSession(deps.db, 'cli-print', undefined, 'print', 'cli');
+        // P1-2 CLI/Web 同树：cwd 已注册为项目时直接绑定（续接后 Web 树按项目可见）；
+        // worktreePath 落盘——Web 打开时工具在原目录执行，而非回退 serve cwd。
+        const existing = await getByDirectory(deps.db, deps.cwd);
+        session = await createSession(deps.db, 'cli-print', existing?.id, 'print', 'cli', undefined, deps.cwd);
     }
     const agentConfig = {
         provider: config.defaultProvider,
         model: opts.model ?? config.defaultModel,
-        // 工具集：enabled 非空 → enabled ∩ registered；空 → 全部 registered（disabled 已在 registry 层过滤）。
-        tools: resolveEnabledToolNames(deps.toolRegistry, config),
+        // 工具集：enabled 含 '*' → 全部 registered；空 → 无工具（fail-closed）；否则 enabled ∩ registered
+        // （disabled 已在 registry 层过滤）。无项目绑定（cwd 未注册为项目）时剔除
+        // 项目绑定工具（kanban 等）——其 store 不会被注入，调用必失败。
+        tools: resolveEnabledToolNames(deps.toolRegistry, config).filter((n) => Boolean(session.projectId) || !PROJECT_BOUND_TOOLS.has(n)),
         plugins: config.plugins.enabled,
         ...(opts.maxTokens !== undefined ? { maxTokens: opts.maxTokens } : {}),
     };
     // P3：首跑友好报错——未配置 provider 时不再让底层 NoRoute 异常裸抛，
     // 给出与 Web 端一致的引导（c0de serve → 设置 → Provider）。
+    // P1-3：区分三种失败（此前一律报「未配置」，配置了 provider 的用户被误导）：
+    //  - 完全没有配置 provider → 引导添加；
+    //  - provider 名不匹配（如 defaultProvider 仍是默认 'openai'，只配了 anthropic）
+    //    → 列出已配置清单 + 修正指引（与 Web PROVIDER_NOT_FOUND 对齐）；
+    //  - provider 声明了模型清单但请求模型不在其中 → 列出可用模型（与 Web
+    //    MODEL_NOT_FOUND 对齐）。
     try {
         resolveRoute(deps.llmRegistry, agentConfig.provider, agentConfig.model);
     }
     catch {
-        throw new Error('未配置可用的 AI 服务。请运行 `c0de serve` 并在「设置 → Provider」中添加 API 服务并测试连接，' +
-            '或使用 `c0de config set` 配置 providers。');
+        if (config.providers.length === 0) {
+            throw new Error('未配置可用的 AI 服务。请运行 `c0de serve` 并在「设置 → Provider」中添加 API 服务并测试连接，' +
+                '或使用 `c0de config set` 配置 providers。');
+        }
+        const configured = config.providers
+            .map((p) => p.name)
+            .filter(Boolean)
+            .join(', ');
+        throw new Error(`未找到名为「${agentConfig.provider}」的 AI 服务。已配置：${configured}。` +
+            `请检查拼写，或用 \`c0de config set defaultProvider <name>\` 修正默认服务。`);
+    }
+    const providerDef = config.providers.find((p) => p.name === agentConfig.provider);
+    const modelNames = providerDef?.models ? Object.keys(providerDef.models) : undefined;
+    if (modelNames && modelNames.length > 0 && !modelNames.includes(agentConfig.model)) {
+        throw new Error(`provider「${agentConfig.provider}」没有名为「${agentConfig.model}」的模型。` +
+            `已配置模型：${modelNames.join(', ')}（可用 \`c0de chat --model <model>\` 指定）。`);
     }
     const state = await createAgent(session, agentConfig, deps);
+    // P2-4：ACP abort 真中止——把外部信号桥接到该 run 的 abortController。
+    // abortAgent 会使 loop 在 turn/流边界 unwind，runAgent 随即结束。
+    if (opts.abortSignal) {
+        if (opts.abortSignal.aborted) {
+            throw new Error('已中止');
+        }
+        opts.abortSignal.addEventListener('abort', () => {
+            abortAgent(state);
+        }, { once: true });
+    }
     const events = [];
     for await (const event of runAgent(state, [{ _tag: 'text', text: message }], deps)) {
         events.push(event);
         opts.onEvent?.(event);
     }
+    // P2-4：中止后如实报错（ACP 客户端收到 error 响应，而非谎报 ok 的完成结果）。
+    if (opts.abortSignal?.aborted) {
+        throw new Error('已中止');
+    }
+    // 终态错误（unexpected，含预算中止）必须反馈给用户而非静默返回半截文本——
+    // 抛出后 dispatch 打印 message 并以非零码退出（预算超支中止等硬性护栏由此可见）。
+    const terminal = events.find((e) => e._tag === 'error' && e.error._tag === 'unexpected');
+    if (terminal && terminal._tag === 'error' && terminal.error._tag === 'unexpected') {
+        throw new Error(terminal.error.message);
+    }
     return collectAssistantText(events);
 }
 export { collectAssistantText, runPrintMode };

package/dist/core/agent.d.ts

@@ -3,7 +3,7 @@ import type { MessageContent, Session } from '../shared/types/message.js';
 import type { AgentDependencies } from './types.js';
 declare function createAgent(session: Session, config: AgentConfig, deps: AgentDependencies): Promise<AgentState>;
 declare function runAgent(state: AgentState, userInput: MessageContent[], deps: AgentDependencies): AsyncGenerator<AgentEvent>;
-declare function pauseAgent(state: AgentState): void;
+declare function pauseAgent(state: AgentState, reason?: string): void;
 declare function resumeAgent(state: AgentState): void;
 declare function abortAgent(state: AgentState): void;
 declare function getAgentStatus(state: AgentState): AgentStatus;

package/dist/core/agent.js

@@ -51,13 +51,18 @@ async function createAgent(session, config, deps) {
 }
 async function* runAgent(state, userInput, deps) {
     // 幂等重发保护：若 DB 末尾已是相同 user message（服务重启后续传场景），
-    // 跳过 append 避免重复。比较 text parts 内容即可区分不同消息。
+    // 跳过 append 避免重复。比较 text/image parts 全量内容——纯文本比较会在
+    // 「含图片消息重发」时误判为不同消息而追加重复条目（P1-2 修复）。
     const last = state.messages[state.messages.length - 1];
     const isDupUser = last?.role === 'user' &&
         last.content.length === userInput.length &&
         last.content.every((p, i) => {
             const q = userInput[i];
-            return p._tag === 'text' && q?._tag === 'text' ? p.text === q.text : false;
+            if (p._tag === 'text' && q?._tag === 'text')
+                return p.text === q.text;
+            if (p._tag === 'image' && q?._tag === 'image')
+                return p.mediaType === q.mediaType && p.data === q.data;
+            return false;
         });
     if (!isDupUser) {
         await appendMessage(deps.db, state.session.id, {
@@ -84,10 +89,10 @@ async function* runAgent(state, userInput, deps) {
     state.status = { _tag: 'running', turnCount: 0 };
     yield* agentLoop(state, deps);
 }
-function pauseAgent(state) {
+function pauseAgent(state, reason) {
     if (state.status._tag !== 'running')
         return;
-    state.status = { _tag: 'paused', pauseReason: 'User requested pause' };
+    state.status = { _tag: 'paused', pauseReason: reason ?? 'User requested pause' };
 }
 function resumeAgent(state) {
     if (state.status._tag !== 'paused')

package/dist/core/agents/builtin.js

@@ -19,7 +19,7 @@ const PLAN_ROLE = `You are c0de-agent in **Plan Mode**. Your job is to investiga
 - Use read-only tools (grep/glob/read) to understand the structure and relevant code.
 - Ask clarifying questions when requirements are ambiguous.
 - When ready, present a concrete implementation plan (files to touch, approach, risks).
-- Do NOT use edit/write tools to modify code. You may run bash for investigation only.`;
+- You have NO shell access and NO write tools in this mode. If investigation requires running a command or modifying files, note it as a step for the user to execute in default mode.`;
 /** 6 个内置 agent（2 primary + 4 subagent）。 */
 const BUILTIN_AGENTS = [
     {
@@ -32,7 +32,7 @@ const BUILTIN_AGENTS = [
     {
         name: 'plan',
         description: '计划模式（只读）。专注调研与方案设计，不直接改代码。',
-        tools: ['read', 'grep', 'glob', 'bash'],
+        tools: ['read', 'grep', 'glob'],
         systemPrompt: PLAN_ROLE,
         mode: 'primary',
         source: 'builtin',

package/dist/core/agents/index.d.ts

@@ -1,5 +1,4 @@
 export { BUILTIN_AGENTS, WORKER_BASE } from './builtin.js';
-export { loadAgentFile, loadAgents } from './discovery.js';
 export type { ParallelResult } from './parallel.js';
 export { mapWithConcurrencyLimit } from './parallel.js';
 export { createAgentRegistry } from './registry.js';

package/dist/core/agents/index.js

@@ -1,4 +1,3 @@
 export { BUILTIN_AGENTS, WORKER_BASE } from './builtin.js';
-export { loadAgentFile, loadAgents } from './discovery.js';
 export { mapWithConcurrencyLimit } from './parallel.js';
 export { createAgentRegistry } from './registry.js';