@winspan/claude-forge 3.1.0 → 3.5.2

package/dist/{autopilot/intent-engine.js → goal/goal-classifier.js}

@@ -3,31 +3,19 @@ import path from 'path';
 import { logger } from '../utils/logger.js';
 import { TreeIndexEngine } from '../distill/tree-index.js';
 import { readActivePlanSummary } from '../utils/plan-reader.js';
-import { RuleDistiller } from './rule-distiller.js';
+import { RuleDistiller } from '../autopilot/rule-distiller.js';
 import { PromptRegistry } from '../prompts/registry.js';
-import { cacheRegistry } from '../core/cache-registry.js';
+import { cacheRegistry } from '../utils/cache-registry.js';
 import { CACHE, TIME } from '../constants.js';
-import { matchGroundTruth } from './ground-truth-rules.js';
-/**
- * IntentEngine — 意图识别引擎
- *
- * 所有用户输入都会拦截分析，根据项目实际情况判断：
- * - simple: 纯对话、查看文件、运行命令等不涉及代码改动的操作 → 直接放行
- * - moderate: 改动范围较小（少量文件） → 注入提示，不启动 Pipeline
- * - complex: 改动范围大、需求不明确、需要任务拆分和质量管控 → 启动 Pipeline 编排
- */
-export class IntentEngine {
+import { matchGroundTruth } from '../autopilot/ground-truth-rules.js';
+export class GoalClassifier {
     api;
     storage = null;
     ruleDistiller = null;
-    /** 项目结构缓存，TTL=2min，避免每次分析都读文件系统 */
-    structureCache = cacheRegistry.register('intent:structure', { max: CACHE.INTENT_STRUCTURE_MAX, ttl: TIME.TWO_MINUTES });
-    /** decisions.md 内容缓存，TTL=5min */
-    decisionsCache = cacheRegistry.register('intent:decisions', { max: CACHE.INTENT_STRUCTURE_MAX, ttl: TIME.FIVE_MINUTES });
-    /** 意图规则缓存，TTL=5min，避免每次 analyze 都查 DB */
-    rulesCache = cacheRegistry.register('intent:rules', { max: CACHE.INTENT_STRUCTURE_MAX, ttl: TIME.FIVE_MINUTES });
-    /** TreeIndex 推理检索结果缓存，key=projectPath:requirement，TTL=2min */
-    treeIndexCache = cacheRegistry.register('intent:treeIndex', { max: CACHE.INTENT_TREE_MAX, ttl: TIME.TWO_MINUTES });
+    structureCache = cacheRegistry.register('goal:structure', { max: CACHE.INTENT_STRUCTURE_MAX, ttl: TIME.TWO_MINUTES });
+    decisionsCache = cacheRegistry.register('goal:decisions', { max: CACHE.INTENT_STRUCTURE_MAX, ttl: TIME.FIVE_MINUTES });
+    rulesCache = cacheRegistry.register('goal:rules', { max: CACHE.INTENT_STRUCTURE_MAX, ttl: TIME.FIVE_MINUTES });
+    treeIndexCache = cacheRegistry.register('goal:treeIndex', { max: CACHE.INTENT_TREE_MAX, ttl: TIME.TWO_MINUTES });
     constructor(api, storage) {
         this.api = api;
         if (storage) {
@@ -35,60 +23,22 @@ export class IntentEngine {
             this.ruleDistiller = new RuleDistiller(storage);
         }
     }
-    /**
-     * 触发离线规则提炼（每 20 次 Stop 调用一次）
-     */
-    async distillRules(projectPath) {
-        if (!this.ruleDistiller)
-            return 0;
-        const count = await this.ruleDistiller.distillRules(projectPath);
-        // 规则更新后失效缓存，下次 analyze 重新加载
-        this.rulesCache.delete(projectPath);
-        return count;
-    }
-    /**
-     * daemon 启动时预热规则缓存，降低首次 analyze 的数据库读取延迟
-     */
-    warmupRulesCache(projectPath) {
-        if (!this.ruleDistiller)
-            return;
-        try {
-            const rules = this.getRulesFromStorage(projectPath);
-            if (rules.length > 0) {
-                logger.info(`[意图分析] 已预热规则缓存：${projectPath}（${rules.length} 条）`);
-            }
-        }
-        catch (err) {
-            logger.warn(`[意图分析] 规则缓存预热失败：${err}`);
-        }
-    }
-    /**
-     * 分析用户输入的意图和复杂度
-     * @param conversationHistory 会话上下文（最近的用户输入和工具调用摘要）
-     * @param activePlan 当前活跃计划摘要（跨 session 的任务续接状态）
-     * @param sessionId 当前 session ID（用于决策日志）
-     */
-    async analyze(userPrompt, projectPath, techStack, conversationHistory, isForgeManaged, activePlan, sessionId) {
-        // 快速放行：纯对话和无改动操作
-        // 注意：有会话上下文时（多轮对话中），短输入可能是确认回复，不应被快速过滤
+    async classify(userPrompt, projectPath, options = {}) {
+        const { techStack, conversationHistory, isForgeManaged, activePlan, sessionId } = options;
+        const sessionIdVal = sessionId ?? '';
         const quickResult = this.quickFilter(userPrompt, !!conversationHistory);
         if (quickResult) {
             logger.info(`快速判定：${quickResult.complexity} | 理由=${quickResult.reasoning}`);
-            return quickResult;
+            return { ...quickResult, projectPath, sessionId: sessionIdVal, taskType: 'other' };
         }
-        // ── Layer 1: Ground Truth（不可变规则，最高优先级）────────────────────────
+        // Layer 1: Ground Truth
         const gtMatch = matchGroundTruth(userPrompt);
         if (gtMatch) {
-            // 需要上下文检查的规则（如"执行已有规划"）：验证活跃计划是否存在
             if (gtMatch.requiresContextCheck) {
                 const plan = activePlan ?? this.getActivePlan(projectPath);
-                if (!plan) {
-                    logger.info(`[意图分析] Ground Truth 规则 ${gtMatch.id} 需要活跃计划，但未找到，降级处理`);
-                    // 没有活跃计划，跳过此规则，继续到 Layer 2
-                }
-                else {
-                    logger.info(`[意图分析] Ground Truth 命中: ${gtMatch.id} → ${gtMatch.complexity}（检测到活跃计划：${plan.title}）`);
-                    const gtResult = {
+                if (plan) {
+                    logger.info(`[GoalClassifier] Ground Truth 命中: ${gtMatch.id} → ${gtMatch.complexity}（活跃计划：${plan.title}）`);
+                    const goal = {
                         complexity: gtMatch.complexity,
                         requiresPipeline: false,
                         requirement: userPrompt,
@@ -97,14 +47,17 @@ export class IntentEngine {
                         suggestedPhases: ['code', 'test'],
                         skipPhases: ['analyze', 'design'],
                         confidence: 1.0,
+                        projectPath,
+                        sessionId: sessionIdVal,
+                        taskType: 'other',
                     };
-                    this.logDecision(sessionId, projectPath, userPrompt, gtMatch.complexity, 'ground_truth', gtMatch.id, 1.0);
-                    return gtResult;
+                    this.logDecision(sessionIdVal, projectPath, userPrompt, gtMatch.complexity, 'ground_truth', gtMatch.id, 1.0);
+                    return goal;
                 }
             }
             else {
-                logger.info(`[意图分析] Ground Truth 命中: ${gtMatch.id} → ${gtMatch.complexity}`);
-                const gtResult = {
+                logger.info(`[GoalClassifier] Ground Truth 命中: ${gtMatch.id} → ${gtMatch.complexity}`);
+                const goal = {
                     complexity: gtMatch.complexity,
                     requiresPipeline: gtMatch.complexity === 'complex',
                     requirement: userPrompt,
@@ -112,111 +65,104 @@ export class IntentEngine {
                     estimatedFiles: gtMatch.complexity === 'simple' ? 0 : gtMatch.complexity === 'moderate' ? 3 : 8,
                     suggestedPhases: gtMatch.complexity === 'complex' ? ['analyze', 'code', 'test'] : gtMatch.complexity === 'moderate' ? ['code', 'test'] : [],
                     confidence: 1.0,
+                    projectPath,
+                    sessionId: sessionIdVal,
+                    taskType: 'other',
                 };
-                // 记录决策日志
-                this.logDecision(sessionId, projectPath, userPrompt, gtMatch.complexity, 'ground_truth', gtMatch.id, 1.0);
-                return gtResult;
+                this.logDecision(sessionIdVal, projectPath, userPrompt, gtMatch.complexity, 'ground_truth', gtMatch.id, 1.0);
+                return goal;
             }
         }
-        // ── Layer 2: Quality Learned Rules（质量加权，自动进化）────────────────────
+        // Layer 2: Learned Rules
         if (this.ruleDistiller) {
             try {
                 const rules = this.getActiveLearnedRulesFromStorage(projectPath);
                 if (rules.length > 0) {
                     const ruleResult = this.ruleDistiller.matchRules(userPrompt, rules);
-                    // 提高置信度门槛到 0.7，只有高质量规则才能跳过 AI
                     if (ruleResult && (ruleResult.confidence ?? 0) >= 0.7) {
-                        logger.info(`[规则库命中] complexity=${ruleResult.complexity} | ${ruleResult.reasoning}`);
-                        this.logDecision(sessionId, projectPath, userPrompt, ruleResult.complexity, 'learned', null, ruleResult.confidence ?? 0);
-                        return ruleResult;
+                        logger.info(`[GoalClassifier] 规则库命中: complexity=${ruleResult.complexity}`);
+                        this.logDecision(sessionIdVal, projectPath, userPrompt, ruleResult.complexity, 'learned', null, ruleResult.confidence ?? 0);
+                        return { ...ruleResult, projectPath, sessionId: sessionIdVal, taskType: inferTaskType(userPrompt) };
                     }
                 }
             }
-            catch {
-                // 规则库查询失败，继续走 AI 分析
-            }
+            catch { /* continue to AI */ }
         }
-        // ── Layer 3: AI Fallback ──────────────────────────────────────────────────
+        // Layer 3: AI Fallback
         try {
             const result = await this.aiAnalyze(userPrompt, projectPath, techStack, conversationHistory, activePlan);
-            // 低置信度主动澄清：confidence < 0.6 且有澄清问题时，强制降级为 simple + 附带澄清问题
             if (result.confidence !== undefined && result.confidence < 0.6 && result.clarifyQuestions && result.clarifyQuestions.length > 0) {
-                logger.warn(`[意图引擎] 置信度过低 (${result.confidence.toFixed(2)})，触发主动澄清`);
-                this.logDecision(sessionId, projectPath, userPrompt, 'simple', 'ai_fallback', null, result.confidence);
+                logger.warn(`[GoalClassifier] 置信度过低 (${result.confidence.toFixed(2)})，触发主动澄清`);
+                this.logDecision(sessionIdVal, projectPath, userPrompt, 'simple', 'ai_fallback', null, result.confidence);
                 return {
                     ...result,
                     complexity: 'simple',
                     requiresPipeline: false,
                     reasoning: `${result.reasoning}\n\n⚠️ 置信度过低 (${(result.confidence * 100).toFixed(0)}%)，建议先澄清需求`,
+                    projectPath,
+                    sessionId: sessionIdVal,
+                    taskType: inferTaskType(userPrompt),
                 };
             }
-            this.logDecision(sessionId, projectPath, userPrompt, result.complexity, 'ai_fallback', null, result.confidence ?? 0.5);
-            return result;
+            this.logDecision(sessionIdVal, projectPath, userPrompt, result.complexity, 'ai_fallback', null, result.confidence ?? 0.5);
+            return { ...result, projectPath, sessionId: sessionIdVal, taskType: inferTaskType(userPrompt) };
         }
         catch (err) {
-            logger.warn(`[意图引擎] AI 分析失败，使用降级方案：${err}`);
-            return this.fallbackAnalyze(userPrompt, isForgeManaged);
+            logger.warn(`[GoalClassifier] AI 分析失败，使用降级方案：${err}`);
+            const fb = this.fallbackAnalyze(userPrompt, isForgeManaged);
+            return { ...fb, projectPath, sessionId: sessionIdVal, taskType: inferTaskType(userPrompt) };
         }
     }
-    /** 记录意图分类决策到审计日志（fire-and-forget） */
-    logDecision(sessionId, projectPath, requirement, complexity, layer, matchedRuleId, confidence) {
-        if (!sessionId || !this.storage)
+    async distillRules(projectPath) {
+        if (!this.ruleDistiller)
+            return 0;
+        const count = await this.ruleDistiller.distillRules(projectPath);
+        this.rulesCache.delete(projectPath);
+        return count;
+    }
+    warmupRulesCache(projectPath) {
+        if (!this.ruleDistiller)
             return;
         try {
-            const id = `dec_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
-            this.storage.logIntentDecision({
-                id,
-                session_id: sessionId,
-                project_path: projectPath,
-                requirement,
-                predicted_complexity: complexity,
-                matched_rule_id: matchedRuleId,
-                matched_layer: layer,
-                confidence,
-            });
+            const rules = this.getActiveLearnedRulesFromStorage(projectPath);
+            if (rules.length > 0) {
+                logger.info(`[GoalClassifier] 已预热规则缓存：${projectPath}（${rules.length} 条）`);
+            }
         }
         catch (err) {
-            logger.debug(`[意图引擎] 决策日志写入失败（非致命）：${err}`);
+            logger.warn(`[GoalClassifier] 规则缓存预热失败：${err}`);
         }
     }
-    /** 从 StorageEngine 获取活跃学习规则（is_active=1, priority='learned'，带 TTL 缓存） */
-    getActiveLearnedRulesFromStorage(projectPath) {
-        const cached = this.rulesCache.get(projectPath);
-        if (cached)
-            return cached;
-        // 优先使用 getActiveLearnedRules（v20 新方法），降级到 getIntentRules
-        const data = this.storage?.getActiveLearnedRules?.() ??
-            this.ruleDistiller?.storage?.getIntentRules() ?? [];
-        this.rulesCache.set(projectPath, data);
-        return data;
-    }
-    /**
-     * @deprecated Use getActiveLearnedRulesFromStorage instead
-     */
-    getRulesFromStorage(projectPath) {
-        return this.getActiveLearnedRulesFromStorage(projectPath);
+    invalidateStructureCache(projectPath) {
+        this.structureCache.delete(projectPath);
     }
-    /** 读取项目的活跃计划摘要（用于 Ground Truth 上下文检查） */
-    getActivePlan(projectPath) {
-        try {
-            return readActivePlanSummary(projectPath) ?? undefined;
+    generateDirective(analysis) {
+        if (analysis.complexity === 'simple')
+            return null;
+        const parts = [];
+        if (analysis.requiresPipeline) {
+            parts.push(`[Forge Autopilot] 检测到复杂需求，已启动 Pipeline 编排。`);
+            parts.push(`需求：${analysis.requirement}`);
+            parts.push(`阶段：${analysis.suggestedPhases.join(' → ')}`);
+            parts.push('');
+            parts.push('请按 Pipeline 阶段指令逐步执行，每步完成后等待质量门禁审查。');
         }
-        catch {
-            return undefined;
+        else {
+            parts.push(`[Forge] 建议关注：${analysis.requirement}`);
+            if (analysis.searchKeywords && analysis.searchKeywords.length > 0) {
+                parts.push(`参考关键词：${analysis.searchKeywords.join(', ')}`);
+            }
         }
+        return parts.join('\n');
+    }
+    getProvider() {
+        return this.api;
     }
-    /**
-     * 快速放行：只过滤明确不涉及代码改动的操作。
-     * @param hasConversation 是否有会话上下文（多轮对话中）。有上下文时短输入可能是确认回复，应交给 AI 判断。
-     */
     quickFilter(prompt, hasConversation) {
         const lower = prompt.toLowerCase().trim();
-        // 确认类回复（同意/好的/是/继续/A/B/C 等）不应被截胡，直接透传给 Claude
         const confirmPatterns = /^(同意|好的|好|是|是的|可以|行|ok|yes|sure|继续|go|proceed|确认|没问题|对|嗯|[a-c])$/i;
-        if (confirmPatterns.test(lower)) {
-            return null; // 交给 Claude 直接处理
-        }
-        // 纯对话 / 提问：不涉及改动
+        if (confirmPatterns.test(lower))
+            return null;
         const conversationPatterns = [
             /^(看|查看|显示|cat|show|read|explain|解释|描述)/i,
             /^(help|帮助|what|什么|how|怎么|为什么|why|where|哪)/i,
@@ -225,17 +171,9 @@ export class IntentEngine {
         ];
         for (const pattern of conversationPatterns) {
             if (pattern.test(lower)) {
-                return {
-                    complexity: 'simple',
-                    requiresPipeline: false,
-                    requirement: prompt,
-                    reasoning: '纯对话/提问，不涉及代码改动',
-                    estimatedFiles: 0,
-                    suggestedPhases: [],
-                };
+                return { complexity: 'simple', requiresPipeline: false, requirement: prompt, reasoning: '纯对话/提问，不涉及代码改动', estimatedFiles: 0, suggestedPhases: [] };
             }
         }
-        // git / 运行命令：不涉及代码改动
         const commandPatterns = [
             /^(commit|push|pull|merge|rebase|stash|checkout|branch)/i,
             /^(run|执行|启动)\s+(test|lint|build|dev|start|serve)/i,
@@ -243,43 +181,22 @@ export class IntentEngine {
         ];
         for (const pattern of commandPatterns) {
             if (pattern.test(lower)) {
-                return {
-                    complexity: 'simple',
-                    requiresPipeline: false,
-                    requirement: prompt,
-                    reasoning: '运行命令/Git 操作，不涉及代码改动',
-                    estimatedFiles: 0,
-                    suggestedPhases: [],
-                };
+                return { complexity: 'simple', requiresPipeline: false, requirement: prompt, reasoning: '运行命令/Git 操作，不涉及代码改动', estimatedFiles: 0, suggestedPhases: [] };
             }
         }
-        // 极短输入且不含动词：有会话上下文时不过滤（可能是对上轮问题的回复）
         if (!hasConversation) {
             const hasActionVerb = /修|改|加|删|实现|重构|优化|fix|add|remove|create|update|refactor|implement|build/i.test(lower);
             if (prompt.length < 4 && !hasActionVerb) {
-                return {
-                    complexity: 'simple',
-                    requiresPipeline: false,
-                    requirement: prompt,
-                    reasoning: '极短输入且无改动动词（无会话上下文），判定为对话',
-                    estimatedFiles: 0,
-                    suggestedPhases: [],
-                };
+                return { complexity: 'simple', requiresPipeline: false, requirement: prompt, reasoning: '极短输入且无改动动词（无会话上下文），判定为对话', estimatedFiles: 0, suggestedPhases: [] };
             }
         }
-        return null; // 交给 AI 分析
+        return null;
     }
-    /**
-     * AI 分析意图（带项目上下文）
-     */
     async aiAnalyze(userPrompt, projectPath, techStack, conversationHistory, activePlan) {
         const contextInfo = await this.readDecisionsContext(userPrompt, projectPath);
         const projectStructure = this.getProjectStructure(projectPath);
-        const historySection = conversationHistory
-            ? `\n## 会话上下文（最近的对话和操作）\n${conversationHistory}\n`
-            : '';
-        const planSection = activePlan
-            ? `\n## 当前活跃计划（跨 session 任务续接状态）
+        const historySection = conversationHistory ? `\n## 会话上下文（最近的对话和操作）\n${conversationHistory}\n` : '';
+        const planSection = activePlan ? `\n## 当前活跃计划（跨 session 任务续接状态）
 计划文件: ${activePlan.relPath}
 计划标题: ${activePlan.title}
 进行中任务: ${activePlan.inProgress.length > 0 ? activePlan.inProgress.map(t => `\n  - ${t}`).join('') : '无'}
@@ -287,8 +204,7 @@ export class IntentEngine {
 已完成: ${activePlan.doneCount} 个任务
 
 **重要**：如果用户输入是对上述任务的续接（如"继续"、"下一步"、任务相关的具体指令），应判定为 simple 或 moderate，直接执行，不要重新启动 Pipeline 或 Plan Mode。
-`
-            : '';
+` : '';
         const techStackSection = techStack ? `技术栈: ${techStack}` : '';
         const projectStructureSection = projectStructure ? `项目结构:\n${projectStructure}` : '';
         const contextInfoSection = contextInfo ? `近期工作上下文: ${contextInfo}` : '';
@@ -304,94 +220,16 @@ export class IntentEngine {
         const response = await this.api.complete(prompt, 'intent');
         return this.parseAnalysis(response, userPrompt);
     }
-    /**
-     * 获取项目结构摘要（给 AI 提供上下文）
-     */
-    getProjectStructure(projectPath) {
-        const cached = this.structureCache.get(projectPath);
-        if (cached)
-            return cached;
-        try {
-            if (!fs.existsSync(projectPath))
-                return '';
-            const lines = [];
-            const entries = fs.readdirSync(projectPath, { withFileTypes: true });
-            // 收集一级目录和关键文件
-            const dirs = [];
-            const files = [];
-            const skipDirs = new Set(['node_modules', '.git', 'dist', 'build', '.next', '__pycache__', '.claude', '.claude-forge', 'vendor', 'target']);
-            for (const entry of entries) {
-                if (entry.name.startsWith('.') && entry.name !== '.env.example')
-                    continue;
-                if (skipDirs.has(entry.name))
-                    continue;
-                if (entry.isDirectory()) {
-                    dirs.push(entry.name + '/');
-                }
-                else {
-                    files.push(entry.name);
-                }
-            }
-            if (dirs.length > 0)
-                lines.push(`目录: ${dirs.join(', ')}`);
-            if (files.length > 0)
-                lines.push(`文件: ${files.join(', ')}`);
-            // 尝试读取 src/ 的一级子目录，了解模块划分
-            const srcPath = path.join(projectPath, 'src');
-            if (fs.existsSync(srcPath)) {
-                const srcEntries = fs.readdirSync(srcPath, { withFileTypes: true });
-                const srcDirs = srcEntries
-                    .filter(e => e.isDirectory() && !e.name.startsWith('.'))
-                    .map(e => e.name + '/');
-                if (srcDirs.length > 0) {
-                    lines.push(`src/ 模块: ${srcDirs.join(', ')}`);
-                }
-            }
-            const data = lines.join('\n');
-            this.structureCache.set(projectPath, data);
-            return data;
-        }
-        catch {
-            return '';
-        }
-    }
-    /**
-     * 降级分析：AI 不可用时的保底策略
-     * Forge 管理项目：检测到改动动词时保守判定为需要 Pipeline，防止绕过编排
-     */
     fallbackAnalyze(prompt, isForgeManaged) {
-        // 有明确的代码改动动词 → moderate
         const hasAction = /修|改|加|删|实现|重构|优化|fix|add|remove|create|update|refactor|implement|build/i.test(prompt);
         if (!hasAction) {
-            return {
-                complexity: 'simple',
-                requiresPipeline: false,
-                requirement: prompt,
-                reasoning: 'AI 分析不可用，未检测到改动动词，降级判定为对话',
-                estimatedFiles: 0,
-                suggestedPhases: [],
-            };
+            return { complexity: 'simple', requiresPipeline: false, requirement: prompt, reasoning: 'AI 分析不可用，未检测到改动动词，降级判定为对话', estimatedFiles: 0, suggestedPhases: [] };
         }
-        // Forge 管理项目：AI 失败时保守判定，要求 Pipeline 编排，防止代码变更绕过产物生成
         if (isForgeManaged) {
-            logger.warn('[Forge:意图引擎] AI 不可用，Forge 管理项目检测到改动动词，保守判定为需要 Pipeline');
-            return {
-                complexity: 'moderate',
-                requiresPipeline: true,
-                requirement: prompt,
-                reasoning: 'AI 分析不可用，Forge 管理项目检测到改动动词，保守判定为需要 Pipeline 编排',
-                estimatedFiles: 0,
-                suggestedPhases: ['analyze', 'code', 'test'],
-            };
+            logger.warn('[GoalClassifier] AI 不可用，Forge 管理项目检测到改动动词，保守判定为需要 Pipeline');
+            return { complexity: 'moderate', requiresPipeline: true, requirement: prompt, reasoning: 'AI 分析不可用，Forge 管理项目检测到改动动词，保守判定为需要 Pipeline 编排', estimatedFiles: 0, suggestedPhases: ['analyze', 'code', 'test'] };
         }
-        return {
-            complexity: 'moderate',
-            requiresPipeline: false,
-            requirement: prompt,
-            reasoning: 'AI 分析不可用，检测到改动动词，降级判定为中等复杂度',
-            estimatedFiles: 0,
-            suggestedPhases: ['code', 'test'],
-        };
+        return { complexity: 'moderate', requiresPipeline: false, requirement: prompt, reasoning: 'AI 分析不可用，检测到改动动词，降级判定为中等复杂度', estimatedFiles: 0, suggestedPhases: ['code', 'test'] };
     }
     parseAnalysis(response, originalPrompt) {
         try {
@@ -414,44 +252,33 @@ export class IntentEngine {
             };
         }
         catch {
-            logger.warn('[Forge:意图引擎] AI 响应解析失败');
+            logger.warn('[GoalClassifier] AI 响应解析失败');
             return this.fallbackAnalyze(originalPrompt);
         }
     }
-    /**
-     * 读取项目蒸馏产出的 decisions.md 作为上下文
-     * 优先走树索引推理检索，降级到关键词切片
-     */
     async readDecisionsContext(requirement, projectPath) {
         const decisionsPath = path.join(projectPath, '.claude-forge', 'decisions.md');
-        // 先查 TreeIndex 结果缓存
         const cacheKey = `${projectPath}:${requirement.slice(0, 100)}`;
         const cached = this.treeIndexCache.get(cacheKey);
         if (cached) {
-            logger.debug(`[意图引擎] TreeIndex 缓存命中`);
+            logger.debug(`[GoalClassifier] TreeIndex 缓存命中`);
             return cached;
         }
-        // 优先走树索引推理检索
         try {
             const index = TreeIndexEngine.loadFromFile(decisionsPath);
             if (index && !TreeIndexEngine.isStale(decisionsPath)) {
                 const engine = new TreeIndexEngine(this.api);
                 const result = await engine.search(index, requirement);
                 if (result) {
-                    logger.debug(`[意图引擎] 树索引推理检索成功，返回 ${result.length} 字符`);
+                    logger.debug(`[GoalClassifier] 树索引推理检索成功，返回 ${result.length} 字符`);
                     this.treeIndexCache.set(cacheKey, result);
                     return result;
                 }
             }
         }
-        catch {
-            // 降级到关键词切片
-        }
+        catch { /* fallback */ }
         return this.readDecisionsContextFallback(projectPath);
     }
-    /**
-     * 降级方案：读取 decisions.md 末尾内容（TTL 缓存）
-     */
     readDecisionsContextFallback(projectPath) {
         const cached = this.decisionsCache.get(projectPath);
         if (cached)
@@ -461,7 +288,6 @@ export class IntentEngine {
             if (!fs.existsSync(decisionsPath))
                 return '';
             const content = fs.readFileSync(decisionsPath, 'utf-8');
-            // 只取最近的内容，避免 prompt 过长
             const data = content.trim();
             this.decisionsCache.set(projectPath, data);
             return data;
@@ -470,36 +296,100 @@ export class IntentEngine {
             return '';
         }
     }
-    /**
-     * 主动失效指定项目的结构缓存（当 Write/Edit 操作发生后调用）
-     */
-    invalidateStructureCache(projectPath) {
-        this.structureCache.delete(projectPath);
+    getProjectStructure(projectPath) {
+        const cached = this.structureCache.get(projectPath);
+        if (cached)
+            return cached;
+        try {
+            if (!fs.existsSync(projectPath))
+                return '';
+            const lines = [];
+            const entries = fs.readdirSync(projectPath, { withFileTypes: true });
+            const dirs = [];
+            const files = [];
+            const skipDirs = new Set(['node_modules', '.git', 'dist', 'build', '.next', '__pycache__', '.claude', '.claude-forge', 'vendor', 'target']);
+            for (const entry of entries) {
+                if (entry.name.startsWith('.') && entry.name !== '.env.example')
+                    continue;
+                if (skipDirs.has(entry.name))
+                    continue;
+                if (entry.isDirectory()) {
+                    dirs.push(entry.name + '/');
+                }
+                else {
+                    files.push(entry.name);
+                }
+            }
+            if (dirs.length > 0)
+                lines.push(`目录: ${dirs.join(', ')}`);
+            if (files.length > 0)
+                lines.push(`文件: ${files.join(', ')}`);
+            const srcPath = path.join(projectPath, 'src');
+            if (fs.existsSync(srcPath)) {
+                const srcEntries = fs.readdirSync(srcPath, { withFileTypes: true });
+                const srcDirs = srcEntries.filter(e => e.isDirectory() && !e.name.startsWith('.')).map(e => e.name + '/');
+                if (srcDirs.length > 0) {
+                    lines.push(`src/ 模块: ${srcDirs.join(', ')}`);
+                }
+            }
+            const data = lines.join('\n');
+            this.structureCache.set(projectPath, data);
+            return data;
+        }
+        catch {
+            return '';
+        }
     }
-    getProvider() {
-        return this.api;
+    getActiveLearnedRulesFromStorage(projectPath) {
+        const cached = this.rulesCache.get(projectPath);
+        if (cached)
+            return cached;
+        const data = this.storage?.getActiveLearnedRules?.() ??
+            this.ruleDistiller?.storage?.getIntentRules() ?? [];
+        this.rulesCache.set(projectPath, data);
+        return data;
     }
-    /**
-     */
-    generateDirective(analysis) {
-        if (analysis.complexity === 'simple')
-            return null;
-        const parts = [];
-        if (analysis.requiresPipeline) {
-            parts.push(`[Forge Autopilot] 检测到复杂需求，已启动 Pipeline 编排。`);
-            parts.push(`需求：${analysis.requirement}`);
-            parts.push(`阶段：${analysis.suggestedPhases.join(' → ')}`);
-            parts.push('');
-            parts.push('请按 Pipeline 阶段指令逐步执行，每步完成后等待质量门禁审查。');
+    getActivePlan(projectPath) {
+        try {
+            return readActivePlanSummary(projectPath) ?? undefined;
         }
-        else {
-            // moderate: 提供建议但不强制编排
-            parts.push(`[Forge] 建议关注：${analysis.requirement}`);
-            if (analysis.searchKeywords && analysis.searchKeywords.length > 0) {
-                parts.push(`参考关键词：${analysis.searchKeywords.join(', ')}`);
-            }
+        catch {
+            return undefined;
         }
-        return parts.join('\n');
     }
+    logDecision(sessionId, projectPath, requirement, complexity, layer, matchedRuleId, confidence) {
+        if (!sessionId || !this.storage)
+            return;
+        try {
+            const id = `dec_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+            this.storage.logIntentDecision({
+                id,
+                session_id: sessionId,
+                project_path: projectPath,
+                requirement,
+                predicted_complexity: complexity,
+                matched_rule_id: matchedRuleId,
+                matched_layer: layer,
+                confidence,
+            });
+        }
+        catch (err) {
+            logger.debug(`[GoalClassifier] 决策日志写入失败（非致命）：${err}`);
+        }
+    }
+}
+function inferTaskType(requirement) {
+    const lower = requirement.toLowerCase();
+    if (lower.includes('bug') || lower.includes('fix') || lower.includes('修复'))
+        return 'bugfix';
+    if (lower.includes('feature') || lower.includes('功能') || lower.includes('新增'))
+        return 'feature';
+    if (lower.includes('refactor') || lower.includes('重构'))
+        return 'refactor';
+    if (lower.includes('performance') || lower.includes('性能') || lower.includes('优化'))
+        return 'performance';
+    if (lower.includes('doc') || lower.includes('文档'))
+        return 'documentation';
+    return 'other';
 }
-//# sourceMappingURL=intent-engine.js.map
+//# sourceMappingURL=goal-classifier.js.map