aodw-skill 0.7.3

package/bin/commands/new.js

@@ -0,0 +1,235 @@
+import fs from 'fs-extra';
+import path from 'path';
+import http from 'http';
+import https from 'https';
+import { URL } from 'url';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { getProjectConfig, getUserConfig } from '../utils/config.js';
+
+function getProjectName() {
+    // 1. Try .aodw/project.yaml
+    const projectConfig = getProjectConfig();
+    if (projectConfig.project_name) return projectConfig.project_name;
+
+    // 2. Try package.json
+    try {
+        const pkgPath = path.join(process.cwd(), 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            if (pkg.name) return pkg.name;
+        }
+    } catch (e) {
+        // ignore
+    }
+    return path.basename(process.cwd());
+}
+
+function fetchIdFromServer(serverUrl, project) {
+    return new Promise((resolve, reject) => {
+        const url = new URL('/api/next-id', serverUrl);
+        url.searchParams.set('project', project);
+
+        const client = url.protocol === 'https:' ? https : http;
+
+        const req = client.get(url.toString(), (res) => {
+            if (res.statusCode !== 200) {
+                reject(new Error(`Server returned status ${res.statusCode}`));
+                return;
+            }
+
+            let data = '';
+            res.on('data', (chunk) => data += chunk);
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    resolve(json.id);
+                } catch (e) {
+                    reject(e);
+                }
+            });
+        });
+
+        req.on('error', (e) => reject(e));
+    });
+}
+
+function getLocalMaxSeq() {
+    const rtDir = path.join(process.cwd(), 'RT');
+    if (!fs.existsSync(rtDir)) return 0;
+
+    const dirs = fs.readdirSync(rtDir);
+    let maxSeq = 0;
+
+    for (const dir of dirs) {
+        const match = dir.match(/^RT-(\d+)$/);
+        if (match) {
+            const seq = parseInt(match[1], 10);
+            if (seq > maxSeq) maxSeq = seq;
+        }
+    }
+
+    return maxSeq;
+}
+
+function getLocalNextId() {
+    const maxSeq = getLocalMaxSeq();
+    return `RT-${String(maxSeq + 1).padStart(3, '0')}`;
+}
+
+function syncIdToServer(serverUrl, project, seq) {
+    return new Promise((resolve, reject) => {
+        const url = new URL('/api/sync-id', serverUrl);
+        url.searchParams.set('project', project);
+        url.searchParams.set('seq', seq.toString());
+
+        const client = url.protocol === 'https:' ? https : http;
+
+        const req = client.request(url.toString(), { method: 'POST' }, (res) => {
+            if (res.statusCode === 200) {
+                resolve(true);
+            } else {
+                reject(new Error(`Server returned status ${res.statusCode}`));
+            }
+        });
+
+        req.on('error', (e) => reject(e));
+        req.end();
+    });
+}
+
+
+export async function createNewRT(options) {
+    const userConfig = getUserConfig();
+
+    // Determine Server URL: Flag > Config > Env Var
+    const serverUrl = options.server || userConfig.server_url || process.env.AODW_ID_SERVER;
+
+    // Determine Project Name: Flag > Config/Package/Dir
+    const project = options.project || getProjectName();
+
+    let title = options.title;
+
+    if (!title) {
+        const answers = await inquirer.prompt([{
+            type: 'input',
+            name: 'title',
+            message: 'Enter the title for this Request Ticket (RT):',
+            validate: input => input.trim().length > 0 ? true : 'Title is required'
+        }]);
+        title = answers.title;
+    }
+
+    let id;
+    // Check if user has configured collaborative mode
+    const isCollaborativeMode = userConfig.mode === 'collaborative';
+
+    if (isCollaborativeMode) {
+        // In collaborative mode, server URL is required
+        if (!serverUrl || serverUrl.trim() === '') {
+            console.error(chalk.red('Error: Collaborative mode requires a server URL.'));
+            console.error(chalk.yellow('Please configure the server URL by running: aodw config'));
+            console.error(chalk.yellow('Or set the AODW_ID_SERVER environment variable.'));
+            process.exit(1);
+        }
+
+        try {
+            console.log(chalk.blue(`Fetching ID from server (${serverUrl})...`));
+            const serverId = await fetchIdFromServer(serverUrl, project);
+            const serverSeq = parseInt(serverId.replace('RT-', ''), 10);
+
+            // Get local max ID and compare
+            const localMaxSeq = getLocalMaxSeq();
+
+            if (serverSeq <= localMaxSeq) {
+                // Server ID is outdated, use local max + 1
+                const finalSeq = localMaxSeq + 1;
+                id = `RT-${String(finalSeq).padStart(3, '0')}`;
+                console.log(chalk.yellow(`⚠ Server ID (${serverId}) ≤ local max (RT-${String(localMaxSeq).padStart(3, '0')})`));
+                console.log(chalk.green(`Using local ID: ${id}`));
+
+                // Sync to server
+                try {
+                    await syncIdToServer(serverUrl, project, finalSeq);
+                    console.log(chalk.blue(`✔ Synced ID to server: ${id}`));
+                } catch (syncErr) {
+                    console.warn(chalk.yellow(`⚠ Failed to sync ID to server: ${syncErr.message}`));
+                    console.warn(chalk.yellow('  The server may not support sync-id API, but RT creation will continue.'));
+                }
+            } else {
+                id = serverId;
+                console.log(chalk.green(`Obtained ID: ${id}`));
+            }
+        } catch (e) {
+            console.error(chalk.red(`Failed to fetch ID from server: ${e.message}`));
+            const { useLocal } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'useLocal',
+                message: 'Do you want to fall back to local ID generation? (Warning: Risk of collision)',
+                default: false
+            }]);
+            if (!useLocal) process.exit(1);
+            id = getLocalNextId();
+        }
+    } else {
+        // Independent mode: always use local generation, ignore server_url
+        // This ensures that when user chooses independent mode, no network request is made
+        id = getLocalNextId();
+        console.log(chalk.yellow(`Using local ID generation: ${id}`));
+        if (serverUrl) {
+            console.log(chalk.gray(`Note: server_url is configured but ignored in independent mode`));
+        }
+    }
+
+    // Create Directory
+    const rtPath = path.join(process.cwd(), 'RT', id);
+    if (fs.existsSync(rtPath)) {
+        console.error(chalk.red(`Error: Directory ${rtPath} already exists!`));
+        process.exit(1);
+    }
+    fs.ensureDirSync(rtPath);
+
+    // Create meta.yaml
+    const now = new Date().toISOString();
+    const metaContent = `id: ${id}
+title: "${title}"
+type: Feature  # Default, update after intake
+profile: Spec-Lite  # Default, update after decision
+status: created
+created_at: "${now}"
+updated_at: "${now}"
+owner: "${process.env.USER || 'unknown'}"
+modules: []
+`;
+    fs.writeFileSync(path.join(rtPath, 'meta.yaml'), metaContent);
+
+    // Create intake.md
+    const intakeContent = `# Intake: ${title}
+
+## 1. 原始需求
+> ${title}
+
+## 2. 澄清问题
+(AI 将在此处添加澄清问题)
+
+## 3. 风险与影响
+- 类型: Feature
+- 风险: Low
+`;
+    fs.writeFileSync(path.join(rtPath, 'intake.md'), intakeContent);
+
+    // Create decision.md
+    const decisionContent = `# Decision: ${id}
+
+## Profile Selection
+- [ ] Spec-Lite (Recommended for most tasks)
+- [ ] Spec-Full (For complex/risky tasks)
+
+## Rationale
+(AI will fill this)
+`;
+    fs.writeFileSync(path.join(rtPath, 'decision.md'), decisionContent);
+
+    console.log(chalk.green(`\n✔ Created RT ${id} at ./RT/${id}`));
+    console.log(chalk.white(`Next step: Open ./RT/${id}/intake.md and start the intake process.`));
+}

package/bin/commands/serve.js

@@ -0,0 +1,79 @@
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import { URL } from 'url';
+
+const STORE_FILE = process.env.AODW_ID_STORE_PATH || path.join(process.cwd(), 'aodw-id-store.json');
+const PORT = process.env.PORT || 2005;
+
+function loadStore() {
+    if (fs.existsSync(STORE_FILE)) {
+        try {
+            return JSON.parse(fs.readFileSync(STORE_FILE, 'utf8'));
+        } catch (e) {
+            console.error('Error reading store file:', e);
+            return {};
+        }
+    }
+    return {};
+}
+
+function saveStore(data) {
+    fs.writeFileSync(STORE_FILE, JSON.stringify(data, null, 2));
+}
+
+export async function serve(options) {
+    const port = options.port || PORT;
+
+    const server = http.createServer((req, res) => {
+        // CORS headers
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+
+        const url = new URL(req.url, `http://${req.headers.host}`);
+
+        if (req.method === 'GET' && url.pathname === '/api/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok' }));
+            return;
+        }
+
+        if (req.method === 'GET' && url.pathname === '/api/next-id') {
+            const project = url.searchParams.get('project') || 'default';
+
+            // Atomic-like operation (Node.js is single threaded for this)
+            const store = loadStore();
+
+            if (!store[project]) {
+                store[project] = 0;
+            }
+
+            store[project]++;
+            saveStore(store);
+
+            const seq = String(store[project]).padStart(3, '0');
+            const id = `RT-${seq}`;
+
+            console.log(`[${new Date().toISOString()}] Issued ${id} for project '${project}'`);
+
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ id, project }));
+            return;
+        }
+
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Not Found' }));
+    });
+
+    server.listen(port, () => {
+        console.log(`AODW ID Server running on port ${port}`);
+        console.log(`Store file: ${STORE_FILE}`);
+    });
+}

package/bin/processors/index.js

@@ -0,0 +1,109 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+
+export class BaseProcessor {
+    constructor(sourcePath, targetPath) {
+        this.sourcePath = sourcePath;
+        this.targetPath = targetPath;
+    }
+
+    async process() {
+        const content = await fs.readFile(this.sourcePath, 'utf8');
+        const processed = this.transform(content);
+        await fs.ensureDir(path.dirname(this.targetPath));
+        await fs.writeFile(this.targetPath, processed, 'utf8');
+    }
+
+    transform(content) {
+        return content;
+    }
+
+    // Helper to inject or replace frontmatter
+    injectFrontmatter(content, key, value) {
+        const frontmatterRegex = /^---\n([\s\S]*?)\n---/;
+        const match = content.match(frontmatterRegex);
+
+        if (match) {
+            let fm = match[1];
+            if (!fm.includes(`${key}:`)) {
+                fm += `\n${key}: ${value}`;
+                return content.replace(frontmatterRegex, `---\n${fm}\n---`);
+            }
+            return content; // Key already exists, don't overwrite
+        } else {
+            return `---\n${key}: ${value}\n---\n\n${content}`;
+        }
+    }
+}
+
+export class AntigravityProcessor extends BaseProcessor {
+    transform(content) {
+        // Replace template placeholders
+        let processed = content.replace(/\{\{REF_PREFIX\}\}/g, '');
+        
+        // For Rules: Inject trigger: always_on (for kernel loader)
+        if (this.targetPath.includes('.agent/rules') && /aodw(-next)?\.md$/.test(this.targetPath)) {
+            processed = this.injectFrontmatter(processed, 'trigger', 'always_on');
+        } else if (this.targetPath.includes('.agent/rules')) {
+            // For other rules: Inject trigger: model_decision
+            processed = this.injectFrontmatter(processed, 'trigger', 'model_decision');
+        }
+        return processed;
+    }
+}
+
+export class CursorProcessor extends BaseProcessor {
+    transform(content) {
+        // Replace template placeholders: @ for Cursor
+        let processed = content.replace(/\{\{REF_PREFIX\}\}/g, '@');
+        
+        // For Rules (.mdc): Inject globs and alwaysApply
+        if (this.targetPath.endsWith('.mdc')) {
+            processed = this.injectFrontmatter(processed, 'globs', '*');
+            processed = this.injectFrontmatter(processed, 'alwaysApply', 'true');
+            processed = this.injectFrontmatter(processed, 'description', 'AI 编排开发工作流 (AODW) — Kernel Loader');
+            processed = this.injectFrontmatter(processed, 'tags', 'aodw, kernel');
+        }
+        return processed;
+    }
+}
+
+export class CopilotProcessor extends BaseProcessor {
+    transform(content) {
+        // For Prompts: Inject model and mode
+        if (this.targetPath.endsWith('.prompt.md')) {
+            let newContent = this.injectFrontmatter(content, 'model', 'gpt-4o');
+            newContent = this.injectFrontmatter(newContent, 'mode', 'chat');
+            return newContent;
+        }
+        return content;
+    }
+}
+
+export class ClaudeProcessor extends BaseProcessor {
+    transform(content) {
+        // Replace template placeholders: empty for Claude
+        let processed = content.replace(/\{\{REF_PREFIX\}\}/g, '');
+        // Claude uses standard markdown, no frontmatter needed
+        return processed;
+    }
+}
+
+export class GeminiProcessor extends BaseProcessor {
+    transform(content) {
+        // Replace template placeholders: empty for Gemini
+        let processed = content.replace(/\{\{REF_PREFIX\}\}/g, '');
+        // Gemini uses standard markdown, no frontmatter needed
+        return processed;
+    }
+}
+
+export class GeneralProcessor extends BaseProcessor {
+    transform(content) {
+        // Replace template placeholders: empty for General
+        let processed = content.replace(/\{\{REF_PREFIX\}\}/g, '');
+        // General uses standard markdown, no frontmatter needed
+        return processed;
+    }
+}

package/bin/update-adapters-from-template.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+/**
+ * 从模板更新适配器文件
+ * 
+ * 这个脚本用于从统一模板 `.aodw/templates/aodw-kernel-loader-template.md`
+ * 生成各个平台的适配器文件到 `templates/AODW_Adapters/` 目录
+ * 
+ * 使用方法：
+ *   node cli/bin/update-adapters-from-template.js
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import {
+  AntigravityProcessor,
+  CursorProcessor,
+  ClaudeProcessor,
+  GeminiProcessor,
+  GeneralProcessor
+} from './processors/index.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT_DIR = path.join(__dirname, '../..');
+
+// 模板路径
+const SOURCE_TEMPLATE = path.join(ROOT_DIR, '.aodw/templates/aodw-kernel-loader-template.md');
+
+// 目标适配器路径
+const TARGET_ADAPTERS = path.join(ROOT_DIR, 'templates/AODW_Adapters');
+
+// 安装文件（使用 Processor）
+async function installFile(source, target, processorClass) {
+  const processor = new processorClass(source, target);
+  await processor.process();
+  console.log(`  ✓ Generated: ${path.relative(ROOT_DIR, target)}`);
+}
+
+async function updateAdapters() {
+  console.log('🔄 Updating adapters from template...\n');
+
+  // 检查模板是否存在
+  if (!fs.existsSync(SOURCE_TEMPLATE)) {
+    console.error(`❌ Template not found: ${SOURCE_TEMPLATE}`);
+    process.exit(1);
+  }
+
+  console.log(`📄 Source template: ${path.relative(ROOT_DIR, SOURCE_TEMPLATE)}\n`);
+
+  // Antigravity
+  console.log('📦 Updating Antigravity adapter...');
+  const antigravityTarget = path.join(TARGET_ADAPTERS, 'antigravity/.agent/rules/aodw.md');
+  await fs.ensureDir(path.dirname(antigravityTarget));
+  await installFile(SOURCE_TEMPLATE, antigravityTarget, AntigravityProcessor);
+
+  // Cursor
+  console.log('\n📦 Updating Cursor adapter...');
+  const cursorTarget = path.join(TARGET_ADAPTERS, 'cursor/.cursor/rules/aodw.mdc');
+  await fs.ensureDir(path.dirname(cursorTarget));
+  await installFile(SOURCE_TEMPLATE, cursorTarget, CursorProcessor);
+
+  // Claude
+  console.log('\n📦 Updating Claude adapter...');
+  const claudeTarget = path.join(TARGET_ADAPTERS, 'claude/CLAUDE.md');
+  await fs.ensureDir(path.dirname(claudeTarget));
+  await installFile(SOURCE_TEMPLATE, claudeTarget, ClaudeProcessor);
+
+  // Gemini
+  console.log('\n📦 Updating Gemini adapter...');
+  const geminiTarget = path.join(TARGET_ADAPTERS, 'gemini/.agent/rules/aodw.md');
+  await fs.ensureDir(path.dirname(geminiTarget));
+  await installFile(SOURCE_TEMPLATE, geminiTarget, GeminiProcessor);
+
+  // General
+  console.log('\n📦 Updating General adapter...');
+  const generalTarget = path.join(TARGET_ADAPTERS, 'general/AGENTS.md');
+  await fs.ensureDir(path.dirname(generalTarget));
+  await installFile(SOURCE_TEMPLATE, generalTarget, GeneralProcessor);
+
+  console.log('\n✅ All adapters updated successfully!');
+  console.log('\n📝 Note: These files are fallback files for CLI installation.');
+  console.log('   CLI will use the template directly if available.');
+}
+
+updateAdapters().catch(err => {
+  console.error('❌ Error:', err);
+  process.exit(1);
+});

package/bin/utils/config.js

@@ -0,0 +1,56 @@
+import fs from 'fs-extra';
+import path from 'path';
+import yaml from 'js-yaml';
+
+function getCoreDir() {
+    return process.env.AODW_CORE_DIR || '.aodw';
+}
+
+function getProjectConfigFile() {
+    return path.join(getCoreDir(), 'project.yaml');
+}
+
+function getUserConfigFile() {
+    return path.join(getCoreDir(), 'config.yaml');
+}
+
+export function getProjectConfig() {
+    const filepath = path.join(process.cwd(), getProjectConfigFile());
+    if (fs.existsSync(filepath)) {
+        try {
+            return yaml.load(fs.readFileSync(filepath, 'utf8')) || {};
+        } catch (e) {
+            return {};
+        }
+    }
+    return {};
+}
+
+export function getUserConfig() {
+    const filepath = path.join(process.cwd(), getUserConfigFile());
+    if (fs.existsSync(filepath)) {
+        try {
+            return yaml.load(fs.readFileSync(filepath, 'utf8')) || {};
+        } catch (e) {
+            return {};
+        }
+    }
+    return {};
+}
+
+export async function saveProjectConfig(config) {
+    const filepath = path.join(process.cwd(), getProjectConfigFile());
+    await fs.ensureDir(path.dirname(filepath));
+    // Read existing to preserve other fields if any
+    const existing = getProjectConfig();
+    const newConfig = { ...existing, ...config };
+    await fs.writeFile(filepath, yaml.dump(newConfig), 'utf8');
+}
+
+export async function saveUserConfig(config) {
+    const filepath = path.join(process.cwd(), getUserConfigFile());
+    await fs.ensureDir(path.dirname(filepath));
+    const existing = getUserConfig();
+    const newConfig = { ...existing, ...config };
+    await fs.writeFile(filepath, yaml.dump(newConfig), 'utf8');
+}

package/docs/README.md

@@ -0,0 +1,26 @@
+# AODW 用户文档
+
+本目录包含 **AODW 用户文档**，这些文档会随 CLI 一起发布，安装到用户项目的 `.aodw/docs/` 目录。
+
+## 📚 文档列表
+
+### 平台评估与选择
+- **adapter-evaluation.md** - 各平台能力评估和对比
+- **platform-matrix.md** - 平台功能矩阵
+
+### 迁移与升级
+- **migration-guide-0.2.0.md** - v0.1.x → v0.2.0 迁移指南
+- **installation-variants.md** - legacy 与 next 双版本安装方案
+
+---
+
+## 🔧 开发者文档
+
+如果你是 AODW 维护者或想深入了解架构，请查看 `/dev-docs/` 目录：
+
+- 架构分析
+- 实施计划
+- 完成报告
+- 跨平台配置指南
+
+这些文档不会被发布到 NPM 包中。

package/docs/adapter-evaluation.md

@@ -0,0 +1,55 @@
+# AODW 平台适配器能力评估报告
+
+## 1. 评估目标
+验证在 RT-010 实施“轻量级引用模式”后，各开发平台（Cursor, Claude, Gemini, General）是否仍能完整执行 AODW 流程（Intake -> Decision -> Spec -> Plan -> Execution -> Verification）。
+
+## 2. Cursor (aodw.mdc)
+- **机制**: `.cursor/rules` (Globs: `*`, AlwaysApply: `true`)
+- **引用方式**: 显式列出 `@.aodw/xxx.md`。
+- **执行逻辑**:
+  - Cursor 的 Composer/Agent 模式在看到 `@file` 语法时，通常会尝试解析或提示用户引用。
+  - 即使不自动展开，`aodw.mdc` 中的指令 "You MUST read..." 会促使具备文件读取工具（如 `grep`, `read_file`）的 Agent 主动获取内容。
+- **覆盖度**: **高**。
+  - Cursor 具备强大的工具调用能力，"引用模式"非常适合它。它不需要将所有规则塞入 System Prompt，而是按需读取。
+- **潜在风险**: 如果用户使用的是不支持工具的旧版 Cursor 模型，或者禁用了文件读取，AI 可能无法获取核心规则。
+- **结论**: **完全可行**，且更优（节省上下文）。
+
+## 3. Claude (CLAUDE.md)
+- **机制**: Claude Projects (Project Instructions + Project Knowledge)。
+- **引用方式**: `CLAUDE.md` 作为 Instructions，核心规则文件作为 Project Knowledge。
+- **执行逻辑**:
+  - 用户必须将 `.aodw/` 目录下的核心文件添加到 "Project Knowledge" 中。
+  - 只要文件在 Knowledge 中，Claude 就能通过 RAG 或长上下文完美检索到。
+  - `CLAUDE.md` 中的 "Required Reading" 清单起到了索引的作用，引导 Claude 去 Knowledge 中查找。
+- **覆盖度**: **高** (前提是配置正确)。
+- **潜在风险**: 用户忘记将 `.aodw/` 文件添加到 Project Knowledge。
+- **结论**: **可行**，依赖用户配置。
+
+## 4. Gemini (GEMINI.md)
+- **机制**: Long Context Window (1M+ tokens)。
+- **引用方式**: `GEMINI.md` 指示 "You MUST load and follow..."。
+- **执行逻辑**:
+  - Gemini 通常用于一次性加载整个仓库或大量文件。
+  - 只要 `.aodw/` 目录在上传/加载的文件列表中，Gemini 就能理解并执行。
+  - 它的超长上下文使得"引用"和"内联"在理解上几乎没有区别，但"引用"能让 Prompt 更清晰。
+- **覆盖度**: **极高**。
+- **结论**: **完全可行**。
+
+## 5. General Agents (AGENTS.md)
+- **机制**: System Prompt / User Prompt。
+- **引用方式**: 文本指令 "You must read..."。
+- **执行逻辑**:
+  - 这是一个通用回退方案。
+  - 如果 Agent 有文件访问权限（如 AutoGPT, LangChain agent），它会去读取。
+  - 如果 Agent 是网页版聊天框（无文件权限），用户需要手动粘贴核心规则内容。
+- **覆盖度**: **中** (取决于 Agent 能力)。
+- **结论**: **可行**，作为标准协议存在。
+
+## 6. 总体结论
+"轻量级引用模式"将 AODW 的执行压力从 **Prompt 长度** 转移到了 **AI 的上下文获取能力** (工具调用、RAG、长窗口) 上。
+鉴于当前主流 AI 编码工具（Cursor, Claude Projects, Gemini 1.5）都具备极强的文件感知能力，这种转移是符合技术趋势的，能带来更低的 Token 消耗和更高的规则一致性。
+
+## 7. 建议改进
+为了降低 Claude 和 General 模式下的配置风险，建议在适配器中增加一行：
+> "If you cannot read these files directly, ask the user to provide them."
+> (如果无法直接读取这些文件，请要求用户提供。)