refactor(security): 重构权限系统，移除工具内置确认逻辑

重构确认流程，完全由权限系统管理工具调用确认
新增 PatternAbstractor 实现权限规则智能抽象
优化权限模式行为，支持 DEFAULT/AUTO_EDIT/YOLO 三种模式
更新相关文档和测试用例

Author: echoVic

.blade/settings.local.json

@@ -1,3 +1,7 @@
 {
-  "permissions": {}
+  "permissions": {
+    "allow": [],
+    "ask": [],
+    "deny": []
+  }
 }

.claude/settings.local.json

@@ -40,7 +40,8 @@
       "Bash(npm test:*)",
       "Bash(npm run test:integration:*)",
       "Bash(blade mcp:*)",
-      "Bash(test:*)"
+      "Bash(test:*)",
+      "Bash(npm run test:unit:*)"
     ],
     "deny": [],
     "ask": [],

docs/development/architecture/confirmation-flow.md

@@ -1,5 +1,15 @@
 # 用户确认流程文档
 
+> **⚠️ 文档部分过时**: 本文档描述的 `requiresConfirmation` 工具字段和 `shouldConfirm()` 方法已被废弃。
+>
+> **当前实现**: Blade 的确认逻辑完全由权限系统管理（PermissionStage），不再依赖工具自身的确认配置。
+>
+> - 确认行为由 `settings.json` 中的权限规则控制（allow/ask/deny）
+> - 权限模式（DEFAULT/AUTO_EDIT/YOLO）决定自动批准策略
+> - 工具不再有 `requiresConfirmation` 字段
+>
+> 请参考 [权限系统文档](../../public/configuration/permissions.md) 了解当前的确认机制。
+
 ## 概述
 
 Blade 实现了一个完整的用户确认流程，用于在执行潜在危险操作前获取用户明确同意。该流程集成在工具执行管道（ExecutionPipeline）中，提供了安全、直观的交互体验。

docs/development/architecture/tool-system.md

@@ -103,9 +103,6 @@ export interface Tool<TParams = unknown> {
   readonly category?: string;
   readonly tags: string[];
 
-  // 安全控制
-  readonly requiresConfirmation: boolean;
-
   // 方法
   getFunctionDeclaration(): FunctionDeclaration;
   getMetadata(): Record<string, unknown>;

docs/public/configuration/permissions.md

@@ -208,6 +208,168 @@ Blade 支持三级权限控制:
 }
 ```
 
+## 智能模式抽象
+
+从 v0.0.10 开始，Blade 实现了**智能权限模式抽象**机制，自动将具体的工具调用转换为模式规则。
+
+### 工作原理
+
+当你在确认提示中选择 **"Yes, don't ask again this session"**（记住本项目会话）时，Blade 不会保存精确的参数，而是根据工具类型自动生成模式规则：
+
+**优化前（旧行为）**：
+```json
+{
+  "permissions": {
+    "allow": [
+      "Bash(command:cd /path && npm run typecheck)",
+      "Bash(command:cd /path && npm test)",
+      "Edit(file_path:/path/src/a.ts, old_string:..., new_string:...)",
+      "Edit(file_path:/path/src/b.ts, old_string:..., new_string:...)"
+    ]
+  }
+}
+```
+
+**优化后（新行为）**：
+```json
+{
+  "permissions": {
+    "allow": [
+      "Bash(command:*npm*)",      // 覆盖所有 npm 命令
+      "Edit(file_path:**/*.ts)"   // 覆盖所有 TS 文件编辑
+    ]
+  }
+}
+```
+
+### 抽象策略
+
+不同工具类型采用不同的抽象策略：
+
+#### Bash 命令
+- **安全命令**（cd/ls/pwd）→ `Bash(command:*)`
+- **包管理器**（npm/pnpm/yarn）→ `Bash(command:*npm*)`
+- **Git 命令**（git status）→ `Bash(command:git status*)`
+- **开发工具**（test/build/lint）→ `Bash(command:*)`
+- **其他命令** → `Bash(command:<主命令>*)`
+
+#### 文件操作（Read/Edit/Write）
+- **有扩展名** → `Tool(file_path:**/*.ext)`
+- **源码目录** → `Tool(file_path:**)`
+- **其他目录** → `Tool(file_path:<dir>/*)`
+
+#### 搜索操作（Grep/Glob）
+- **有类型限制** → `Grep(pattern:*, type:ts)`
+- **有 glob 限制** → `Grep(pattern:*, glob:*.ts)`
+- **有路径限制** → `Grep(pattern:*, path:**/*.ts)`
+- **默认** → `Grep(pattern:*)`
+
+#### Web 请求（WebFetch）
+- **按域名分组** → `WebFetch(domain:api.github.com)`
+
+### 优势
+
+1. **减少权限文件大小**：从数百条规则减少到几条模式
+2. **避免重复确认**：相似操作自动复用权限
+3. **更符合直觉**："记住"意味着"信任这类操作"，而非"仅记住此确切操作"
+
+### 规则覆盖与清理
+
+当添加新的模式规则时，Blade 会自动检测并移除被覆盖的旧规则：
+
+```
+添加 "Edit(file_path:**/*.ts)" 后：
+✅ 保留：Read(file_path:**/*.json)  (不冲突)
+❌ 删除：Edit(file_path:/path/a.ts)  (被覆盖)
+❌ 删除：Edit(file_path:/path/b.ts)  (被覆盖)
+```
+
+## 权限模式
+
+Blade 提供了三种权限模式，控制工具调用的默认行为。
+
+### 模式对比
+
+| 模式 | Read | Search | Edit | Write | Bash | 其他 | 适用场景 |
+|------|------|--------|------|-------|------|------|----------|
+| **DEFAULT** | ✅ | ✅ | ❌ | ❌ | ❌ | ❌ | 日常开发（默认） |
+| **AUTO_EDIT** | ✅ | ✅ | ✅ | ❌ | ❌ | ❌ | 频繁修改代码 |
+| **YOLO** | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | 演示/高度信任 |
+
+✅ = 自动批准 | ❌ = 需要确认
+
+### DEFAULT 模式（默认）
+
+自动批准只读操作，其他操作需要确认。
+
+**设计理念**：
+- Read/Search 是只读操作，不会修改文件，默认安全
+- Edit/Write/Bash 可能修改系统，需要用户确认
+
+**适用场景**：
+- 日常开发任务
+- 不确定 AI 行为时的保守策略
+
+### AUTO_EDIT 模式
+
+在 DEFAULT 基础上，额外自动批准 Edit 操作。
+
+**设计理念**：
+- 信任 AI 的文件修改能力
+- 减少频繁确认，提升效率
+- 仍需确认 Write（创建新文件）和 Bash（执行命令）
+
+**适用场景**：
+- 重构代码
+- 批量修改文件
+- 频繁的编辑任务
+
+**配置方式**：
+```json
+{
+  "permissionMode": "autoEdit"
+}
+```
+
+或通过命令行：
+```bash
+blade --permission-mode autoEdit
+```
+
+### YOLO 模式
+
+自动批准所有工具调用，完全信任 AI。
+
+**⚠️ 警告**：
+- 跳过所有确认，AI 可以执行任何操作
+- 可能删除文件、执行危险命令
+- 仅在高度可控的环境使用
+
+**适用场景**：
+- 演示场景
+- 测试环境
+- 一次性任务
+
+**配置方式**：
+```json
+{
+  "permissionMode": "yolo"
+}
+```
+
+### 权限规则优先级
+
+权限模式与权限规则的优先级关系：
+
+```
+DENY 规则 > ALLOW 规则 > 权限模式 > ASK（默认）
+```
+
+**示例**：
+- 即使在 YOLO 模式下，`deny` 规则仍然生效
+- `allow` 规则可以覆盖模式的 ASK 行为
+- 权限模式只影响未匹配任何规则的工具调用
+
 ## /permissions 命令
 
 交互式管理项目本地权限规则（`.blade/settings.local.json`）。

src/config/ConfigManager.ts

@@ -457,6 +457,9 @@ export class ConfigManager {
 
   /**
    * 将权限规则追加到项目本地 settings.local.json 的 allow 列表
+   * 增强功能：
+   * 1. 去重：检查规则是否已存在
+   * 2. 清理：移除被新规则覆盖的旧规则
    */
   async appendLocalPermissionAllowRule(rule: string): Promise<void> {
     const localSettingsPath = path.join(process.cwd(), '.blade', 'settings.local.json');
@@ -475,19 +478,37 @@ export class ConfigManager {
       permissions.ask = Array.isArray(permissions.ask) ? permissions.ask : [];
       permissions.deny = Array.isArray(permissions.deny) ? permissions.deny : [];
 
-      if (!permissions.allow.includes(rule)) {
-        permissions.allow = [...permissions.allow, rule];
-        existingSettings.permissions = permissions;
+      // 检查新规则是否已存在
+      if (permissions.allow.includes(rule)) {
+        return; // 规则已存在，无需重复添加
+      }
 
-        await fs.writeFile(
-          localSettingsPath,
-          JSON.stringify(existingSettings, null, 2),
-          { mode: 0o600, encoding: 'utf-8' }
+      // 移除被新规则覆盖的旧规则
+      const originalCount = permissions.allow.length;
+      permissions.allow = permissions.allow.filter((oldRule: string) => {
+        return !this.isRuleCoveredBy(oldRule, rule);
+      });
+
+      const removedCount = originalCount - permissions.allow.length;
+      if (removedCount > 0 && this.config?.debug) {
+        console.log(
+          `[ConfigManager] 新规则 "${rule}" 覆盖了 ${removedCount} 条旧规则，已自动清理`
         );
       }
 
-      if (this.config && !this.config.permissions.allow.includes(rule)) {
-        this.config.permissions.allow = [...this.config.permissions.allow, rule];
+      // 添加新规则
+      permissions.allow.push(rule);
+      existingSettings.permissions = permissions;
+
+      await fs.writeFile(
+        localSettingsPath,
+        JSON.stringify(existingSettings, null, 2),
+        { mode: 0o600, encoding: 'utf-8' }
+      );
+
+      // 更新内存配置
+      if (this.config) {
+        this.config.permissions.allow = [...permissions.allow];
       }
     } catch (error) {
       console.error('[ConfigManager] Failed to append local permission rule:', error);
@@ -497,6 +518,113 @@ export class ConfigManager {
     }
   }
 
+  /**
+   * 判断 rule1 是否被 rule2 覆盖
+   * 使用 PermissionChecker 的匹配逻辑来判断
+   * @param rule1 旧规则
+   * @param rule2 新规则
+   */
+  private isRuleCoveredBy(rule1: string, rule2: string): boolean {
+    try {
+      // 动态导入 PermissionChecker
+      const { PermissionChecker } = require('./PermissionChecker.js');
+
+      // 创建只包含新规则的 checker
+      const checker = new PermissionChecker({
+        allow: [rule2],
+        ask: [],
+        deny: [],
+      });
+
+      // 从 rule1 解析出工具名和参数
+      const toolName = this.extractToolNameFromRule(rule1);
+      if (!toolName) return false;
+
+      const params = this.extractParamsFromRule(rule1);
+
+      // 构造描述符
+      const descriptor = {
+        toolName,
+        params,
+        affectedPaths: [],
+      };
+
+      // 检查 rule1 是否匹配 rule2
+      const checkResult = checker.check(descriptor);
+      return checkResult.result === 'allow';
+    } catch (error) {
+      // 解析失败，保守处理：不删除
+      console.warn(
+        `[ConfigManager] 无法判断规则覆盖关系: ${error instanceof Error ? error.message : '未知错误'}`
+      );
+      return false;
+    }
+  }
+
+  /**
+   * 从规则字符串中提取工具名
+   */
+  private extractToolNameFromRule(rule: string): string | null {
+    const match = rule.match(/^([A-Za-z0-9_]+)(\(|$)/);
+    return match ? match[1] : null;
+  }
+
+  /**
+   * 从规则字符串中提取参数
+   */
+  private extractParamsFromRule(rule: string): Record<string, unknown> {
+    const match = rule.match(/\((.*)\)$/);
+    if (!match) return {};
+
+    const paramString = match[1];
+    const params: Record<string, unknown> = {};
+
+    // 简单解析参数（key:value 格式）
+    const parts = this.smartSplitParams(paramString);
+    for (const part of parts) {
+      const colonIndex = part.indexOf(':');
+      if (colonIndex > 0) {
+        const key = part.slice(0, colonIndex).trim();
+        const value = part.slice(colonIndex + 1).trim();
+        params[key] = value;
+      }
+    }
+
+    return params;
+  }
+
+  /**
+   * 智能分割参数字符串（处理嵌套括号）
+   */
+  private smartSplitParams(str: string): string[] {
+    const result: string[] = [];
+    let current = '';
+    let braceDepth = 0;
+    let parenDepth = 0;
+
+    for (let i = 0; i < str.length; i++) {
+      const char = str[i];
+
+      if (char === '{') braceDepth++;
+      else if (char === '}') braceDepth--;
+      else if (char === '(') parenDepth++;
+      else if (char === ')') parenDepth--;
+
+      if (char === ',' && braceDepth === 0 && parenDepth === 0) {
+        result.push(current.trim());
+        current = '';
+      } else {
+        current += char;
+      }
+    }
+
+    if (current) {
+      result.push(current.trim());
+    }
+
+    return result;
+  }
+
   /**
    * 设置权限模式
    * @param mode 目标权限模式