triflux 6.0.21 → 6.1.1

package/hub/reflexion.mjs

@@ -0,0 +1,103 @@
+// hub/reflexion.mjs — Cross-Session Error Learning Engine
+// 에러를 구조화 저장 → 다음 세션에서 유사 에러 패턴 매칭 → 자동 솔루션 적용
+
+/**
+ * 에러 메시지를 정규화된 패턴 시그니처로 변환
+ * 파일 경로, 줄 번호, 타임스탬프, UUID, 숫자 리터럴을 플레이스홀더로 치환
+ * @param {string} errorMessage
+ * @returns {string}
+ */
+export function normalizeError(errorMessage) {
+  if (!errorMessage || typeof errorMessage !== 'string') return '';
+  let p = errorMessage;
+  // Windows 파일 경로 (C:\Users\...) — Unix 경로보다 먼저 처리
+  p = p.replace(/[A-Za-z]:\\[\w\\.\-/]+/g, '<FILE>');
+  // Unix 파일 경로 (/home/user/file.js)
+  p = p.replace(/(?:\/[\w.\-]+){2,}/g, '<FILE>');
+  // 줄:컬럼 (file.js:42:10)
+  p = p.replace(/:(\d+)(:\d+)?(?=[\s,)\]]|$)/g, ':<LINE>');
+  // "line 42" / "Line 42"
+  p = p.replace(/\b[Ll]ine\s+\d+/g, 'line <LINE>');
+  // ISO 타임스탬프
+  p = p.replace(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}[\w.+-]*/g, '<TIME>');
+  // UUID (8-4-4-4-12) — Unix 타임스탬프보다 먼저 처리 (UUID 내부 숫자 보호)
+  p = p.replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '<ID>');
+  // 긴 hex 해시 (32+자리)
+  p = p.replace(/\b[0-9a-f]{32,}\b/gi, '<ID>');
+  // Unix 타임스탬프 (10-13자리 숫자)
+  p = p.replace(/\b\d{10,13}\b/g, '<TIME>');
+  // 4자리 이상 숫자 리터럴
+  p = p.replace(/\b\d{4,}\b/g, '<NUM>');
+  // 소문자화 + 공백 정규화
+  p = p.toLowerCase().replace(/\s+/g, ' ').trim();
+  return p;
+}
+
+/**
+ * 에러에 대한 기존 솔루션 검색
+ * @param {object} store - createStore() 반환 객체
+ * @param {string} errorMessage - 원본 에러 메시지
+ * @param {object} [context={}] - { file, function, cli, agent }
+ * @returns {{ found: boolean, entries: Array, bestMatch: object|null }}
+ */
+export function lookupSolution(store, errorMessage, context = {}) {
+  const pattern = normalizeError(errorMessage);
+  if (!pattern) return { found: false, entries: [], bestMatch: null };
+
+  const entries = store.findReflexion(pattern, context);
+  if (!entries.length) return { found: false, entries: [], bestMatch: null };
+
+  const bestMatch = entries[0]; // confidence DESC 정렬 결과
+  return { found: true, entries, bestMatch };
+}
+
+/**
+ * 에러 해결 후 학습 저장
+ * 동일 패턴이 존재하면 hit 업데이트, 없으면 새로 생성
+ * @param {object} store
+ * @param {{ error: string, solution: string, context?: object, success?: boolean }} opts
+ * @returns {object|null}
+ */
+export function learnFromError(store, { error, solution, context = {}, success = false }) {
+  const pattern = normalizeError(error);
+  if (!pattern || !solution) return null;
+
+  // 동일 패턴이 이미 존재하는지 확인
+  const existing = store.findReflexion(pattern, context);
+  if (existing.length && existing[0].error_pattern === pattern) {
+    return store.updateReflexionHit(existing[0].id, success);
+  }
+
+  return store.addReflexion({
+    error_pattern: pattern,
+    error_message: error,
+    context,
+    solution,
+    solution_code: null,
+  });
+}
+
+/**
+ * 솔루션 적용 결과 피드백
+ * @param {object} store
+ * @param {string} entryId
+ * @param {boolean} success
+ * @returns {object|null}
+ */
+export function reportOutcome(store, entryId, success) {
+  return store.updateReflexionHit(entryId, success);
+}
+
+/**
+ * 신뢰도 자동 조정 (success_count / hit_count, 샘플 크기 기반 감쇠)
+ * hit_count가 작으면 0.5(기본값)쪽으로 보수적으로 수렴
+ * @param {object} entry - { hit_count, success_count }
+ * @returns {number} 0~1 사이 신뢰도
+ */
+export function recalcConfidence(entry) {
+  if (!entry || !entry.hit_count || entry.hit_count <= 0) return 0.5;
+  const ratio = entry.success_count / entry.hit_count;
+  // 샘플 크기 기반 감쇠: hit_count가 10 미만이면 기본값(0.5) 방향으로 보정
+  const decay = Math.min(1, entry.hit_count / 10);
+  return ratio * decay + 0.5 * (1 - decay);
+}

package/hub/research.mjs

@@ -0,0 +1,141 @@
+// hub/research.mjs — 자율 웹 리서치 엔진 코어
+// 검색 쿼리 생성 → 결과 정규화 → 보고서 빌드 → 저장
+
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { TFX_REPORTS_DIR } from './paths.mjs';
+
+/**
+ * 주제에서 검색 쿼리 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 [];
+
+  const t = topic.trim();
+  const detectedLang = lang === 'auto' ? detectLang(t) : lang;
+
+  if (detectedLang === 'ko') {
+    return [
+      `${t} 정리`,
+      `${t} 비교 분석`,
+      `${t} 최신 동향 ${new Date().getFullYear()}`,
+      `${toEnglishQuery(t)} overview`,
+      `${toEnglishQuery(t)} comparison ${new Date().getFullYear()}`,
+    ];
+  }
+
+  return [
+    `${t} overview`,
+    `${t} comparison`,
+    `${t} best practices ${new Date().getFullYear()}`,
+    `${t} pros and cons`,
+  ];
+}
+
+/**
+ * 검색 원시 결과를 정규화한다. 중복 URL 제거 + 빈/null 필터링.
+ * @param {Array<object|null|undefined>} rawResults - 검색 엔진 원시 결과
+ * @returns {Array<{title: string, url: string, snippet: string}>}
+ */
+export function normalizeResults(rawResults) {
+  if (!Array.isArray(rawResults)) return [];
+
+  const seen = new Set();
+  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 (!url || seen.has(url)) continue;
+    seen.add(url);
+    out.push({ title, url, snippet });
+  }
+
+  return out;
+}
+
+/**
+ * 리서치 보고서를 마크다운으로 빌드한다.
+ * @param {string} topic - 리서치 주제
+ * @param {string[]} findings - 핵심 발견 목록
+ * @param {Array<{title: string, url: string, snippet: string}>} sources - 출처 목록
+ * @returns {string} 마크다운 문자열
+ */
+export function buildReport(topic, findings, sources) {
+  const date = new Date().toISOString().split('T')[0];
+  const findingsSection = (findings || [])
+    .map((f, i) => `${i + 1}. ${f}`)
+    .join('\n');
+  const sourcesSection = (sources || [])
+    .map((s) => `- [${s.title || s.url}](${s.url})${s.snippet ? ` — ${s.snippet}` : ''}`)
+    .join('\n');
+
+  return `# Research: ${topic}
+Date: ${date}
+
+## Executive Summary
+${topic}에 대한 자동 리서치 결과입니다.
+
+## Key Findings
+${findingsSection || '_발견 없음_'}
+
+## Actionable Recommendations
+리서치 결과를 바탕으로 다음 단계를 검토하세요.
+
+## Sources
+${sourcesSection || '_출처 없음_'}
+`;
+}
+
+/**
+ * 보고서를 .tfx/reports/research-{timestamp}.md에 저장한다.
+ * @param {string} topic - 리서치 주제 (파일명 생성용)
+ * @param {string} content - 마크다운 보고서 내용
+ * @param {string} [baseDir=process.cwd()] - 프로젝트 루트 경로
+ * @returns {string} 저장된 파일 경로
+ */
+export function saveReport(topic, content, baseDir = process.cwd()) {
+  const dir = join(baseDir, TFX_REPORTS_DIR);
+  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, '-')
+    .slice(0, 40)
+    .toLowerCase();
+  const filename = `research-${ts}-${slug}.md`;
+  const filepath = join(dir, filename);
+
+  writeFileSync(filepath, content, 'utf-8');
+  return filepath;
+}
+
+// ── internal helpers ──
+
+/**
+ * 텍스트에 한글이 포함되어 있으면 'ko', 아니면 'en'
+ * @param {string} text
+ * @returns {'ko'|'en'}
+ */
+function detectLang(text) {
+  return /[가-힣]/.test(text) ? 'ko' : 'en';
+}
+
+/**
+ * 한국어 토픽에서 영어 검색 쿼리용 문자열 추출.
+ * 영문/숫자만 남기고, 없으면 원문 그대로 반환.
+ * @param {string} text
+ * @returns {string}
+ */
+function toEnglishQuery(text) {
+  const eng = text.replace(/[가-힣\s]+/g, ' ').trim();
+  return eng || text;
+}

package/hub/schema.sql

@@ -125,3 +125,22 @@ CREATE TABLE IF NOT EXISTS pipeline_state (
   created_at INTEGER,
   updated_at INTEGER
 );
+
+-- Reflexion 에러 학습 테이블
+CREATE TABLE IF NOT EXISTS reflexion_entries (
+  id TEXT PRIMARY KEY,
+  error_pattern TEXT NOT NULL,          -- 에러 시그니처 (정규화)
+  error_message TEXT NOT NULL,          -- 원본 에러 메시지
+  context_json TEXT NOT NULL DEFAULT '{}', -- { file, function, cli, agent }
+  solution TEXT NOT NULL,               -- 해결책 설명
+  solution_code TEXT,                   -- 해결 코드 스니펫 (있으면)
+  confidence REAL NOT NULL DEFAULT 0.5, -- 솔루션 신뢰도 (0-1)
+  hit_count INTEGER NOT NULL DEFAULT 1, -- 매칭 횟수
+  success_count INTEGER NOT NULL DEFAULT 0, -- 성공 횟수
+  last_hit_ms INTEGER NOT NULL,
+  created_at_ms INTEGER NOT NULL,
+  updated_at_ms INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_reflexion_pattern ON reflexion_entries(error_pattern);
+CREATE INDEX IF NOT EXISTS idx_reflexion_confidence ON reflexion_entries(confidence DESC);

package/hub/store.mjs

@@ -91,6 +91,12 @@ function parseAssignRow(row) {
   };
 }
 
+function parseReflexionRow(row) {
+  if (!row) return null;
+  const { context_json, ...rest } = row;
+  return { ...rest, context: parseJson(context_json, {}) };
+}
+
 /**
  * 저장소 생성
  * @param {string} dbPath
@@ -107,7 +113,7 @@ export function createStore(dbPath) {
 
   const schemaSQL = readFileSync(join(__dirname, 'schema.sql'), 'utf8');
   db.exec("CREATE TABLE IF NOT EXISTS _meta (key TEXT PRIMARY KEY, value TEXT)");
-  const SCHEMA_VERSION = '2';
+  const SCHEMA_VERSION = '3';
   const curVer = (() => {
     try { return db.prepare("SELECT value FROM _meta WHERE key='schema_version'").pluck().get(); }
     catch { return null; }
@@ -221,6 +227,18 @@ export function createStore(dbPath) {
     ackedRecent: db.prepare("SELECT COUNT(*) as cnt FROM messages WHERE status='acked' AND created_at_ms > ? - 300000"),
     assignCountByStatus: db.prepare('SELECT COUNT(*) as cnt FROM assign_jobs WHERE status = ?'),
     activeAssignCount: db.prepare("SELECT COUNT(*) as cnt FROM assign_jobs WHERE status IN ('queued','running')"),
+
+    // reflexion
+    insertReflexion: db.prepare(`
+      INSERT INTO reflexion_entries (id, error_pattern, error_message, context_json, solution, solution_code, confidence, hit_count, success_count, last_hit_ms, created_at_ms, updated_at_ms)
+      VALUES (@id, @error_pattern, @error_message, @context_json, @solution, @solution_code, @confidence, @hit_count, @success_count, @last_hit_ms, @created_at_ms, @updated_at_ms)`),
+    getReflexionById: db.prepare('SELECT * FROM reflexion_entries WHERE id = ?'),
+    findReflexionExact: db.prepare('SELECT * FROM reflexion_entries WHERE error_pattern = ? ORDER BY confidence DESC'),
+    findReflexionLike: db.prepare("SELECT * FROM reflexion_entries WHERE error_pattern LIKE ? ESCAPE '\\' ORDER BY confidence DESC LIMIT 10"),
+    updateReflexionHitSuccess: db.prepare('UPDATE reflexion_entries SET hit_count = hit_count + 1, success_count = success_count + 1, last_hit_ms = ?, updated_at_ms = ? WHERE id = ?'),
+    updateReflexionHitOnly: db.prepare('UPDATE reflexion_entries SET hit_count = hit_count + 1, last_hit_ms = ?, updated_at_ms = ? WHERE id = ?'),
+    updateReflexionConfidence: db.prepare('UPDATE reflexion_entries SET confidence = ?, updated_at_ms = ? WHERE id = ?'),
+    pruneReflexionEntries: db.prepare('DELETE FROM reflexion_entries WHERE updated_at_ms < ? AND confidence < ?'),
   };
 
   const assignStatusListeners = new Set();
@@ -700,6 +718,60 @@ export function createStore(dbPath) {
         assign_timed_out: S.assignCountByStatus.get('timed_out').cnt,
       };
     },
+
+    // --- Reflexion CRUD ---
+
+    addReflexion({ error_pattern, error_message, context = {}, solution, solution_code = null }) {
+      const now = Date.now();
+      const id = uuidv7();
+      S.insertReflexion.run({
+        id,
+        error_pattern,
+        error_message,
+        context_json: JSON.stringify(context),
+        solution,
+        solution_code,
+        confidence: 0.5,
+        hit_count: 1,
+        success_count: 0,
+        last_hit_ms: now,
+        created_at_ms: now,
+        updated_at_ms: now,
+      });
+      return store.getReflexion(id);
+    },
+
+    getReflexion(id) {
+      return parseReflexionRow(S.getReflexionById.get(id));
+    },
+
+    findReflexion(errorPattern) {
+      let rows = S.findReflexionExact.all(errorPattern);
+      if (rows.length) return rows.map(parseReflexionRow);
+      const escaped = errorPattern.replace(/[%_\\]/g, '\\$&');
+      rows = S.findReflexionLike.all(`%${escaped.slice(0, 100)}%`);
+      return rows.map(parseReflexionRow);
+    },
+
+    updateReflexionHit(id, success = false) {
+      const now = Date.now();
+      if (success) {
+        S.updateReflexionHitSuccess.run(now, now, id);
+      } else {
+        S.updateReflexionHitOnly.run(now, now, id);
+      }
+      const entry = store.getReflexion(id);
+      if (entry && entry.hit_count > 0) {
+        const conf = entry.success_count / entry.hit_count;
+        S.updateReflexionConfidence.run(Math.max(0, Math.min(1, conf)), now, id);
+      }
+      return store.getReflexion(id);
+    },
+
+    pruneReflexion(maxAge_ms = 30 * 24 * 3600 * 1000, minConfidence = 0.2) {
+      const cutoff = Date.now() - maxAge_ms;
+      return S.pruneReflexionEntries.run(cutoff, minConfidence).changes;
+    },
   };
 
   return store;

package/hub/team/cli/commands/start/index.mjs

@@ -38,7 +38,7 @@ function renderTmuxInstallHelp() {
 export { parseTeamArgs };
 
 export async function teamStart(args = []) {
-  const { agents, lead, layout, teammateMode, task: rawTask, assigns, autoAttach, progressive, timeoutSec, verbose } = parseTeamArgs(args);
+  const { agents, lead, layout, teammateMode, task: rawTask, assigns, autoAttach, progressive, timeoutSec, verbose, mcpProfile } = parseTeamArgs(args);
   // --assign 사용 시 task를 자동 생성
   const task = rawTask || (assigns.length > 0 ? assigns.map(a => a.prompt).join(" + ") : "");
   if (!task) return printStartUsage();
@@ -72,7 +72,7 @@ export async function teamStart(args = []) {
   const state = effectiveMode === "in-process"
     ? await startInProcessTeam({ sessionId, task, lead, agents, subtasks, hubUrl })
     : effectiveMode === "headless"
-      ? await startHeadlessTeam({ sessionId, task, lead, agents, subtasks, layout, assigns, autoAttach, progressive, timeoutSec, verbose })
+      ? await startHeadlessTeam({ sessionId, task, lead, agents, subtasks, layout, assigns, autoAttach, progressive, timeoutSec, verbose, mcpProfile })
       : effectiveMode === "wt"
         ? await startWtTeam({ sessionId, task, lead, agents, subtasks, layout, hubUrl })
         : await startMuxTeam({ sessionId, task, lead, agents, subtasks, layout, hubUrl, teammateMode: effectiveMode });

package/hub/team/cli/commands/start/parse-args.mjs

@@ -11,6 +11,7 @@ export function parseTeamArgs(args = []) {
   let progressive = true;
   let timeoutSec = 300;
   let verbose = false;
+  let mcpProfile = "";
 
   for (let index = 0; index < args.length; index += 1) {
     const current = args[index];
@@ -38,6 +39,8 @@ export function parseTeamArgs(args = []) {
       progressive = false;
     } else if (current === "--timeout" && args[index + 1]) {
       timeoutSec = Number(args[++index]) || 300;
+    } else if (current === "--mcp-profile" && args[index + 1]) {
+      mcpProfile = args[++index].trim();
     } else if (!current.startsWith("-")) {
       taskParts.push(current);
     }
@@ -54,5 +57,6 @@ export function parseTeamArgs(args = []) {
     progressive,
     timeoutSec,
     verbose,
+    mcpProfile,
   };
 }

package/hub/team/cli/commands/start/start-headless.mjs

@@ -1,14 +1,14 @@
 import { BOLD, DIM, GREEN, RESET, AMBER } from "../../../shared.mjs";
-import { runHeadlessInteractive } from "../../../headless.mjs";
+import { runHeadlessInteractive, resolveCliType } from "../../../headless.mjs";
 import { ok, warn } from "../../render.mjs";
 import { buildTasks } from "../../services/task-model.mjs";
 import { clearTeamState } from "../../services/state-store.mjs";
 
-export async function startHeadlessTeam({ sessionId, task, lead, agents, subtasks, layout, assigns, autoAttach, progressive, timeoutSec, verbose }) {
+export async function startHeadlessTeam({ sessionId, task, lead, agents, subtasks, layout, assigns, autoAttach, progressive, timeoutSec, verbose, mcpProfile }) {
   // --assign이 있으면 그것을 사용, 없으면 agents+subtasks 조합
   const assignments = assigns && assigns.length > 0
-    ? assigns.map((a, i) => ({ cli: a.cli, prompt: a.prompt, role: a.role || `worker-${i + 1}` }))
-    : subtasks.map((subtask, i) => ({ cli: agents[i] || agents[0], prompt: subtask, role: `worker-${i + 1}` }));
+    ? assigns.map((a, i) => ({ cli: resolveCliType(a.cli), prompt: a.prompt, role: a.role || `worker-${i + 1}`, mcp: mcpProfile }))
+    : subtasks.map((subtask, i) => ({ cli: resolveCliType(agents[i] || agents[0]), prompt: subtask, role: `worker-${i + 1}`, mcp: mcpProfile }));
 
   ok(`headless ${assignments.length}워커 시작`);
 
@@ -46,11 +46,17 @@ export async function startHeadlessTeam({ sessionId, task, lead, agents, subtask
     for (const r of failed) console.log(`  ${AMBER}✗${RESET} ${r.paneName} (${r.cli}) exit=${r.exitCode}`);
   }
 
-  // 결과 파일 경로 (Lead가 필요시 Read()로 확인)
+  // handoff 요약 (Lead 토큰 절약 포맷)
   for (const r of results) {
     const icon = r.matched && r.exitCode === 0 ? `${GREEN}✓${RESET}` : `${AMBER}✗${RESET}`;
-    if (r.resultFile) {
-      console.log(`  ${icon} ${r.paneName}: ${r.resultFile}`);
+    if (r.handoffFormatted) {
+      const tag = r.handoffFallback ? `${DIM}(fallback)${RESET}` : "";
+      console.log(`  ${icon} ${r.paneName} ${tag}`);
+      for (const line of r.handoffFormatted.split("\n")) {
+        console.log(`    ${DIM}${line}${RESET}`);
+      }
+    } else {
+      if (r.resultFile) console.log(`  ${icon} ${r.paneName}: ${r.resultFile}`);
     }
   }
 
@@ -83,6 +89,7 @@ export async function startHeadlessTeam({ sessionId, task, lead, agents, subtask
     startedAt: Date.now(),
     members,
     headlessResults: results,
+    handoffs: results.map((r) => ({ paneName: r.paneName, cli: r.cli, ...r.handoff })),
     tasks: buildTasks(assignments.map(a => a.prompt), members.filter((m) => m.role === "worker")),
     postSave() {
       // headless는 실행 완료 후 즉시 정리 — HUD에 잔존 방지