triflux 6.0.21 → 6.1.0

package/hub/intent.mjs

@@ -0,0 +1,100 @@
+// hub/intent.mjs — Intent Classification Engine
+// 사용자 요청의 "진짜 의도"를 분석 → 카테고리 분류 → 최적 에이전트/모델 자동 선택
+
+/** triflux 특화 의도 카테고리 (10개) */
+export const INTENT_CATEGORIES = {
+  implement:  { agent: 'executor',       mcp: 'implement', effort: 'high' },
+  debug:      { agent: 'debugger',       mcp: 'implement', effort: 'high' },
+  analyze:    { agent: 'analyst',        mcp: 'analyze',   effort: 'xhigh' },
+  design:     { agent: 'architect',      mcp: 'analyze',   effort: 'xhigh' },
+  review:     { agent: 'code-reviewer',  mcp: 'review',    effort: 'thorough' },
+  document:   { agent: 'writer',         mcp: 'docs',      effort: 'pro' },
+  research:   { agent: 'scientist',      mcp: 'analyze',   effort: 'high' },
+  'quick-fix':{ agent: 'build-fixer',    mcp: 'implement', effort: 'fast' },
+  explain:    { agent: 'writer',         mcp: 'docs',      effort: 'flash' },
+  test:       { agent: 'test-engineer',  mcp: null,         effort: null },
+};
+
+/** @internal 키워드 → 카테고리 매핑 패턴 */
+const KEYWORD_PATTERNS = [
+  { category: 'implement', keywords: ['구현', '만들', '추가', '생성', '작성', '빌드', 'implement', 'create', 'add', 'build', 'make', 'develop'], weight: 1.0 },
+  { category: 'debug',     keywords: ['버그', '에러', '오류', '고쳐', '수정', '디버그', 'fix', 'bug', 'error', 'debug', 'troubleshoot', 'crash', 'broken'], weight: 1.0 },
+  { category: 'analyze',   keywords: ['분석', '조사', '파악', 'analyze', 'investigate', 'examine', 'inspect'], weight: 0.9 },
+  { category: 'design',    keywords: ['설계', '아키텍처', '디자인', '구조', 'design', 'architect', 'structure'], weight: 0.9 },
+  { category: 'review',    keywords: ['리뷰', '검토', '코드리뷰', 'review', 'code review', 'audit'], weight: 1.0 },
+  { category: 'document',  keywords: ['문서', '도큐먼트', '문서화', 'document', 'docs', 'documentation', 'readme'], weight: 0.9 },
+  { category: 'research',  keywords: ['리서치', '연구', '탐색', 'research', 'explore', 'study'], weight: 0.8 },
+  { category: 'quick-fix', keywords: ['빠르게', '간단히', '급한', 'quick fix', 'hotfix', 'quick'], weight: 0.85 },
+  { category: 'explain',   keywords: ['설명', '뭐야', '알려', '이해', 'explain', 'what is', 'how does', 'tell me', 'describe'], weight: 1.0 },
+  { category: 'test',      keywords: ['테스트', '테스팅', '시험', '검증', 'test', 'testing', 'spec', 'unit test'], weight: 1.0 },
+];
+
+/**
+ * 키워드 기반 빠른 분류 (0-cost, Codex 호출 없이)
+ * 고신뢰(>0.8) 시 Codex triage 건너뜀
+ * @param {string} prompt - 사용자 프롬프트
+ * @returns {{ category: string, confidence: number }}
+ */
+export function quickClassify(prompt) {
+  if (!prompt || typeof prompt !== 'string' || !prompt.trim()) {
+    return { category: 'implement', confidence: 0.1 };
+  }
+
+  const lower = prompt.toLowerCase().trim();
+  let bestCategory = null;
+  let bestScore = 0;
+
+  for (const { category, keywords, weight } of KEYWORD_PATTERNS) {
+    let matchCount = 0;
+    for (const kw of keywords) {
+      if (lower.includes(kw)) matchCount++;
+    }
+    if (matchCount > 0) {
+      const score = (matchCount / keywords.length) * weight;
+      if (score > bestScore) {
+        bestScore = score;
+        bestCategory = category;
+      }
+    }
+  }
+
+  if (!bestCategory) {
+    return { category: 'implement', confidence: 0.3 };
+  }
+
+  // 매칭 품질 기반 신뢰도 (0.5~0.95 범위)
+  const confidence = Math.min(0.95, 0.5 + bestScore * 0.5);
+  return { category: bestCategory, confidence };
+}
+
+/**
+ * 전체 의도 분류 — routing 정보 포함
+ * @param {string} prompt
+ * @returns {{ category: string, confidence: number, reasoning: string, routing: { agent: string, mcp: string|null, effort: string|null } }}
+ */
+export function classifyIntent(prompt) {
+  const quick = quickClassify(prompt);
+  const routing = INTENT_CATEGORIES[quick.category] || INTENT_CATEGORIES.implement;
+
+  return {
+    category: quick.category,
+    confidence: quick.confidence,
+    reasoning: `keyword-match: ${quick.category} (${quick.confidence.toFixed(2)})`,
+    routing: {
+      agent: routing.agent,
+      mcp: routing.mcp,
+      effort: routing.effort,
+    },
+  };
+}
+
+/**
+ * 분류 히스토리 기반 학습 (reflexion 연동 가능)
+ * @param {string} prompt
+ * @param {string} actualCategory - 실제 카테고리
+ */
+export function refineClassification(prompt, actualCategory) {
+  // reflexion 연동 시 store에 오분류 기록 저장 예정
+  void prompt;
+  void actualCategory;
+}

package/hub/pipeline/gates/confidence.mjs

@@ -0,0 +1,56 @@
+// hub/pipeline/gates/confidence.mjs — Pre-Execution Confidence Gate
+//
+// plan → prd → [confidence] → exec
+// 5단계 확신도 검증: >=90% proceed / 70-89% alternative / <70% abort
+
+export const CRITERIA = [
+  { id: 'no_duplicate',  label: '중복 구현 없는지?', weight: 0.25 },
+  { id: 'architecture',  label: '아키텍처 준수?',    weight: 0.25 },
+  { id: 'docs_verified', label: '공식 문서 확인?',   weight: 0.20 },
+  { id: 'oss_reference', label: 'OSS 레퍼런스?',    weight: 0.15 },
+  { id: 'root_cause',    label: '근본 원인 파악?',   weight: 0.15 },
+];
+
+/**
+ * 확신도 검증 실행
+ * @param {string|object} planArtifact - plan 단계에서 생성된 구현 계획
+ * @param {object} context - { checks?, codebaseFiles?, existingTests? }
+ * @param {object} [context.checks] - 각 기준별 점수 (boolean 또는 0-1 숫자)
+ * @returns {{ score: number, breakdown: Array, decision: string, reasoning: string }}
+ */
+export function runConfidenceCheck(planArtifact, context = {}) {
+  if (!planArtifact) {
+    return {
+      score: 0,
+      breakdown: CRITERIA.map(c => ({ id: c.id, label: c.label, weight: c.weight, score: 0, passed: false })),
+      decision: 'abort',
+      reasoning: 'planArtifact가 제공되지 않았습니다.',
+    };
+  }
+
+  const checks = context.checks || {};
+
+  const breakdown = CRITERIA.map(c => {
+    const raw = checks[c.id];
+    const score = typeof raw === 'number' ? Math.max(0, Math.min(1, raw)) : (raw ? 1 : 0);
+    return { id: c.id, label: c.label, weight: c.weight, score, passed: score >= 0.7 };
+  });
+
+  const totalScore = Math.round(
+    breakdown.reduce((sum, b) => sum + b.score * b.weight, 0) * 100,
+  );
+
+  let decision, reasoning;
+  if (totalScore >= 90) {
+    decision = 'proceed';
+    reasoning = `확신도 ${totalScore}%: 모든 기준 충족. 실행 진행.`;
+  } else if (totalScore >= 70) {
+    decision = 'alternative';
+    reasoning = `확신도 ${totalScore}%: 일부 기준 미달. 대안 검토 필요.`;
+  } else {
+    decision = 'abort';
+    reasoning = `확신도 ${totalScore}%: 기준 미달. 실행 중단.`;
+  }
+
+  return { score: totalScore, breakdown, decision, reasoning };
+}

package/hub/pipeline/gates/index.mjs

@@ -0,0 +1,4 @@
+// hub/pipeline/gates/index.mjs — Quality Gates re-export
+
+export { CRITERIA, runConfidenceCheck } from './confidence.mjs';
+export { RED_FLAGS, QUESTIONS, runSelfCheck } from './selfcheck.mjs';

package/hub/pipeline/gates/selfcheck.mjs

@@ -0,0 +1,84 @@
+// hub/pipeline/gates/selfcheck.mjs — Post-Execution Self-Check (Hallucination Detection)
+//
+// exec → verify → [selfcheck] → complete/fix
+// 4대 필수 질문 + 7대 할루시네이션 Red Flag 탐지
+
+export const RED_FLAGS = [
+  { id: 'test_pass_no_output',  pattern: /테스트\s*(?:가\s*)?통과/,  label: '"테스트 통과" (출력 없이)' },
+  { id: 'everything_works',     pattern: /모든\s*게?\s*작동/,        label: '"모든게 작동" (증거 없이)' },
+  { id: 'no_changes_with_diff', pattern: /변경\s*(?:사항\s*)?없/,    label: '"변경 없음" (diff 있는데)' },
+  { id: 'backward_compatible',  pattern: /호환성\s*(?:이\s*)?유지/,  label: '"호환성 유지" (검증 없이)' },
+  { id: 'performance_improved', pattern: /성능\s*(?:이\s*)?개선/,    label: '"성능 개선" (벤치마크 없이)' },
+  { id: 'security_enhanced',    pattern: /보안\s*(?:이\s*)?강화/,    label: '"보안 강화" (증거 없이)' },
+  { id: 'error_handling_done',  pattern: /에러\s*처리\s*(?:가\s*)?완료/, label: '"에러 처리 완료" (catch 블록만)' },
+];
+
+export const QUESTIONS = [
+  { id: 'tests_passing',    label: '모든 테스트 통과?',   evidenceKey: 'testOutput' },
+  { id: 'requirements_met', label: '모든 요구사항 충족?', evidenceKey: 'requirementChecklist' },
+  { id: 'no_assumptions',   label: '검증 없는 가정?',    evidenceKey: 'references' },
+  { id: 'evidence_provided', label: '증거 있는가?',       evidenceKey: 'artifacts' },
+];
+
+/**
+ * Red Flag 스캔 — 텍스트에서 할루시네이션 패턴 탐지
+ * @param {string} text - 스캔 대상 텍스트
+ * @param {object} context - { hasDiff?, evidence? }
+ * @returns {Array<{ id: string, label: string }>}
+ */
+function detectRedFlags(text, context = {}) {
+  const flags = [];
+  const evidence = context.evidence || {};
+
+  for (const rf of RED_FLAGS) {
+    if (!rf.pattern.test(text)) continue;
+
+    // "변경 없음"은 실제 diff가 있을 때만 Red Flag
+    if (rf.id === 'no_changes_with_diff' && !context.hasDiff) continue;
+
+    // "테스트 통과"는 testOutput 증거가 없을 때만 Red Flag
+    if (rf.id === 'test_pass_no_output' && evidence.testOutput) continue;
+
+    // 기타 Red Flag는 해당 id의 반증이 있으면 스킵
+    if (evidence[rf.id]) continue;
+
+    flags.push({ id: rf.id, label: rf.label });
+  }
+
+  return flags;
+}
+
+/**
+ * Self-Check 실행
+ * @param {string|object} execResult - 실행 결과 (텍스트 또는 객체)
+ * @param {string|object} verifyResult - 검증 결과 (텍스트 또는 객체)
+ * @param {object} requirements - { hasDiff?, evidence? }
+ * @param {boolean} [requirements.hasDiff] - diff 존재 여부
+ * @param {object} [requirements.evidence] - { testOutput, requirementChecklist, references, artifacts }
+ * @returns {{ passed: boolean, score: number, flags: Array, checklist: Array }}
+ */
+export function runSelfCheck(execResult, verifyResult, requirements = {}) {
+  const text = [
+    typeof execResult === 'string' ? execResult : JSON.stringify(execResult || ''),
+    typeof verifyResult === 'string' ? verifyResult : JSON.stringify(verifyResult || ''),
+  ].join('\n');
+
+  const flags = detectRedFlags(text, requirements);
+
+  const evidence = requirements.evidence || {};
+  const checklist = QUESTIONS.map(q => {
+    const ev = evidence[q.evidenceKey];
+    const passed = ev != null && (typeof ev === 'string' ? ev.trim().length > 0 : true);
+    return { id: q.id, label: q.label, passed, evidence: ev || null };
+  });
+
+  const allQuestionsPassed = checklist.every(q => q.passed);
+  const passed = flags.length === 0 && allQuestionsPassed;
+
+  // 점수: 기본 100, Red Flag당 -15, 실패 질문당 -20
+  const flagPenalty = flags.length * 15;
+  const questionPenalty = checklist.filter(q => !q.passed).length * 20;
+  const score = Math.max(0, 100 - flagPenalty - questionPenalty);
+
+  return { passed, score, flags, checklist };
+}

package/hub/pipeline/index.mjs

@@ -14,6 +14,10 @@ import {
   updatePipelineState,
   removePipelineState,
 } from './state.mjs';
+import { runConfidenceCheck } from './gates/confidence.mjs';
+import { runSelfCheck } from './gates/selfcheck.mjs';
+import { classifyIntent as _classifyIntent } from '../intent.mjs';
+// deslop gate: 호출자가 scanDirectory/detectSlop 결과를 전달
 
 /**
  * 파이프라인 매니저 생성
@@ -154,6 +158,86 @@ export function createPipeline(db, teamName, opts = {}) {
     remove() {
       return removePipelineState(db, teamName);
     },
+
+    /**
+     * Confidence Gate 실행 + 자동 전이
+     * prd → confidence → exec/failed
+     * @param {string|object} planArtifact
+     * @param {object} context - { checks?, codebaseFiles?, existingTests? }
+     * @returns {{ ok: boolean, gate: object, state?: object, error?: string }}
+     */
+    runConfidenceGate(planArtifact, context = {}) {
+      const current = readPipelineState(db, teamName);
+      if (!current) return { ok: false, error: `파이프라인 없음: ${teamName}` };
+
+      if (current.phase !== 'confidence') {
+        return { ok: false, error: `confidence gate는 confidence 단계에서만 실행 가능 (현재: ${current.phase})` };
+      }
+
+      const gate = runConfidenceCheck(planArtifact, context);
+      this.setArtifact('confidence_result', gate);
+
+      if (gate.decision === 'abort') {
+        const result = this.advance('failed');
+        return { ok: true, gate, state: result.state };
+      }
+
+      // proceed 또는 alternative → exec로 전이
+      const result = this.advance('exec');
+      return { ok: result.ok, gate, state: result.state, error: result.error };
+    },
+
+    /**
+     * Deslop Gate 실행 + 자동 전이
+     * exec → deslop → verify
+     * 호출자가 미리 deslop 결과를 생성하여 전달.
+     * @param {object} [deslopResult] - scanDirectory() 또는 detectSlop() 결과
+     * @returns {{ ok: boolean, gate: object, state?: object, error?: string }}
+     */
+    runDeslopGate(deslopResult = null) {
+      const current = readPipelineState(db, teamName);
+      if (!current) return { ok: false, error: `파이프라인 없음: ${teamName}` };
+
+      if (current.phase !== 'deslop') {
+        return { ok: false, error: `deslop gate는 deslop 단계에서만 실행 가능 (현재: ${current.phase})` };
+      }
+
+      const gate = deslopResult || { files: [], summary: { total: 0, clean: 0 } };
+      this.setArtifact('deslop_result', gate);
+
+      // deslop은 항상 verify로 전이 (정보 제공 게이트, 차단 없음)
+      const result = this.advance('verify');
+      return { ok: result.ok, gate, state: result.state, error: result.error };
+    },
+
+    /**
+     * Self-Check Gate 실행 + 자동 전이
+     * verify → selfcheck → complete/fix
+     * @param {string|object} execResult
+     * @param {string|object} verifyResult
+     * @param {object} requirements - { hasDiff?, evidence? }
+     * @returns {{ ok: boolean, gate: object, state?: object, error?: string }}
+     */
+    runSelfCheckGate(execResult, verifyResult, requirements = {}) {
+      const current = readPipelineState(db, teamName);
+      if (!current) return { ok: false, error: `파이프라인 없음: ${teamName}` };
+
+      if (current.phase !== 'selfcheck') {
+        return { ok: false, error: `selfcheck gate는 selfcheck 단계에서만 실행 가능 (현재: ${current.phase})` };
+      }
+
+      const gate = runSelfCheck(execResult, verifyResult, requirements);
+      this.setArtifact('selfcheck_result', gate);
+
+      if (gate.passed) {
+        const result = this.advance('complete');
+        return { ok: result.ok, gate, state: result.state, error: result.error };
+      }
+
+      // Red Flag 탐지 또는 필수 질문 실패 → fix
+      const result = this.advance('fix');
+      return { ok: result.ok, gate, state: result.state, error: result.error };
+    },
   };
 }
 
@@ -212,5 +296,23 @@ export async function benchmarkEnd(preLabel, postLabel, options = {}) {
   } catch { return null; }
 }
 
+/**
+ * 트리아지 통합: quickClassify 고신뢰 시 Codex 분류 스킵 판정
+ * @param {string} prompt
+ * @param {number} [threshold=0.8]
+ * @returns {{ skip: boolean, routing: object|null, classification: object }}
+ */
+export function triageWithIntent(prompt, threshold = 0.8) {
+  const classification = _classifyIntent(prompt);
+  if (classification.confidence >= threshold) {
+    return { skip: true, routing: classification.routing, classification };
+  }
+  return { skip: false, routing: null, classification };
+}
+
 export { ensurePipelineTable } from './state.mjs';
 export { PHASES, TERMINAL, ALLOWED, canTransition } from './transitions.mjs';
+export { CRITERIA, runConfidenceCheck } from './gates/confidence.mjs';
+export { RED_FLAGS, QUESTIONS, runSelfCheck } from './gates/selfcheck.mjs';
+export { detectSlop, autoFixSlop, scanDirectory } from '../quality/deslop.mjs';
+export { quickClassify, classifyIntent, INTENT_CATEGORIES } from '../intent.mjs';

package/hub/pipeline/transitions.mjs

@@ -1,21 +1,27 @@
 // hub/pipeline/transitions.mjs — 파이프라인 단계 전이 규칙
 //
-// plan → prd → exec → verify → complete/fix
+// plan → prd → confidence → exec → deslop → verify → selfcheck → complete/fix
 // fix → exec/verify/complete/failed
 // complete, failed = 터미널 상태
 
-export const PHASES = ['plan', 'prd', 'exec', 'verify', 'fix', 'complete', 'failed'];
+export const PHASES = [
+  'plan', 'prd', 'confidence', 'exec', 'deslop', 'verify', 'selfcheck',
+  'fix', 'complete', 'failed',
+];
 
 export const TERMINAL = new Set(['complete', 'failed']);
 
 export const ALLOWED = {
-  'plan':     ['prd'],
-  'prd':      ['exec'],
-  'exec':     ['verify'],
-  'verify':   ['fix', 'complete', 'failed'],
-  'fix':      ['exec', 'verify', 'complete', 'failed'],
-  'complete': [],
-  'failed':   [],
+  'plan':       ['prd'],
+  'prd':        ['confidence'],
+  'confidence': ['exec', 'failed'],
+  'exec':       ['deslop'],
+  'deslop':     ['verify'],
+  'verify':     ['selfcheck', 'fix', 'failed'],
+  'selfcheck':  ['complete', 'fix'],
+  'fix':        ['exec', 'verify', 'complete', 'failed'],
+  'complete':   [],
+  'failed':     [],
 };
 
 /**

package/hub/quality/deslop.mjs

@@ -0,0 +1,251 @@
+/**
+ * Anti-Slop Code Pass
+ * AI 생성 코드에서 불필요한 요소를 자동 탐지/제거하는 정적 분석 모듈
+ */
+
+import { readdir, readFile, writeFile, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+
+/** @type {Array<{type: string, pattern: RegExp, severity: string, autoFixable: boolean, multiline: boolean}>} */
+export const SLOP_PATTERNS = [
+  {
+    type: 'trivial_comment',
+    pattern: /^\s*\/\/\s*(import|define|set|get|return|export)\s/i,
+    severity: 'low',
+    autoFixable: true,
+    multiline: false,
+  },
+  {
+    type: 'empty_catch',
+    pattern: /catch\s*\([^)]*\)\s*\{\s*\}/,
+    severity: 'med',
+    autoFixable: false,
+    multiline: true,
+  },
+  {
+    type: 'console_debug',
+    pattern: /^\s*console\.(log|debug|info)\(/,
+    severity: 'low',
+    autoFixable: true,
+    multiline: false,
+  },
+  {
+    type: 'useless_jsdoc',
+    pattern: /\/\*\*\s*\n\s*\*\s*\n\s*\*\//,
+    severity: 'low',
+    autoFixable: true,
+    multiline: true,
+  },
+  {
+    type: 'rethrow_only',
+    pattern: /catch\s*\((\w+)\)\s*\{\s*throw\s+\1\s*;?\s*\}/,
+    severity: 'med',
+    autoFixable: false,
+    multiline: true,
+  },
+  {
+    type: 'redundant_type',
+    pattern: /:\s*(string|number|boolean)\s*=\s*('[^']*'|"[^"]*"|\d+|true|false)/,
+    severity: 'low',
+    autoFixable: false,
+    multiline: false,
+  },
+  {
+    type: 'commented_code',
+    pattern: /^\s*\/\/\s*(const |let |var |function |class |if\s*\(|for\s*\(|while\s*\(|return |await )/,
+    severity: 'low',
+    autoFixable: true,
+    multiline: false,
+  },
+];
+
+const SEVERITY_WEIGHT = { low: 2, med: 5 };
+
+/**
+ * 파일 내용에서 slop 패턴 탐지
+ * @param {string} content - 파일 내용
+ * @param {string} [filePath] - 파일 경로 (보고용)
+ * @returns {{ issues: Array<{line: number, type: string, severity: string, suggestion: string, text: string, autoFixable: boolean}>, score: number }}
+ */
+export function detectSlop(content, filePath = '') {
+  const lines = content.split('\n');
+  const issues = [];
+
+  for (const sp of SLOP_PATTERNS) {
+    if (sp.multiline) continue;
+    for (let i = 0; i < lines.length; i++) {
+      if (sp.pattern.test(lines[i])) {
+        issues.push({
+          line: i + 1,
+          type: sp.type,
+          severity: sp.severity,
+          suggestion: `${sp.type} 패턴 감지`,
+          text: lines[i].trim(),
+          autoFixable: sp.autoFixable,
+        });
+      }
+    }
+  }
+
+  for (const sp of SLOP_PATTERNS) {
+    if (!sp.multiline) continue;
+    const regex = new RegExp(sp.pattern.source, sp.pattern.flags.replace('g', '') + 'g');
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const line = content.substring(0, match.index).split('\n').length;
+      issues.push({
+        line,
+        type: sp.type,
+        severity: sp.severity,
+        suggestion: `${sp.type} 패턴 감지`,
+        text: match[0].split('\n')[0].trim(),
+        autoFixable: sp.autoFixable,
+      });
+    }
+  }
+
+  issues.sort((a, b) => a.line - b.line);
+
+  const totalPenalty = issues.reduce((sum, i) => sum + (SEVERITY_WEIGHT[i.severity] || 2), 0);
+  const score = Math.max(0, 100 - totalPenalty);
+
+  return { issues, score };
+}
+
+/**
+ * 자동 수정 (safe transforms만)
+ * @param {string} content - 파일 내용
+ * @param {Array<{type: string, autoFixable: boolean}>} issues - detectSlop 결과
+ * @returns {{ fixed: string, applied: number, skipped: number }}
+ */
+export function autoFixSlop(content, issues) {
+  if (!issues || issues.length === 0) return { fixed: content, applied: 0, skipped: 0 };
+
+  const fixable = issues.filter(i => i.autoFixable);
+  const skipped = issues.length - fixable.length;
+
+  if (fixable.length === 0) return { fixed: content, applied: 0, skipped };
+
+  let fixed = content;
+  let applied = 0;
+
+  // Multi-line: useless_jsdoc 제거
+  if (fixable.some(i => i.type === 'useless_jsdoc')) {
+    const matches = fixed.match(/\/\*\*\s*\n\s*\*\s*\n\s*\*\/\n?/g);
+    if (matches) {
+      fixed = fixed.replace(/\/\*\*\s*\n\s*\*\s*\n\s*\*\/\n?/g, '');
+      applied += matches.length;
+    }
+  }
+
+  // Line-level: trivial_comment, console_debug, commented_code 제거
+  const lineTypes = new Set(
+    fixable
+      .filter(i => ['trivial_comment', 'console_debug', 'commented_code'].includes(i.type))
+      .map(i => i.type),
+  );
+
+  if (lineTypes.size > 0) {
+    const linePatterns = SLOP_PATTERNS.filter(p => lineTypes.has(p.type));
+    const lines = fixed.split('\n');
+    const result = [];
+    for (const line of lines) {
+      let remove = false;
+      for (const p of linePatterns) {
+        if (p.pattern.test(line)) {
+          remove = true;
+          applied++;
+          break;
+        }
+      }
+      if (!remove) result.push(line);
+    }
+    fixed = result.join('\n');
+  }
+
+  return { fixed, applied, skipped };
+}
+
+function matchesGlob(filePath, pattern) {
+  const normalized = '/' + filePath.replace(/\\/g, '/');
+
+  // **/*.ext → 확장자 매칭
+  if (pattern.startsWith('**/*.')) {
+    const ext = pattern.slice(4);
+    return normalized.endsWith(ext);
+  }
+
+  // *.ext → 확장자 매칭 (디렉토리 무관)
+  if (pattern.startsWith('*.') && !pattern.includes('/')) {
+    const ext = pattern.slice(1);
+    return normalized.endsWith(ext);
+  }
+
+  // **/dir/** → 디렉토리 포함 여부
+  const dirMatch = pattern.match(/^\*\*\/([^*]+)\/\*\*$/);
+  if (dirMatch) {
+    return normalized.includes('/' + dirMatch[1] + '/');
+  }
+
+  return false;
+}
+
+/**
+ * 디렉토리 전체 스캔
+ * @param {string} dirPath - 스캔 대상 디렉토리
+ * @param {object} [opts]
+ * @param {string[]} [opts.include] - 포함할 glob 패턴
+ * @param {string[]} [opts.exclude] - 제외할 glob 패턴
+ * @param {boolean} [opts.autoFix] - 자동 수정 여부
+ * @returns {Promise<{ files: Array<{path: string, issues: Array, score: number}>, summary: object }>}
+ */
+export async function scanDirectory(dirPath, opts = {}) {
+  const {
+    include = ['**/*.mjs', '**/*.js', '**/*.ts'],
+    exclude = ['**/node_modules/**', '**/dist/**', '**/.git/**'],
+    autoFix = false,
+  } = opts;
+
+  const entries = await readdir(dirPath, { recursive: true });
+  const files = [];
+
+  for (const entry of entries) {
+    const normalized = entry.replace(/\\/g, '/');
+    const fullPath = join(dirPath, entry);
+
+    let st;
+    try { st = await stat(fullPath); } catch { continue; }
+    if (!st.isFile()) continue;
+
+    const included = include.some(p => matchesGlob(normalized, p));
+    const excluded = exclude.some(p => matchesGlob(normalized, p));
+    if (!included || excluded) continue;
+
+    const fileContent = await readFile(fullPath, 'utf-8');
+    const { issues, score } = detectSlop(fileContent, normalized);
+
+    if (autoFix && issues.length > 0) {
+      const { fixed, applied } = autoFixSlop(fileContent, issues);
+      if (applied > 0) await writeFile(fullPath, fixed, 'utf-8');
+    }
+
+    files.push({ path: normalized, issues, score });
+  }
+
+  const totalIssues = files.reduce((sum, f) => sum + f.issues.length, 0);
+  const avgScore = files.length > 0
+    ? Math.round(files.reduce((sum, f) => sum + f.score, 0) / files.length)
+    : 100;
+
+  const byType = {};
+  for (const f of files) {
+    for (const issue of f.issues) {
+      byType[issue.type] = (byType[issue.type] || 0) + 1;
+    }
+  }
+
+  return {
+    files,
+    summary: { totalFiles: files.length, totalIssues, averageScore: avgScore, byType },
+  };
+}