@triflux/core 10.0.3 → 10.25.1

package/hub/quality/deslop.mjs

@@ -3,57 +3,59 @@
  * AI 생성 코드에서 불필요한 요소를 자동 탐지/제거하는 정적 분석 모듈
  */
 
-import { readdir, readFile, writeFile, stat } from 'node:fs/promises';
-import { join, relative } from 'node:path';
+import { readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { join } from "node:path";
 
 /** @type {ReadonlyArray<{type: string, pattern: RegExp, severity: string, autoFixable: boolean, multiline: boolean}>} */
 export const SLOP_PATTERNS = Object.freeze([
   {
-    type: 'trivial_comment',
+    type: "trivial_comment",
     pattern: /^\s*\/\/\s*(import|define|set|get|return|export)\s/i,
-    severity: 'low',
+    severity: "low",
     autoFixable: true,
     multiline: false,
   },
   {
-    type: 'empty_catch',
+    type: "empty_catch",
     pattern: /catch\s*\([^)]*\)\s*\{\s*\}/,
-    severity: 'med',
+    severity: "med",
     autoFixable: false,
     multiline: true,
   },
   {
-    type: 'console_debug',
+    type: "console_debug",
     pattern: /^\s*console\.(log|debug|info)\(/,
-    severity: 'low',
+    severity: "low",
     autoFixable: true,
     multiline: false,
   },
   {
-    type: 'useless_jsdoc',
+    type: "useless_jsdoc",
     pattern: /\/\*\*\s*\n\s*\*\s*\n\s*\*\//,
-    severity: 'low',
+    severity: "low",
     autoFixable: true,
     multiline: true,
   },
   {
-    type: 'rethrow_only',
+    type: "rethrow_only",
     pattern: /catch\s*\((\w+)\)\s*\{\s*throw\s+\1\s*;?\s*\}/,
-    severity: 'med',
+    severity: "med",
     autoFixable: false,
     multiline: true,
   },
   {
-    type: 'redundant_type',
-    pattern: /:\s*(string|number|boolean)\s*=\s*('[^']*'|"[^"]*"|\d+|true|false)/,
-    severity: 'low',
+    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',
+    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,
   },
@@ -67,8 +69,8 @@ const SEVERITY_WEIGHT = { low: 2, med: 5 };
  * @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');
+export function detectSlop(content, filePath = "") {
+  const lines = content.split("\n");
   const issues = [];
 
   for (const sp of SLOP_PATTERNS) {
@@ -90,16 +92,19 @@ export function detectSlop(content, filePath = '') {
 
   for (const sp of SLOP_PATTERNS) {
     if (!sp.multiline) continue;
-    const regex = new RegExp(sp.pattern.source, sp.pattern.flags.replace('g', '') + 'g');
+    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;
+      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(),
+        text: match[0].split("\n")[0].trim(),
         autoFixable: sp.autoFixable,
         file: filePath,
       });
@@ -108,7 +113,10 @@ export function detectSlop(content, filePath = '') {
 
   issues.sort((a, b) => a.line - b.line);
 
-  const totalPenalty = issues.reduce((sum, i) => sum + (SEVERITY_WEIGHT[i.severity] || 2), 0);
+  const totalPenalty = issues.reduce(
+    (sum, i) => sum + (SEVERITY_WEIGHT[i.severity] || 2),
+    0,
+  );
   const score = Math.max(0, 100 - totalPenalty);
 
   return { issues, score };
@@ -121,9 +129,10 @@ export function detectSlop(content, filePath = '') {
  * @returns {{ fixed: string, applied: number, skipped: number }}
  */
 export function autoFixSlop(content, issues) {
-  if (!issues || issues.length === 0) return { fixed: content, applied: 0, skipped: 0 };
+  if (!issues || issues.length === 0)
+    return { fixed: content, applied: 0, skipped: 0 };
 
-  const fixable = issues.filter(i => i.autoFixable);
+  const fixable = issues.filter((i) => i.autoFixable);
   const skipped = issues.length - fixable.length;
 
   if (fixable.length === 0) return { fixed: content, applied: 0, skipped };
@@ -132,10 +141,10 @@ export function autoFixSlop(content, issues) {
   let applied = 0;
 
   // Multi-line: useless_jsdoc 제거
-  if (fixable.some(i => i.type === '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, '');
+      fixed = fixed.replace(/\/\*\*\s*\n\s*\*\s*\n\s*\*\/\n?/g, "");
       applied += matches.length;
     }
   }
@@ -143,13 +152,15 @@ export function autoFixSlop(content, issues) {
   // 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),
+      .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 linePatterns = SLOP_PATTERNS.filter((p) => lineTypes.has(p.type));
+    const lines = fixed.split("\n");
     const result = [];
     for (const line of lines) {
       let remove = false;
@@ -162,23 +173,23 @@ export function autoFixSlop(content, issues) {
       }
       if (!remove) result.push(line);
     }
-    fixed = result.join('\n');
+    fixed = result.join("\n");
   }
 
   return { fixed, applied, skipped };
 }
 
 function matchesGlob(filePath, pattern) {
-  const normalized = '/' + filePath.replace(/\\/g, '/');
+  const normalized = "/" + filePath.replace(/\\/g, "/");
 
   // **/*.ext → 확장자 매칭
-  if (pattern.startsWith('**/*.')) {
+  if (pattern.startsWith("**/*.")) {
     const ext = pattern.slice(4);
     return normalized.endsWith(ext);
   }
 
   // *.ext → 확장자 매칭 (디렉토리 무관)
-  if (pattern.startsWith('*.') && !pattern.includes('/')) {
+  if (pattern.startsWith("*.") && !pattern.includes("/")) {
     const ext = pattern.slice(1);
     return normalized.endsWith(ext);
   }
@@ -186,7 +197,7 @@ function matchesGlob(filePath, pattern) {
   // **/dir/** → 디렉토리 포함 여부
   const dirMatch = pattern.match(/^\*\*\/([^*]+)\/\*\*$/);
   if (dirMatch) {
-    return normalized.includes('/' + dirMatch[1] + '/');
+    return normalized.includes("/" + dirMatch[1] + "/");
   }
 
   return false;
@@ -203,8 +214,8 @@ function matchesGlob(filePath, pattern) {
  */
 export async function scanDirectory(dirPath, opts = {}) {
   const {
-    include = ['**/*.mjs', '**/*.js', '**/*.ts'],
-    exclude = ['**/node_modules/**', '**/dist/**', '**/.git/**'],
+    include = ["**/*.mjs", "**/*.js", "**/*.ts"],
+    exclude = ["**/node_modules/**", "**/dist/**", "**/.git/**"],
     autoFix = false,
   } = opts;
 
@@ -212,32 +223,37 @@ export async function scanDirectory(dirPath, opts = {}) {
   const files = [];
 
   for (const entry of entries) {
-    const normalized = entry.replace(/\\/g, '/');
+    const normalized = entry.replace(/\\/g, "/");
     const fullPath = join(dirPath, entry);
 
     let st;
-    try { st = await stat(fullPath); } catch { continue; }
+    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));
+    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 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');
+      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 avgScore =
+    files.length > 0
+      ? Math.round(files.reduce((sum, f) => sum + f.score, 0) / files.length)
+      : 100;
 
   const byType = {};
   for (const f of files) {
@@ -248,6 +264,11 @@ export async function scanDirectory(dirPath, opts = {}) {
 
   return {
     files,
-    summary: { totalFiles: files.length, totalIssues, averageScore: avgScore, byType },
+    summary: {
+      totalFiles: files.length,
+      totalIssues,
+      averageScore: avgScore,
+      byType,
+    },
   };
 }

package/hub/reflexion.mjs

@@ -7,7 +7,8 @@ const DEFAULT_CONFIDENCE = 0.5;
 const ACTIVE_RULE_CONFIDENCE = 0.5;
 const ADAPTIVE_PROMOTION_STEP = 0.1;
 const ADAPTIVE_DECAY_STEP = 0.1;
-const ADAPTIVE_DECAY_WINDOW = 5;
+/** @deprecated 세션 기반 decay에서 시간 기반으로 변경됨. 미사용. */
+const _ADAPTIVE_DECAY_WINDOW = 5;
 const ADAPTIVE_DELETE_THRESHOLD = 0.3;
 
 function clampConfidence(value) {
@@ -31,6 +32,7 @@ function pickString(...values) {
   );
 }
 
+/** @deprecated 세션 기반 decay 제거로 미사용. 세션 인식 복원 시 재활용 예정. */
 function pickSessionCount(...values) {
   const raw = values.find((value) => Number.isFinite(Number(value)));
   return raw == null ? 0 : Math.max(0, Math.trunc(Number(raw)));
@@ -109,6 +111,7 @@ function normalizeSessionIds(sessionIds) {
   ];
 }
 
+/** @deprecated reflexion_entries 기반. adaptive_rules에서는 미사용. 세션 인식 복원 시 재활용 예정. */
 function getAdaptiveState(rule = {}) {
   const state = rule.adaptive_state || {};
   const session_ids = normalizeSessionIds(state.session_ids);
@@ -125,7 +128,8 @@ function getAdaptiveState(rule = {}) {
   };
 }
 
-function mergeAdaptiveState(rule, errorContext = {}) {
+/** @deprecated reflexion_entries 기반. adaptive_rules에서는 미사용. 세션 인식 복원 시 재활용 예정. */
+function _mergeAdaptiveState(rule, errorContext = {}) {
   const current = getAdaptiveState(rule);
   const sessionId = pickSessionId(errorContext);
   const sessionCount = pickSessionCount(
@@ -159,6 +163,63 @@ function filterEntriesByType(entries, type) {
   );
 }
 
+function parseAdaptiveRuleId(ruleId, projectSlug = "") {
+  const value = pickString(ruleId);
+  if (!value) return null;
+  const nulSeparator = value.indexOf("\u0000");
+  if (nulSeparator > 0) {
+    return {
+      project_slug: value.slice(0, nulSeparator),
+      pattern: value.slice(nulSeparator + 1),
+    };
+  }
+  if (projectSlug && value.startsWith(`${projectSlug}:`)) {
+    return {
+      project_slug: projectSlug,
+      pattern: value.slice(projectSlug.length + 1),
+    };
+  }
+  return null;
+}
+
+function resolveAdaptiveRuleIdentity(
+  ruleIdOrProjectSlug,
+  patternOrErrorContext,
+) {
+  if (typeof patternOrErrorContext === "string") {
+    return {
+      project_slug: pickString(ruleIdOrProjectSlug),
+      pattern: pickString(patternOrErrorContext),
+    };
+  }
+
+  const errorContext =
+    patternOrErrorContext && typeof patternOrErrorContext === "object"
+      ? patternOrErrorContext
+      : {};
+  const projectSlug = pickString(pickProjectSlug(errorContext));
+  const fromRuleId = parseAdaptiveRuleId(ruleIdOrProjectSlug, projectSlug);
+  const errorText = pickString(
+    errorContext.error_pattern,
+    errorContext.pattern,
+    errorContext.error,
+    errorContext.errorText,
+    errorContext.errorMessage,
+    buildErrorText(errorContext),
+  );
+  const pattern = pickString(normalizeError(errorText), fromRuleId?.pattern);
+  return {
+    project_slug: pickString(projectSlug, fromRuleId?.project_slug),
+    pattern,
+  };
+}
+
+function listAdaptiveRulesFromStore(store, projectSlug) {
+  if (!store?.listAdaptiveRules) return [];
+  const rules = store.listAdaptiveRules(projectSlug);
+  return Array.isArray(rules) ? rules : [];
+}
+
 /**
  * 에러 메시지를 정규화된 패턴 시그니처로 변환
  * 파일 경로, 줄 번호, 타임스탬프, UUID, 숫자 리터럴을 플레이스홀더로 치환
@@ -185,6 +246,7 @@ export function normalizeError(errorMessage) {
 
 /**
  * 에러에 대한 기존 솔루션 검색
+ * @deprecated reflexion_entries 기반. adaptive_rules로 통합 예정. 현재 런타임 호출 없음.
  * @param {object} store - createStore() 반환 객체
  * @param {string} errorMessage - 원본 에러 메시지
  * @param {object} [context={}] - { file, function, cli, agent }
@@ -200,6 +262,7 @@ export function lookupSolution(store, errorMessage, context = {}) {
 
 /**
  * 에러 해결 후 학습 저장
+ * @deprecated reflexion_entries 기반. adaptive_rules로 통합 예정. 현재 런타임 호출 없음.
  * 동일 패턴이 존재하면 hit 업데이트, 없으면 새로 생성
  * @param {object} store
  * @param {{ error: string, solution: string, context?: object, success?: boolean }} opts
@@ -233,6 +296,7 @@ export function learnFromError(
 
 /**
  * 솔루션 적용 결과 피드백
+ * @deprecated reflexion_entries 기반. adaptive_rules로 통합 예정. 현재 런타임 호출 없음.
  * @param {object} store
  * @param {string} entryId
  * @param {boolean} success
@@ -280,82 +344,76 @@ export function adaptiveRuleFromError(errorContext = {}) {
 
 /**
  * 동일 패턴이 여러 세션에서 재발하면 adaptive rule confidence를 승격
- * @param {object} store
- * @param {string} ruleId
- * @param {object} [errorContext={}]
+ * 현재 (projectSlug, pattern)과 구형 (ruleId, errorContext) 시그니처를 모두 지원한다.
+ * @param {object} store — store-adapter 인스턴스 (findAdaptiveRule, updateRuleConfidence 필요)
+ * @param {string} ruleIdOrProjectSlug
+ * @param {object|string} patternOrErrorContext
  * @returns {object|null}
  */
-export function promoteRule(store, ruleId, errorContext = {}) {
-  const rule = store.getReflexion(ruleId);
-  if (!rule || rule.type !== ADAPTIVE_RULE_TYPE || !store.patchReflexion)
-    return null;
-  const current = getAdaptiveState(rule);
-  const next = mergeAdaptiveState(rule, errorContext);
-  const newSession = next.session_occurrences > current.session_occurrences;
-  const promoted =
-    newSession && next.session_occurrences >= 2
-      ? clampConfidence(rule.confidence + ADAPTIVE_PROMOTION_STEP)
-      : rule.confidence;
-  return store.patchReflexion(ruleId, {
-    adaptive_state: next,
-    confidence: promoted,
-    hit_count: (rule.hit_count || 0) + 1,
-    last_hit_ms: Date.now(),
-  });
+export function promoteRule(store, ruleIdOrProjectSlug, patternOrErrorContext) {
+  if (!store.findAdaptiveRule || !store.updateRuleConfidence) return null;
+  const identity = resolveAdaptiveRuleIdentity(
+    ruleIdOrProjectSlug,
+    patternOrErrorContext,
+  );
+  if (!identity.project_slug || !identity.pattern) return null;
+  const rule = store.findAdaptiveRule(identity.project_slug, identity.pattern);
+  if (!rule) return null;
+  const promoted = clampConfidence(rule.confidence + ADAPTIVE_PROMOTION_STEP);
+  return store.updateRuleConfidence(
+    identity.project_slug,
+    identity.pattern,
+    promoted,
+    { hit_count_increment: 1 },
+  );
 }
 
 /**
- * 지정 세션 수만큼 관측되지 않은 adaptive rules confidence 감소
- * @param {object} store
- * @param {number} sessionCount
+ * 7일 이상 미관측된 adaptive rules의 confidence를 -0.1 감소, 임계값 이하면 삭제
+ * @param {object} store — store-adapter 인스턴스 (listAdaptiveRules, updateRuleConfidence, deleteAdaptiveRule 필요)
+ * @param {number} _sessionCount — 하위 호환용 (현재 미사용)
+ * @param {string} [projectSlug] — 특정 프로젝트만 대상. 미지정 시 전체 스캔
  * @returns {{ updated: Array, deleted: string[] }}
  */
-export function decayRules(store, sessionCount) {
-  const currentSession = pickSessionCount(sessionCount);
-  if (!store.listReflexion || !store.patchReflexion || !store.deleteReflexion) {
-    return { updated: [], deleted: [] };
-  }
+export function decayRules(store, _sessionCount, projectSlug) {
+  if (!store.listAdaptiveRules) return { updated: [], deleted: [] };
   const result = { updated: [], deleted: [] };
-  for (const rule of store.listReflexion({ type: ADAPTIVE_RULE_TYPE })) {
-    const state = getAdaptiveState(rule);
-    const baseline = Math.max(
-      state.last_seen_session,
-      state.last_decay_session,
-    );
-    const decaySteps = Math.floor(
-      (currentSession - baseline) / ADAPTIVE_DECAY_WINDOW,
-    );
-    if (decaySteps <= 0) continue;
-    const confidence = clampConfidence(
-      rule.confidence - decaySteps * ADAPTIVE_DECAY_STEP,
-    );
-    if (confidence <= ADAPTIVE_DELETE_THRESHOLD) {
-      if (store.deleteReflexion(rule.id)) result.deleted.push(rule.id);
+  const rules = listAdaptiveRulesFromStore(store, projectSlug);
+  for (const rule of rules) {
+    // 7일 이상 미관측된 규칙만 decay 대상
+    const ageDays =
+      (Date.now() - (rule.last_seen_ms || 0)) / (24 * 3600 * 1000);
+    if (ageDays < 7) continue;
+    const decayed = clampConfidence(rule.confidence - ADAPTIVE_DECAY_STEP);
+    if (decayed <= ADAPTIVE_DELETE_THRESHOLD) {
+      if (store.deleteAdaptiveRule(rule.project_slug, rule.pattern)) {
+        result.deleted.push(`${rule.project_slug}:${rule.pattern}`);
+      }
       continue;
     }
-    const updated = store.patchReflexion(rule.id, {
-      confidence,
-      adaptive_state: {
-        ...state,
-        last_decay_session: baseline + decaySteps * ADAPTIVE_DECAY_WINDOW,
-      },
-    });
-    if (updated) result.updated.push(updated);
+    if (decayed < rule.confidence) {
+      const updated = store.updateRuleConfidence(
+        rule.project_slug,
+        rule.pattern,
+        decayed,
+        { hit_count_increment: 0 },
+      );
+      if (updated) result.updated.push(updated);
+    }
   }
   return result;
 }
 
 /**
  * 현재 활성화된 adaptive rules 조회
- * @param {object} store
+ * @param {object} store — store-adapter 인스턴스 (listAdaptiveRules 필요)
  * @param {string} projectSlug
  * @returns {Array}
  */
 export function getActiveAdaptiveRules(store, projectSlug) {
-  if (!store.listReflexion) return [];
-  return store
-    .listReflexion({ type: ADAPTIVE_RULE_TYPE, projectSlug })
-    .filter((rule) => rule.confidence > ACTIVE_RULE_CONFIDENCE);
+  return listAdaptiveRulesFromStore(store, projectSlug).filter(
+    (rule) => rule.confidence >= ACTIVE_RULE_CONFIDENCE,
+  );
 }
 
 /**

package/hub/research.mjs

@@ -1,24 +1,26 @@
 // hub/research.mjs — 자율 웹 리서치 엔진 코어
 // 검색 쿼리 생성 → 결과 정규화 → 보고서 빌드 → 저장
 
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { TFX_REPORTS_DIR } from './paths.mjs';
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { TFX_REPORTS_DIR } from "./paths.mjs";
 
 /**
+ * @experimental 런타임 미연결 — 향후 통합 예정
+ * @experimental
  * 주제에서 검색 쿼리 3-5개를 자동 생성한다.
  * 한국어 주제 → 한국어 + 영어 혼합, 영어 주제 → 영어 쿼리.
  * @param {string} topic - 리서치 주제
  * @param {'ko'|'en'|'auto'} [lang='auto'] - 언어 힌트
  * @returns {string[]} 검색 쿼리 배열
  */
-export function generateQueries(topic, lang = 'auto') {
-  if (!topic || typeof topic !== 'string' || !topic.trim()) return [];
+export function generateQueries(topic, lang = "auto") {
+  if (!topic || typeof topic !== "string" || !topic.trim()) return [];
 
   const t = topic.trim();
-  const detectedLang = lang === 'auto' ? detectLang(t) : lang;
+  const detectedLang = lang === "auto" ? detectLang(t) : lang;
 
-  if (detectedLang === 'ko') {
+  if (detectedLang === "ko") {
     return [
       `${t} 정리`,
       `${t} 비교 분석`,
@@ -48,10 +50,10 @@ export function normalizeResults(rawResults) {
   const out = [];
 
   for (const r of rawResults) {
-    if (!r || typeof r !== 'object') continue;
-    const url = (r.url || r.link || '').trim();
-    const title = (r.title || r.name || '').trim();
-    const snippet = (r.snippet || r.description || r.content || '').trim();
+    if (!r || typeof r !== "object") continue;
+    const url = (r.url || r.link || "").trim();
+    const title = (r.title || r.name || "").trim();
+    const snippet = (r.snippet || r.description || r.content || "").trim();
 
     if (!url || seen.has(url)) continue;
     seen.add(url);
@@ -69,13 +71,16 @@ export function normalizeResults(rawResults) {
  * @returns {string} 마크다운 문자열
  */
 export function buildReport(topic, findings, sources) {
-  const date = new Date().toISOString().split('T')[0];
+  const date = new Date().toISOString().split("T")[0];
   const findingsSection = (findings || [])
     .map((f, i) => `${i + 1}. ${f}`)
-    .join('\n');
+    .join("\n");
   const sourcesSection = (sources || [])
-    .map((s) => `- [${s.title || s.url}](${s.url})${s.snippet ? ` — ${s.snippet}` : ''}`)
-    .join('\n');
+    .map(
+      (s) =>
+        `- [${s.title || s.url}](${s.url})${s.snippet ? ` — ${s.snippet}` : ""}`,
+    )
+    .join("\n");
 
   return `# Research: ${topic}
 Date: ${date}
@@ -84,13 +89,13 @@ Date: ${date}
 ${topic}에 대한 자동 리서치 결과입니다.
 
 ## Key Findings
-${findingsSection || '_발견 없음_'}
+${findingsSection || "_발견 없음_"}
 
 ## Actionable Recommendations
 리서치 결과를 바탕으로 다음 단계를 검토하세요.
 
 ## Sources
-${sourcesSection || '_출처 없음_'}
+${sourcesSection || "_출처 없음_"}
 `;
 }
 
@@ -106,20 +111,24 @@ export function saveReport(topic, content, baseDir = process.cwd()) {
   const resolvedDir = resolve(dir);
   const expectedBase = resolve(baseDir || TFX_REPORTS_DIR);
   if (!resolvedDir.startsWith(expectedBase)) {
-    throw new Error('Invalid report directory: path traversal detected');
+    throw new Error("Invalid report directory: path traversal detected");
   }
   mkdirSync(dir, { recursive: true });
 
-  const ts = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').slice(0, 19);
-  const slug = (topic || 'untitled')
-    .replace(/[^a-zA-Z0-9가-힣\s-]/g, '')
-    .replace(/\s+/g, '-')
+  const ts = new Date()
+    .toISOString()
+    .replace(/[:.]/g, "-")
+    .replace("T", "_")
+    .slice(0, 19);
+  const slug = (topic || "untitled")
+    .replace(/[^a-zA-Z0-9가-힣\s-]/g, "")
+    .replace(/\s+/g, "-")
     .slice(0, 40)
     .toLowerCase();
   const filename = `research-${ts}-${slug}.md`;
   const filepath = join(dir, filename);
 
-  writeFileSync(filepath, content, 'utf-8');
+  writeFileSync(filepath, content, "utf-8");
   return filepath;
 }
 
@@ -131,7 +140,7 @@ export function saveReport(topic, content, baseDir = process.cwd()) {
  * @returns {'ko'|'en'}
  */
 function detectLang(text) {
-  return /[가-힣]/.test(text) ? 'ko' : 'en';
+  return /[가-힣]/.test(text) ? "ko" : "en";
 }
 
 /**
@@ -141,6 +150,6 @@ function detectLang(text) {
  * @returns {string}
  */
 function toEnglishQuery(text) {
-  const eng = text.replace(/[가-힣\s]+/g, ' ').trim();
+  const eng = text.replace(/[가-힣\s]+/g, " ").trim();
   return eng || text;
 }