c0de-agent 1.12.0 → 1.13.0

package/dist/project/project.js

@@ -1,7 +1,9 @@
 import { basename } from 'node:path';
 import { eq } from 'drizzle-orm';
+import { loadConfigScopes } from '../core/config.js';
 import { kanbanBoards, projects, sessions } from '../db/schema.js';
 import { resolveProject } from './resolve.js';
+import { computeProjectRiskFingerprint, projectTrustNeeded } from './trust.js';
 function rowToProject(row) {
     return {
         id: row.id,
@@ -11,6 +13,12 @@ function rowToProject(row) {
         gitRemote: row.gitRemote,
         createdAt: row.createdAt instanceof Date ? row.createdAt.getTime() : new Date(row.createdAt).getTime(),
         updatedAt: row.updatedAt instanceof Date ? row.updatedAt.getTime() : new Date(row.updatedAt).getTime(),
+        trustedAt: row.trustedAt instanceof Date
+            ? row.trustedAt.getTime()
+            : row.trustedAt
+                ? new Date(row.trustedAt).getTime()
+                : null,
+        riskFingerprint: row.riskFingerprint,
     };
 }
 /**
@@ -85,6 +93,63 @@ export async function updateProjectName(handle, id, name) {
         .returning();
     return row ? rowToProject(row) : null;
 }
+/**
+ * P0-2：显式信任项目——用户在信任确认弹窗中批准项目作用域配置/插件后落盘。
+ * 信任是「克隆即信任」防线的落点；未信任项目携带风险配置时聊天入口被门禁拦截。
+ * 一次性动作：信任后不再拦截（用户可随时在设置中收回项目级配置）。
+ * P1：信任时同时落盘「风险配置指纹」（当前项目作用域的 summarizeProjectRisk
+ * 快照）——此后若仓库 git pull 新增 auto 权限/插件/MCP 等风险键，指纹漂移会
+ * 重新触发门禁复检，而非永久信任。
+ */
+export async function trustProject(handle, id) {
+    const existing = await getProject(handle, id);
+    if (!existing)
+        return null;
+    const scope = loadConfigScopes(existing.worktree).project;
+    // 指纹含 MCP 参数与插件文件内容（trust.ts computeProjectRiskFingerprint）——
+    // 信任批准的是「当时的完整风险面」，此后任何漂移（含插件代码变更）都会复检。
+    const riskFingerprint = computeProjectRiskFingerprint(scope, { projectDir: existing.worktree });
+    const rows = await handle.db
+        .update(projects)
+        .set({ trustedAt: new Date(), riskFingerprint })
+        .where(eq(projects.id, id))
+        .returning();
+    const row = rows[0];
+    return row ? rowToProject(row) : null;
+}
+/**
+ * P0 CLI 项目信任门禁：agent 执行路径（c0de chat / c0de acp）在无 Web 确认弹窗的
+ * 情况下，若目录项目未信任（或信任后未 config 漂移）且项目作用域/全局权限配置含
+ * 风险项，直接抛错引导 `c0de trust <dir>`——与 Web 聊天入口 409 TRUST_REQUIRED 用
+ * 同一套 projectTrustNeeded 判定，杜绝「Web 拦、CLI 裸奔」的不对称。
+ * 无风险项时不拦；trust/sessions 等非 agent 命令由调用方跳过此门禁。
+ * `globalRaw` 参数仅供测试注入确定性全局配置（生产走本机 ~/.c0de/config.json）。
+ */
+export async function enforceProjectTrust(handle, cwd, globalRaw) {
+    const scopes = loadConfigScopes(cwd);
+    const effectiveGlobal = globalRaw === undefined ? scopes.global : globalRaw;
+    let trustedAt = null;
+    let riskFingerprint = null;
+    try {
+        const project = await getByDirectory(handle, cwd);
+        trustedAt = project?.trustedAt ?? null;
+        riskFingerprint = project?.riskFingerprint ?? null;
+    }
+    catch {
+        // 信任状态查询失败 → 按未信任处理（宁可拦截，不静默放行）
+    }
+    const risks = projectTrustNeeded(scopes.project, effectiveGlobal, trustedAt, riskFingerprint, cwd);
+    if (risks.length === 0)
+        return;
+    const globalKinds = new Set(['permission-auto', 'permission-timeout-deny']);
+    const globalOnly = risks.every((r) => globalKinds.has(r.kind));
+    const sourceNote = globalOnly
+        ? '（风险来自全局配置 permission；如有意为之可执行 c0de trust 一次性放行本项目）'
+        : '';
+    throw new Error(`项目目录 ${cwd} 的配置含需要你确认的风险项。\n` +
+        `  请先审查后执行 c0de trust <目录> --yes 显式信任；或改用 c0de serve 在浏览器确认。\n` +
+        `  风险项：${risks.map((r) => r.kind).join('、')}${sourceNote}`);
+}
 /**
  * 项目重新定位（A1：目录被移动/重命名后的恢复通道）。
  *

package/dist/project/trust.d.ts

@@ -0,0 +1,65 @@
+import type { Config } from '../shared/types/config.js';
+/** 单个风险项：kind 供前端图标/文案映射，detail 为人类可读说明。
+ *  'trust-drift' 为展示专用（仅 projectTrustNeeded 在漂移时返回），
+ *  不参与 summarizeProjectRisk 与指纹计算。 */
+export type TrustRiskItem = {
+    kind: 'permission-auto' | 'permission-timeout-deny' | 'plugins-enabled' | 'mcp-enabled' | 'provider-rerouting' | 'workflows-enabled' | 'trust-drift';
+    detail: string;
+};
+/** 从全局配置中提取「会作用于本项目的权限风险」项（auto 放行 / 超时后继续自主执行）。
+ *  仅这两类参与门禁与可视化——全局插件/MCP 是用户本机显式安装（需手改 ~/.c0de），
+ *  不属仓库自带风险面，不纳入项目信任门禁。 */
+export declare function globalPermissionRiskItems(globalRaw: Partial<Config> | undefined): TrustRiskItem[];
+/**
+ * 把「全局配置中会作用于本项目的权限风险」并入项目风险列表（作为可见上下文）。
+ * 目的：用户在做信任决策时能看到完整生效的权限状态，避免「信任了项目却发现全局
+ * 早已 auto」的困惑。复用现有 kind（前端无需新增映射）；同类 kind 已存在则跳过。
+ */
+export declare function enrichProjectRiskWithGlobal(risks: TrustRiskItem[], globalRaw: Partial<Config> | undefined): TrustRiskItem[];
+/** 汇总项目作用域原始配置中的风险项。无风险返回空数组。
+ * 宽松形状：项目 JSON 可能字段漂移，非法值一律忽略（fail-closed 由
+ * 「未信任 + 无风险项 = 不拦截」与「有风险项必拦截」共同保证——解析不出
+ * 风险的配置也不含可信风险）。
+ * projectDir 提供时额外检测 `.c0de/workflows/*.js`（项目工作流是 dynamic
+ * import 的任意代码执行面，与 .c0de/plugins 同级，纯文件系统、无配置键）。
+ */
+export declare function summarizeProjectRisk(raw: Partial<Config> | undefined, projectDir?: string): TrustRiskItem[];
+/**
+ * 计算项目作用域风险配置的指纹。
+ *
+ * P0（代码面覆盖）：指纹不再只是配置键的 hash——已信任仓库 `git pull` 修改
+ * 插件代码（同名）或 MCP `args`（同名）此前不会触发复检，下次 serve 重启即
+ * 静默加载执行新代码。现在指纹由三部分组成：
+ *  1. 风险项 canonical 行（kind:detail，配置键漂移）；
+ *  2. MCP 服务器 canonical 参数（name+command+args+transport+url 全量，
+ *     防「同名改 args」绕过）；
+ *  3. 项目插件目录全部文件内容 hash（插件可 import 同目录其它文件，
+ *     内容面覆盖整个插件目录，防「同名改代码」绕过）。
+ * 无风险项、无 MCP、无插件 → ''（空串）。
+ * 升级后旧指纹（仅配置键）与含插件/MCP 的新口径不一致 → 一次性重新确认，
+ * 属预期行为（漂移复检）。
+ */
+export declare function computeProjectRiskFingerprint(raw: Partial<Config> | undefined, opts?: {
+    projectDir?: string;
+}): string;
+/**
+ * 判定项目是否需要（重新）信任：返回「需要用户确认的风险项」数组，空数组 = 放行。
+ * 门禁条件：
+ *  - 未信任：项目风险 或 全局权限风险（auto / timeoutAction=deny）任一存在即拦。
+ *    全局权限风险兜底「仓库未携带 .c0de 但本机已全局 auto」的裸奔场景。
+ *  - 已信任：仅当项目作用域指纹漂移（git pull 新增风险键 / MCP 参数变更 /
+ *    插件或工作流代码变更）时复检——返回项目风险项 + 前置 trust-drift 说明项，
+ *    用户能看到「为什么又要确认」；全局配置是用户本机显式选择，不因漂移重新门禁。
+ * projectDir 提供时插件/工作流文件内容纳入指纹（serve 启动的插件加载门禁与
+ * 聊天入口使用同一口径）。
+ * 供 Web 聊天入口（返回 409）与 CLI agent 路径（抛错引导 c0de trust）共用，
+ * 保证两处「什么时候拦」判定完全一致，不再各自为政。
+ */
+export declare function projectTrustNeeded(raw: Partial<Config> | undefined, globalRaw: Partial<Config> | undefined, trustedAt: number | null | undefined, riskFingerprint: string | null | undefined, projectDir?: string): TrustRiskItem[];
+/**
+ * 项目是否「当前可信任」（插件加载门禁用）：已信任且指纹与信任时一致。
+ * 漂移（fingerprint 不匹配）或未信任 → false（fail-closed，项目插件不加载）。
+ * 供 server bootstrap 与 CLI deps 复用——插件在启动时加载，必须与聊天门禁
+ * 同口径校验，否则「先重启、后门禁」的窗口里漂移代码已执行。
+ */
+export declare function projectTrustCurrent(raw: Partial<Config> | undefined, trustedAt: number | null | undefined, riskFingerprint: string | null | undefined, projectDir: string): boolean;

package/dist/project/trust.js

@@ -0,0 +1,328 @@
+// src/project/trust.ts
+// P0-2 项目信任边界：评估「项目作用域原始配置」中的风险项。
+//
+// 背景：`git clone` 一个携带 `.c0de/config.json`（或 `.c0de/plugins` /
+// `.c0de/workflows`）的仓库后 `c0de serve`，此前配置静默合并生效（可把权限
+// 降级为 auto/YOLO），插件在启动时直接加载执行、工作流在列出/运行时 dynamic
+// import 执行——信任在克隆完成时被默认授予。现在：
+//  - 聊天入口：未信任项目 + 风险配置 → 409 TRUST_REQUIRED（前端弹窗确认后
+//    POST /api/projects/:id/trust 落盘 trustedAt，一次性）；
+//  - 启动入口：未信任项目的 .c0de/plugins 与 .c0de/workflows 不加载
+//    （信任后重启生效；工作流侧发现入口同样按信任门禁）。
+//
+// 评估「项目作用域原始配置」（loadConfigScopes(cwd).project），并额外评估
+// 「全局权限风险」（permission.defaultMode=auto / timeoutAction=deny）。
+// 两类入口不同：项目风险无论信任状态都参与指纹复检；全局权限风险仅当项目
+// **未信任**时触发门禁（一次性，信任后不再复检）——兜底「仓库未携带 .c0de
+// 但本机已全局 auto，克隆即全自动执行」的裸奔场景。全局配置的插件/MCP 是用户
+// 本机显式安装（需手改 ~/.c0de），不属仓库自带风险面，不纳入门禁。
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+/** 从全局配置中提取「会作用于本项目的权限风险」项（auto 放行 / 超时后继续自主执行）。
+ *  仅这两类参与门禁与可视化——全局插件/MCP 是用户本机显式安装（需手改 ~/.c0de），
+ *  不属仓库自带风险面，不纳入项目信任门禁。 */
+export function globalPermissionRiskItems(globalRaw) {
+    const items = [];
+    if (globalRaw?.permission?.defaultMode === 'auto') {
+        items.push({
+            kind: 'permission-auto',
+            detail: '（全局配置）权限模式 auto：本机已全局设为自动放行，本项目同样生效',
+        });
+    }
+    if (globalRaw?.permission?.timeoutAction === 'deny') {
+        items.push({
+            kind: 'permission-timeout-deny',
+            detail: '（全局配置）权限超时动作 timeoutAction=deny：本机已全局设为超时后继续自主执行',
+        });
+    }
+    return items;
+}
+/** 按 kind 去重合并：primary 在前（其 detail 优先），secondary 仅补齐缺失 kind。 */
+function mergeRiskItems(primary, secondary) {
+    const out = [...primary];
+    const seen = new Set(out.map((r) => r.kind));
+    for (const item of secondary) {
+        if (seen.has(item.kind))
+            continue;
+        seen.add(item.kind);
+        out.push(item);
+    }
+    return out;
+}
+/**
+ * 把「全局配置中会作用于本项目的权限风险」并入项目风险列表（作为可见上下文）。
+ * 目的：用户在做信任决策时能看到完整生效的权限状态，避免「信任了项目却发现全局
+ * 早已 auto」的困惑。复用现有 kind（前端无需新增映射）；同类 kind 已存在则跳过。
+ */
+export function enrichProjectRiskWithGlobal(risks, globalRaw) {
+    if (!globalRaw)
+        return risks;
+    return mergeRiskItems(risks, globalPermissionRiskItems(globalRaw));
+}
+/** 汇总项目作用域原始配置中的风险项。无风险返回空数组。
+ * 宽松形状：项目 JSON 可能字段漂移，非法值一律忽略（fail-closed 由
+ * 「未信任 + 无风险项 = 不拦截」与「有风险项必拦截」共同保证——解析不出
+ * 风险的配置也不含可信风险）。
+ * projectDir 提供时额外检测 `.c0de/workflows/*.js`（项目工作流是 dynamic
+ * import 的任意代码执行面，与 .c0de/plugins 同级，纯文件系统、无配置键）。
+ */
+export function summarizeProjectRisk(raw, projectDir) {
+    const items = [];
+    // P0（代码面）：项目工作流 `.c0de/workflows/*.js` 会在「列出/运行」时被
+    // dynamic import（模块顶层代码即刻执行），与 .c0de/plugins 同级的任意代码
+    // 执行面——克隆仓库自带即拦截，与插件一致。纯文件系统检测、不依赖配置键，
+    // 必须在下方 `!raw` 早退之前执行（仓库可能完全不携带 .c0de/config.json）。
+    if (projectDir) {
+        const names = workflowFileNames(projectDir);
+        if (names.length > 0) {
+            items.push({
+                kind: 'workflows-enabled',
+                detail: `项目工作流（.c0de/workflows，列出/运行时会执行其中代码）：${names.join('、')}`,
+            });
+        }
+    }
+    if (!raw)
+        return items;
+    if (raw.permission?.defaultMode === 'auto') {
+        items.push({
+            kind: 'permission-auto',
+            detail: '权限模式 auto：bash/write/edit 等需要确认的工具将被自动放行',
+        });
+    }
+    // 权限确认超时后的动作降级为 'deny'：安全默认是 'pause'（超时后暂停对话，
+    // 防 agent 在用户缺席时继续自主执行）；'deny' 会「拒绝该工具但继续自动执行」。
+    // 携带此键的可疑仓库可在不触发 auto 权限的前提下悄然弱化超时安全网。
+    if (raw.permission?.timeoutAction === 'deny') {
+        items.push({
+            kind: 'permission-timeout-deny',
+            detail: '权限超时动作 timeoutAction=deny：确认超时后 agent 将继续自主执行（安全默认应为 pause）',
+        });
+    }
+    const plugins = raw.plugins?.enabled;
+    if (Array.isArray(plugins)) {
+        const names = plugins.filter((p) => typeof p === 'string').sort();
+        if (names.length > 0) {
+            items.push({ kind: 'plugins-enabled', detail: `启用项目插件：${names.join('、')}` });
+        }
+    }
+    // P0：MCP 服务器（stdio 类会在项目信任边界内本地执行任意命令，与插件同级的
+    // 任意代码执行面）。任何非空 mcpServers 数组都拦截——fail-closed，绝不静默
+    // 加载克隆仓库自带的 MCP 进程。
+    const mcpServers = raw.mcpServers;
+    if (Array.isArray(mcpServers) && mcpServers.length > 0) {
+        const names = mcpServers
+            .map((m) => {
+            const e = (typeof m === 'object' && m !== null ? m : {});
+            if (typeof e.name === 'string' && e.name.length > 0)
+                return e.name;
+            if (typeof e.command === 'string' && e.command.length > 0)
+                return e.command;
+            return typeof e.transport === 'string' ? e.transport : '（未命名）';
+        })
+            .sort(); // 排序保证指纹稳定：数组重排不触发无谓复检
+        items.push({
+            kind: 'mcp-enabled',
+            detail: `启用 MCP 服务器：${names.join('、')}（stdio 类会在本地执行命令）`,
+        });
+    }
+    // P1：自定义 Provider 端点（baseURL 非空）会把「所有对话提示词（含代码上下文、
+    // 私有文件内容）」默认路由到该第三方地址，是比 auto 权限更直接的数据外泄面。
+    // 任何项目作用域配置声明了自定义 baseURL 的 provider 都拦截（fail-closed），
+    // 绝不静默把请求发往非官方端点。空 baseURL（官方默认端点）不视为风险。
+    const providers = raw.providers;
+    if (Array.isArray(providers)) {
+        const custom = providers
+            .map((p) => {
+            const e = (typeof p === 'object' && p !== null ? p : {});
+            const url = typeof e.baseURL === 'string' ? e.baseURL : typeof e.baseUrl === 'string' ? e.baseUrl : '';
+            return {
+                name: typeof e.name === 'string' && e.name.length > 0 ? e.name : '（未命名）',
+                url: url.trim(),
+            };
+        })
+            .filter((p) => p.url.length > 0);
+        if (custom.length > 0) {
+            const desc = custom
+                .map((p) => `${p.name} → ${p.url}`)
+                .sort() // 排序保证指纹稳定：provider 数组重排不触发无谓复检
+                .join('、');
+            items.push({
+                kind: 'provider-rerouting',
+                detail: `自定义 Provider 端点（baseURL）：${desc}。你的所有对话提示词将发往该地址`,
+            });
+        }
+    }
+    return items;
+}
+/**
+ * 计算项目作用域风险配置的指纹。
+ *
+ * P0（代码面覆盖）：指纹不再只是配置键的 hash——已信任仓库 `git pull` 修改
+ * 插件代码（同名）或 MCP `args`（同名）此前不会触发复检，下次 serve 重启即
+ * 静默加载执行新代码。现在指纹由三部分组成：
+ *  1. 风险项 canonical 行（kind:detail，配置键漂移）；
+ *  2. MCP 服务器 canonical 参数（name+command+args+transport+url 全量，
+ *     防「同名改 args」绕过）；
+ *  3. 项目插件目录全部文件内容 hash（插件可 import 同目录其它文件，
+ *     内容面覆盖整个插件目录，防「同名改代码」绕过）。
+ * 无风险项、无 MCP、无插件 → ''（空串）。
+ * 升级后旧指纹（仅配置键）与含插件/MCP 的新口径不一致 → 一次性重新确认，
+ * 属预期行为（漂移复检）。
+ */
+export function computeProjectRiskFingerprint(raw, opts) {
+    return hashLines(fingerprintLines(raw, opts?.projectDir));
+}
+/** 指纹的 canonical 行集合（排序前）：风险项 + MCP 参数 + 插件/工作流文件内容。 */
+function fingerprintLines(raw, projectDir) {
+    return [
+        ...summarizeProjectRisk(raw, projectDir).map((r) => `${r.kind}:${r.detail}`),
+        ...mcpCanonicalLines(raw),
+        ...pluginDirHashes(projectDir),
+        ...workflowDirHashes(projectDir),
+    ].sort();
+}
+function hashLines(lines) {
+    if (lines.length === 0)
+        return '';
+    return createHash('sha256').update(lines.join('\n')).digest('hex');
+}
+/** MCP 服务器条目的 canonical 参数行（稳定键序；非法条目跳过）。 */
+function mcpCanonicalLines(raw) {
+    const servers = raw?.mcpServers;
+    if (!Array.isArray(servers))
+        return [];
+    const lines = [];
+    for (const m of servers) {
+        if (typeof m !== 'object' || m === null)
+            continue;
+        const e = m;
+        const canonical = JSON.stringify({
+            name: typeof e.name === 'string' ? e.name : null,
+            command: typeof e.command === 'string' ? e.command : null,
+            args: Array.isArray(e.args) ? e.args : null,
+            transport: typeof e.transport === 'string' ? e.transport : null,
+            url: typeof e.url === 'string' ? e.url : null,
+        });
+        lines.push(`mcp:${canonical}`);
+    }
+    return lines;
+}
+/** 项目插件目录内全部文件的内容 hash 行（相对路径 + sha256；按路径排序保证确定性）。
+ *  目录不存在/不可读 → 空（指纹退化为配置口径；插件加载侧另有 fail-closed 门禁）。 */
+function pluginDirHashes(projectDir) {
+    if (!projectDir)
+        return [];
+    const dir = join(projectDir, '.c0de', 'plugins');
+    const lines = [];
+    const walk = (cur) => {
+        let entries = [];
+        try {
+            if (!existsSync(cur))
+                return;
+            entries = readdirSync(cur).sort();
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = join(cur, entry);
+            try {
+                if (statSync(full).isDirectory()) {
+                    walk(full);
+                    continue;
+                }
+                const rel = relative(dir, full).split(sep).join('/');
+                lines.push(`plugin-file:${rel}:${createHash('sha256').update(readFileSync(full)).digest('hex')}`);
+            }
+            catch {
+                // 单个文件读取失败跳过（不因无法 hash 而放行或误报）
+            }
+        }
+    };
+    walk(dir);
+    return lines;
+}
+/** 项目工作流目录 `.c0de/workflows` 下的 `*.js` 文件名（排序；目录缺失 → 空）。
+ *  工作流文件是 dynamic import 的任意代码执行面（模块顶层代码在「列出」时即执行），
+ *  因此只要存在即构成风险项——无需配置键，纯文件系统检测。 */
+function workflowFileNames(projectDir) {
+    const dir = join(projectDir, '.c0de', 'workflows');
+    try {
+        if (!existsSync(dir))
+            return [];
+        return readdirSync(dir)
+            .filter((f) => f.endsWith('.js'))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+/** 项目工作流目录内全部文件的内容 hash 行（与 pluginDirHashes 同口径：
+ *  相对路径 + sha256；目录不存在 → 空）。工作流文件内容漂移（同名改代码）
+ *  与插件一样触发 trust-drift 复检，杜绝「信任后 git pull 换代码」绕过。 */
+function workflowDirHashes(projectDir) {
+    if (!projectDir)
+        return [];
+    const dir = join(projectDir, '.c0de', 'workflows');
+    const lines = [];
+    for (const entry of workflowFileNames(projectDir)) {
+        try {
+            lines.push(`workflow-file:${entry}:${createHash('sha256')
+                .update(readFileSync(join(dir, entry)))
+                .digest('hex')}`);
+        }
+        catch {
+            // 单个文件读取失败跳过（不因无法 hash 而放行或误报）
+        }
+    }
+    return lines;
+}
+/**
+ * 判定项目是否需要（重新）信任：返回「需要用户确认的风险项」数组，空数组 = 放行。
+ * 门禁条件：
+ *  - 未信任：项目风险 或 全局权限风险（auto / timeoutAction=deny）任一存在即拦。
+ *    全局权限风险兜底「仓库未携带 .c0de 但本机已全局 auto」的裸奔场景。
+ *  - 已信任：仅当项目作用域指纹漂移（git pull 新增风险键 / MCP 参数变更 /
+ *    插件或工作流代码变更）时复检——返回项目风险项 + 前置 trust-drift 说明项，
+ *    用户能看到「为什么又要确认」；全局配置是用户本机显式选择，不因漂移重新门禁。
+ * projectDir 提供时插件/工作流文件内容纳入指纹（serve 启动的插件加载门禁与
+ * 聊天入口使用同一口径）。
+ * 供 Web 聊天入口（返回 409）与 CLI agent 路径（抛错引导 c0de trust）共用，
+ * 保证两处「什么时候拦」判定完全一致，不再各自为政。
+ */
+export function projectTrustNeeded(raw, globalRaw, trustedAt, riskFingerprint, projectDir) {
+    const projectRisks = summarizeProjectRisk(raw, projectDir);
+    const untrusted = trustedAt == null;
+    if (untrusted) {
+        return mergeRiskItems(projectRisks, globalPermissionRiskItems(globalRaw));
+    }
+    // 已信任 + 无风险键且无插件/工作流文件：无漂移面，直接放行（保持旧行为——
+    // 信任后删光风险配置不触发复检）。
+    const lines = fingerprintLines(raw, projectDir);
+    if (lines.length === 0)
+        return [];
+    const currentFp = hashLines(lines);
+    if (riskFingerprint !== currentFp) {
+        return [
+            {
+                kind: 'trust-drift',
+                detail: '自上次信任以来，项目风险配置、MCP 参数、插件代码或工作流文件已变更（如仓库 git pull 更新）——需重新确认信任后才会放行',
+            },
+            ...projectRisks,
+        ];
+    }
+    return [];
+}
+/**
+ * 项目是否「当前可信任」（插件加载门禁用）：已信任且指纹与信任时一致。
+ * 漂移（fingerprint 不匹配）或未信任 → false（fail-closed，项目插件不加载）。
+ * 供 server bootstrap 与 CLI deps 复用——插件在启动时加载，必须与聊天门禁
+ * 同口径校验，否则「先重启、后门禁」的窗口里漂移代码已执行。
+ */
+export function projectTrustCurrent(raw, trustedAt, riskFingerprint, projectDir) {
+    if (trustedAt == null)
+        return false;
+    return computeProjectRiskFingerprint(raw, { projectDir }) === riskFingerprint;
+}

package/dist/server/agent-manager.d.ts

@@ -34,7 +34,7 @@ type AgentManager = {
     /** 活跃 run 数（不含占位）。 */
     size(): number;
     abort(sessionId: string): boolean;
-    pause(sessionId: string): boolean;
+    pause(sessionId: string, reason?: string): boolean;
     resume(sessionId: string): boolean;
     /** 暂停全部活跃 run 并等待到达安全点；超时强制中止（热更新前调用）。
      *  返回 pausedIds：成功暂停的会话 id 列表——调用方在后续步骤（spawn 等）
@@ -49,11 +49,15 @@ type AgentManager = {
     children(parentSessionId: string): ActiveRun[];
     /** 查询所有后台任务（jobId 非空的 run）。 */
     backgroundJobs(): ActiveRun[];
-    /** 列出全部活跃 run（含子 agent）——热更新影响面展示用。 */
+    /** 列出全部活跃 run（含子 agent）——热更新影响面展示用。
+     *  status/currentTool（P2-9）：确认弹窗区分「正在执行工具、超时将被强杀」的
+     *  run 与普通 running/paused run，用户可判断被中断的代价。 */
     listActive(): Array<{
         sessionId: string;
         agentType?: string;
         parentSessionId?: string;
+        status: 'running' | 'paused' | 'idle' | 'stopped' | 'interrupted';
+        currentTool?: string;
     }>;
     /** 中止所有活跃 run 并清空（dev 热重载重建前调用）。 */
     dispose(): void;

package/dist/server/agent-manager.js

@@ -40,11 +40,11 @@ function createAgentManager() {
             abortAgent(run.state);
             return true;
         },
-        pause(sessionId) {
+        pause(sessionId, reason) {
             const run = slotRun(runs.get(sessionId));
             if (!run)
                 return false;
-            pauseAgent(run.state);
+            pauseAgent(run.state, reason);
             return true;
         },
         resume(sessionId) {
@@ -110,6 +110,8 @@ function createAgentManager() {
                 sessionId: r.sessionId,
                 agentType: r.agentType,
                 parentSessionId: r.parentSessionId,
+                status: r.state.status._tag,
+                currentTool: r.state.status._tag === 'running' ? r.state.status.currentTool : undefined,
             }));
         },
         dispose() {

package/dist/server/app.js

@@ -1,5 +1,5 @@
 // src/server/app.ts
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import path from 'node:path';
 import { serveStatic } from '@hono/node-server/serve-static';
 import { Hono } from 'hono';
@@ -24,6 +24,7 @@ import { createTerminalRoute } from './routes/terminal.js';
 import { createTodoRoute } from './routes/todo.js';
 import { createToolRoute } from './routes/tool.js';
 import { createUpdateRoute } from './routes/update.js';
+import { createUsageRoute } from './routes/usage.js';
 import { createWorkflowsRoute } from './routes/workflows.js';
 /** 创建完整的 Hono 应用，挂载所有路由 + 中间件。 */
 function createApp(ctx) {
@@ -41,6 +42,10 @@ function createApp(ctx) {
             '/api/auth/pairing/request',
             '/api/auth/pairing/status',
         ],
+        allowedOrigins: ctx.config.security.allowedOrigins,
+        // P1 媒体预览：文件 raw 端点（FilePreview 的 img/audio/video/embed src）
+        // 无法携带 Authorization 头，接受 ?token= query 认证（仅 GET raw 路径）。
+        queryTokenPath: (p) => p.startsWith('/api/files/') && p.endsWith('/raw'),
         ...(ctx.authManager ? { verify: (t) => ctx.authManager?.verify(t) ?? false } : {}),
     }));
     // 路由
@@ -63,36 +68,46 @@ function createApp(ctx) {
     app.route('/api/files', createFilesRoute(ctx));
     app.route('/api/terminal', createTerminalRoute(ctx));
     app.route('/api/workflows', createWorkflowsRoute(ctx));
-    // 根路径
-    app.get('/', (c) => c.json({
-        name: 'c0de-agent',
-        version: '0.1.0',
-        endpoints: [
-            '/api/health',
-            '/api/agents',
-            '/api/sessions',
-            '/api/projects',
-            '/api/providers',
-            '/api/catalog',
-            '/api/filesystem',
-            '/api/chat',
-            '/api/commands',
-            '/api/tools',
-            '/api/todo',
-            '/api/kanban',
-            '/api/update',
-            '/api/config',
-            '/api/permissions',
-            '/api/files',
-            '/api/terminal',
-            '/api/workflows',
-        ],
-    }));
-    // 静态文件服务（生产环境 dist-web/ 存在时启用）
-    if (existsSync(path.resolve(ctx.cwd, 'dist-web'))) {
-        app.use('/*', serveStatic({ root: './dist-web' }));
-        app.get('/*', (c) => c.body(null)); // SPA fallback
+    app.route('/api/usage', createUsageRoute(ctx));
+    // 静态文件服务（生产环境 dist-web/ 存在时启用）。
+    // 根路径语义：dist-web 存在时 '/' 与所有未匹配路由回退 index.html（SPA history
+    // 路由深链刷新可用）；否则 '/' 返回 API 端点列表（无前端构建的开发/CI 场景）。
+    const distWebRoot = path.resolve(ctx.cwd, 'dist-web');
+    const indexHtmlPath = path.join(distWebRoot, 'index.html');
+    const hasWebAssets = existsSync(indexHtmlPath);
+    if (hasWebAssets) {
+        app.use('/*', serveStatic({ root: distWebRoot }));
+        app.get('/*', (c) => c.html(readFileSync(indexHtmlPath, 'utf-8')));
     }
+    // 根路径
+    app.get('/', (c) => {
+        if (hasWebAssets)
+            return c.html(readFileSync(indexHtmlPath, 'utf-8'));
+        return c.json({
+            name: 'c0de-agent',
+            version: '0.1.0',
+            endpoints: [
+                '/api/health',
+                '/api/agents',
+                '/api/sessions',
+                '/api/projects',
+                '/api/providers',
+                '/api/catalog',
+                '/api/filesystem',
+                '/api/chat',
+                '/api/commands',
+                '/api/tools',
+                '/api/todo',
+                '/api/kanban',
+                '/api/update',
+                '/api/config',
+                '/api/permissions',
+                '/api/files',
+                '/api/terminal',
+                '/api/workflows',
+            ],
+        });
+    });
     return app;
 }
 export { createApp };