triflux 5.0.3 → 5.1.1

package/hub/pipeline/index.mjs

@@ -4,6 +4,7 @@
 
 import { writeFileSync, mkdirSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
 
 import { canTransition, transitionPhase, ralphRestart, TERMINAL } from './transitions.mjs';
 import {
@@ -83,6 +84,26 @@ export function createPipeline(db, teamName, opts = {}) {
       return { ok: true, state: { ...state } };
     },
 
+    /**
+     * DAG 컨텍스트를 파이프라인 상태에 저장
+     * @param {{ dag_width: number, levels: Record<number, string[]>, edges: Array<{from:string, to:string}>, max_complexity: string, taskResults: Record<string, *> }} dagContext
+     */
+    setDagContext(dagContext) {
+      const current = readPipelineState(db, teamName);
+      if (!current) return;
+      const artifacts = { ...(current.artifacts || {}), dagContext };
+      state = updatePipelineState(db, teamName, { artifacts });
+    },
+
+    /**
+     * DAG 컨텍스트 조회 (편의 메서드)
+     * @returns {{ dag_width: number, levels: Record<number, string[]>, edges: Array<{from:string, to:string}>, max_complexity: string, taskResults: Record<string, *> } | null}
+     */
+    getDagContext() {
+      const current = readPipelineState(db, teamName) || state;
+      return current?.artifacts?.dagContext || null;
+    },
+
     /**
      * artifact 저장 (plan_path, prd_path, verify_report 등)
      * @param {string} key
@@ -136,5 +157,60 @@ export function createPipeline(db, teamName, opts = {}) {
   };
 }
 
+// ── 토큰 벤치마크 훅 ──
+
+let _tokenSnapshotMod = null;
+
+async function loadTokenSnapshot() {
+  if (_tokenSnapshotMod) return _tokenSnapshotMod;
+  try {
+    _tokenSnapshotMod = await import('../../scripts/token-snapshot.mjs');
+  } catch {
+    _tokenSnapshotMod = null;
+  }
+  return _tokenSnapshotMod;
+}
+
+/**
+ * 파이프라인 시작 시 토큰 스냅샷 캡처
+ * @param {string} label - 스냅샷 라벨 (e.g. teamName + timestamp)
+ * @returns {Promise<{label: string, snapshot: object}|null>}
+ */
+export async function benchmarkStart(label) {
+  const mod = await loadTokenSnapshot();
+  if (!mod?.takeSnapshot) return null;
+  try {
+    const snapshot = mod.takeSnapshot(label);
+    return { label, snapshot };
+  } catch { return null; }
+}
+
+/**
+ * 파이프라인 종료 시 diff 계산 + 결과 저장
+ * @param {string} preLabel - 시작 스냅샷 라벨
+ * @param {string} postLabel - 종료 스냅샷 라벨
+ * @param {object} options - { agent?, cli?, id? }
+ * @returns {Promise<object|null>} diff 결과
+ */
+export async function benchmarkEnd(preLabel, postLabel, options = {}) {
+  const mod = await loadTokenSnapshot();
+  if (!mod?.takeSnapshot || !mod?.computeDiff) return null;
+  try {
+    // 종료 스냅샷 캡처
+    mod.takeSnapshot(postLabel);
+    // diff 계산 (결과는 DIFFS_DIR에 자동 저장됨)
+    const diff = mod.computeDiff(preLabel, postLabel, options);
+
+    // 추가로 타임스탬프 기반 사본 저장
+    const diffsDir = join(homedir(), '.omc', 'state', 'cx-auto-tokens', 'diffs');
+    mkdirSync(diffsDir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    const outPath = join(diffsDir, `${ts}.json`);
+    writeFileSync(outPath, JSON.stringify(diff, null, 2));
+
+    return diff;
+  } catch { return null; }
+}
+
 export { ensurePipelineTable } from './state.mjs';
 export { PHASES, TERMINAL, ALLOWED, canTransition } from './transitions.mjs';

package/hub/team/native.mjs

@@ -10,17 +10,17 @@ import * as fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-const ROUTE_SCRIPT = "~/.claude/scripts/tfx-route.sh";
-export const SLIM_WRAPPER_SUBAGENT_TYPE = "slim-wrapper";
-/** scout 역할 기본 설정 — read-only 탐색 전용 */
-export const SCOUT_ROLE_CONFIG = {
-  cli: "codex",
-  role: "scientist",
-  mcp_profile: "analyze",
-  maxIterations: 2,
-  readOnly: true,
-};
-const ROUTE_LOG_RE = /\[tfx-route\]/i;
+const ROUTE_SCRIPT = "~/.claude/scripts/tfx-route.sh";
+export const SLIM_WRAPPER_SUBAGENT_TYPE = "slim-wrapper";
+/** scout 역할 기본 설정 — read-only 탐색 전용 */
+export const SCOUT_ROLE_CONFIG = {
+  cli: "codex",
+  role: "scientist",
+  mcp_profile: "analyze",
+  maxIterations: 2,
+  readOnly: true,
+};
+const ROUTE_LOG_RE = /\[tfx-route\]/i;
 const ROUTE_COMMAND_RE = /(?:^|[\s"'`])(?:bash\s+)?(?:[^"'`\s]*\/)?tfx-route\.sh\b/i;
 const ROUTE_PROMPT_RE = /tfx-route\.sh/i;
 const DIRECT_TOOL_BYPASS_RE = /\b(?:Read|Edit|Write)\s*\(/;
@@ -77,6 +77,7 @@ export function buildSlimWrapperAgent(cli, opts = {}) {
  *   usedRoute: boolean,
  *   abnormal: boolean,
  *   reason: string|null,
+ *   slopDetected: boolean,
  * }}
  */
 export function verifySlimWrapperRouteExecution(input = {}) {
@@ -96,6 +97,7 @@ export function verifySlimWrapperRouteExecution(input = {}) {
     : sawDirectToolBypass
       ? "direct_tool_bypass_detected"
       : "missing_tfx_route_evidence";
+  const slopDetected = detectSlop(stdoutText);
 
   return {
     expectedRouteInvocation,
@@ -106,6 +108,7 @@ export function verifySlimWrapperRouteExecution(input = {}) {
     usedRoute,
     abnormal,
     reason,
+    slopDetected,
   };
 }
 
@@ -154,7 +157,7 @@ function getRouteTimeout(role, _mcpProfile) {
  * @param {number} [opts.maxIterations=3] — 피드백 루프 최대 반복 횟수
  * @returns {string} 슬림 래퍼 프롬프트
  */
-export function buildSlimWrapperPrompt(cli, opts = {}) {
+export function buildSlimWrapperPrompt(cli, opts = {}) {
   const {
     subtask,
     role = "executor",
@@ -171,13 +174,13 @@ export function buildSlimWrapperPrompt(cli, opts = {}) {
 
   const routeTimeoutSec = getRouteTimeout(role, mcp_profile);
   const escaped = subtask.replace(/'/g, "'\\''");
-  const pipelineHint = pipelinePhase
-    ? `\n파이프라인 단계: ${pipelinePhase}`
-    : '';
-  const routeEnvPrefix = buildRouteEnvPrefix(agentName, workerIndex, searchTool);
-  const scoutConstraint = (role === "scout" || role === "scientist")
-    ? "\n이 워커는 scout(탐색 전용)이다. 코드를 수정하거나 파일을 생성하지 마라. 기존 코드를 읽고 분석하여 보고만 하라."
-    : "";
+  const pipelineHint = pipelinePhase
+    ? `\n파이프라인 단계: ${pipelinePhase}`
+    : '';
+  const routeEnvPrefix = buildRouteEnvPrefix(agentName, workerIndex, searchTool);
+  const scoutConstraint = (role === "scout" || role === "scientist")
+    ? "\n이 워커는 scout(탐색 전용)이다. 코드를 수정하거나 파일을 생성하지 마라. 기존 코드를 읽고 분석하여 보고만 하라."
+    : "";
 
   // Bash 도구 timeout (모두 600초 이내)
   const launchTimeoutMs = 15000;   // Step 1: fork + job_id 반환
@@ -192,10 +195,10 @@ Step 0 — 시작 보고 (턴 경계 생성):
 TaskUpdate(taskId: "${taskId}", status: "in_progress")
 SendMessage(type: "message", recipient: "${leadName}", content: "작업 시작: ${agentName}", summary: "task ${taskId} started")
 
-[HARD CONSTRAINT] 허용 도구: Bash, TaskUpdate, TaskGet, TaskList, SendMessage만 사용한다.
-Read, Edit, Write, Grep, Glob, Agent, WebSearch, WebFetch 등 다른 모든 도구 사용을 금지한다.
-코드를 직접 읽거나 수정하면 안 된다. 반드시 아래 Bash 명령(tfx-route.sh)을 통해 Codex/Gemini에 위임하라.
-이 규칙을 위반하면 작업 실패로 간주한다.${scoutConstraint}
+[HARD CONSTRAINT] 허용 도구: Bash, TaskUpdate, TaskGet, TaskList, SendMessage만 사용한다.
+Read, Edit, Write, Grep, Glob, Agent, WebSearch, WebFetch 등 다른 모든 도구 사용을 금지한다.
+코드를 직접 읽거나 수정하면 안 된다. 반드시 아래 Bash 명령(tfx-route.sh)을 통해 Codex/Gemini에 위임하라.
+이 규칙을 위반하면 작업 실패로 간주한다.${scoutConstraint}
 
 gemini/codex를 직접 호출하지 마라. 반드시 tfx-route.sh를 거쳐야 한다.
 프롬프트를 파일로 저장하지 마라. tfx-route.sh가 인자로 받는다.
@@ -232,40 +235,40 @@ SendMessage 후 너는 IDLE 상태가 된다. 리드의 응답을 기다려라.
 
 Step 6 — 최종 종료 (반드시 실행):
 TaskUpdate(taskId: "${taskId}", status: "completed", metadata: {result: "success"|"failed"|"fallback", iterations: ITERATION})
-SendMessage(type: "message", recipient: "${leadName}", content: "최종 완료: ${agentName} (ITERATION회 실행)", summary: "task ${taskId} final")
-→ 종료. 이후 추가 도구 호출 금지.`;
-}
-
-/**
- * scout 파견용 프롬프트 생성
- * @param {object} opts
- * @param {string} opts.question — 탐색 질문
- * @param {string} [opts.scope] — 탐색 범위 힌트 (파일 패턴)
- * @param {string} [opts.teamName] — 팀 이름
- * @param {string} [opts.taskId] — 태스크 ID
- * @param {string} [opts.agentName] — 에이전트 이름
- * @param {string} [opts.leadName] — 리드 이름
- * @returns {string} slim wrapper 프롬프트
- */
-export function buildScoutDispatchPrompt(opts = {}) {
-  const { question, scope = "", teamName, taskId, agentName, leadName } = opts;
-  const subtask = scope
-    ? `${question} 탐색 범위: ${scope}`
-    : question;
-  return buildSlimWrapperPrompt("codex", {
-    subtask,
-    role: "scientist",
-    teamName,
-    taskId,
-    agentName,
-    leadName,
-    mcp_profile: "analyze",
-    maxIterations: SCOUT_ROLE_CONFIG.maxIterations,
-  });
-}
-
-/**
- * v3 하이브리드 래퍼 프롬프트 생성
+SendMessage(type: "message", recipient: "${leadName}", content: "최종 완료: ${agentName} (ITERATION회 실행)", summary: "task ${taskId} final")
+→ 종료. 이후 추가 도구 호출 금지.`;
+}
+
+/**
+ * scout 파견용 프롬프트 생성
+ * @param {object} opts
+ * @param {string} opts.question — 탐색 질문
+ * @param {string} [opts.scope] — 탐색 범위 힌트 (파일 패턴)
+ * @param {string} [opts.teamName] — 팀 이름
+ * @param {string} [opts.taskId] — 태스크 ID
+ * @param {string} [opts.agentName] — 에이전트 이름
+ * @param {string} [opts.leadName] — 리드 이름
+ * @returns {string} slim wrapper 프롬프트
+ */
+export function buildScoutDispatchPrompt(opts = {}) {
+  const { question, scope = "", teamName, taskId, agentName, leadName } = opts;
+  const subtask = scope
+    ? `${question} 탐색 범위: ${scope}`
+    : question;
+  return buildSlimWrapperPrompt("codex", {
+    subtask,
+    role: "scientist",
+    teamName,
+    taskId,
+    agentName,
+    leadName,
+    mcp_profile: "analyze",
+    maxIterations: SCOUT_ROLE_CONFIG.maxIterations,
+  });
+}
+
+/**
+ * v3 하이브리드 래퍼 프롬프트 생성
  * psmux pane 기반 비동기 실행 + polling 패턴.
  * Agent가 idle 상태를 유지하여 인터럽트 수신이 가능하다.
  *
@@ -442,6 +445,199 @@ export function formatPollReport(pollResult = {}) {
     : `${completed.length}/${total} 완료`;
 }
 
+// ── Anti-slop 필터링 ────────────────────────────────────────────
+
+/**
+ * 문자열을 정규화: 소문자 변환 + 연속 공백을 단일 공백으로 + trim
+ * @param {string} s
+ * @returns {string}
+ */
+function normalizeText(s) {
+  return String(s || "").toLowerCase().replace(/\s+/g, " ").trim();
+}
+
+/**
+ * 두 문자열의 단어 집합 Jaccard 유사도를 계산한다.
+ * @param {string} a — 정규화된 문자열
+ * @param {string} b — 정규화된 문자열
+ * @returns {number} 0.0–1.0
+ */
+function jaccardSimilarity(a, b) {
+  const setA = new Set(a.split(" ").filter(Boolean));
+  const setB = new Set(b.split(" ").filter(Boolean));
+  if (setA.size === 0 && setB.size === 0) return 1.0;
+  if (setA.size === 0 || setB.size === 0) return 0.0;
+  let intersection = 0;
+  for (const w of setA) {
+    if (setB.has(w)) intersection++;
+  }
+  return intersection / (setA.size + setB.size - intersection);
+}
+
+/**
+ * findings 배열에서 중복을 제거한다.
+ * 정규화 후 description의 Jaccard 유사도 >= 0.8이면 중복으로 판정.
+ * 동일 file+line인 경우도 중복 후보로 취급.
+ *
+ * @param {Array<{description:string, file?:string, line?:number, severity?:string}>} findings
+ * @returns {Array<{description:string, file?:string, line?:number, severity?:string, occurrences:number}>}
+ */
+export function deduplicateFindings(findings) {
+  if (!Array.isArray(findings) || findings.length === 0) return [];
+
+  const groups = []; // [{canonical, items:[]}]
+
+  for (const f of findings) {
+    const norm = normalizeText(f.description);
+    let merged = false;
+    for (const g of groups) {
+      if (jaccardSimilarity(norm, g.norm) >= 0.8) {
+        g.items.push(f);
+        merged = true;
+        break;
+      }
+    }
+    if (!merged) {
+      groups.push({ norm, canonical: f, items: [f] });
+    }
+  }
+
+  return groups.map((g) => ({
+    description: g.canonical.description,
+    ...(g.canonical.file != null ? { file: g.canonical.file } : {}),
+    ...(g.canonical.line != null ? { line: g.canonical.line } : {}),
+    ...(g.canonical.severity != null ? { severity: g.canonical.severity } : {}),
+    occurrences: g.items.length,
+  }));
+}
+
+/**
+ * scout 보고서 원문을 핵심 발견 사항만 추출하여 압축한다.
+ * 파일:라인 + 한줄 요약 형태로 변환하며 최대 ~500토큰(2000자) 이하로 제한.
+ *
+ * @param {string} rawReport — 자유형 텍스트
+ * @returns {{findings: Array<{file:string, line:string, summary:string}>, summary:string, tokenEstimate:number}}
+ */
+export function compressScoutReport(rawReport) {
+  const MAX_CHARS = 2000;
+  const text = String(rawReport || "");
+
+  // 파일:라인 패턴 추출 (path/to/file.ext:123 형태 + 뒤따르는 설명)
+  const fileLineRe = /([a-zA-Z0-9_./-]+\.[a-zA-Z]{1,10}):(\d+)\s*[:\-–—]?\s*(.+)/g;
+  const findings = [];
+  let match;
+  while ((match = fileLineRe.exec(text)) !== null) {
+    findings.push({
+      file: match[1],
+      line: match[2],
+      summary: match[3].trim().slice(0, 120),
+    });
+  }
+
+  // 문장 단위로 핵심 요약 구성
+  const sentences = text
+    .split(/[.\n]/)
+    .map((s) => s.trim())
+    .filter((s) => s.length > 10);
+  let summary = sentences.slice(0, 5).join(". ");
+
+  // 토큰 추정: ~4자 = 1토큰
+  const estimateTokens = (s) => Math.ceil(s.length / 4);
+
+  // findings를 먼저 계산하고, 남은 공간에 맞춰 summary를 자른다
+  const findingsJson = JSON.stringify(findings);
+  const findingsBudget = Math.min(findingsJson.length, Math.floor(MAX_CHARS * 0.3));
+
+  let trimmedFindings = findings;
+  if (findingsJson.length > findingsBudget && findings.length > 0) {
+    trimmedFindings = [];
+    let used = 2; // []
+    for (const f of findings) {
+      const entryLen = JSON.stringify(f).length + 1;
+      if (used + entryLen > findingsBudget) break;
+      trimmedFindings.push(f);
+      used += entryLen;
+    }
+  }
+
+  const summaryBudget = MAX_CHARS - JSON.stringify(trimmedFindings).length;
+  if (summary.length > summaryBudget) {
+    summary = summary.slice(0, Math.max(0, summaryBudget - 3)) + "...";
+  }
+
+  return {
+    findings: trimmedFindings,
+    summary,
+    tokenEstimate: estimateTokens(summary + JSON.stringify(trimmedFindings)),
+  };
+}
+
+/**
+ * 여러 scout 보고서의 발견 사항을 종합하여 가중 신뢰도를 계산한다.
+ * 동일 발견이 여러 scout에서 보고되면 신뢰도가 높다.
+ *
+ * @param {Array<{agentName:string, findings:Array<{description:string}>}>} scoutReports
+ * @returns {Array<{description:string, confidence:number, reporters:string[]}>}
+ */
+export function weightedConsensus(scoutReports) {
+  if (!Array.isArray(scoutReports) || scoutReports.length === 0) return [];
+
+  const totalScouts = scoutReports.length;
+  // {normDesc -> {description, reporters: Set}}
+  const consensusMap = new Map();
+
+  for (const report of scoutReports) {
+    const agent = String(report.agentName || "unknown");
+    const findings = Array.isArray(report.findings) ? report.findings : [];
+    for (const f of findings) {
+      const norm = normalizeText(f.description);
+      let matched = false;
+      for (const [key, entry] of consensusMap) {
+        if (jaccardSimilarity(norm, key) >= 0.8) {
+          entry.reporters.add(agent);
+          matched = true;
+          break;
+        }
+      }
+      if (!matched) {
+        consensusMap.set(norm, {
+          description: f.description,
+          reporters: new Set([agent]),
+        });
+      }
+    }
+  }
+
+  return Array.from(consensusMap.values()).map((entry) => ({
+    description: entry.description,
+    confidence: Math.round((entry.reporters.size / totalScouts) * 100) / 100,
+    reporters: Array.from(entry.reporters),
+  }));
+}
+
+// ── Slop detection helper ───────────────────────────────────────
+
+const SLOP_REPEAT_THRESHOLD = 3;
+
+/**
+ * 텍스트에서 동일 패턴이 SLOP_REPEAT_THRESHOLD회 이상 반복되는지 판정한다.
+ * 줄 단위로 정규화하여 비교.
+ * @param {string} text
+ * @returns {boolean}
+ */
+function detectSlop(text) {
+  const lines = String(text || "")
+    .split("\n")
+    .map(normalizeText)
+    .filter((l) => l.length > 15); // 너무 짧은 줄은 무시
+  const counts = new Map();
+  for (const line of lines) {
+    counts.set(line, (counts.get(line) || 0) + 1);
+    if (counts.get(line) >= SLOP_REPEAT_THRESHOLD) return true;
+  }
+  return false;
+}
+
 /**
  * 팀 이름 생성 (타임스탬프 기반)
  * @returns {string}

package/hub/team/routing.mjs

@@ -8,17 +8,20 @@
  *   strategy: "quick_single" | "thorough_single" | "quick_team" | "thorough_team" | "batch_single",
  *   reason: string,
  *   dag_width: number,
- *   max_complexity: string
+ *   max_complexity: string,
+ *   dagContext: { dag_width: number, levels: Record<number, string[]>, edges: Array<{from:string, to:string}>, max_complexity: string, taskResults: Record<string, *> }
  * }}
  */
 export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
   const N = subtasks.length;
   if (N === 0) {
-    return { strategy: 'quick_single', reason: 'empty_subtasks', dag_width: 0, max_complexity: 'S' };
+    const dagContext = { dag_width: 0, levels: {}, edges: [], max_complexity: 'S', taskResults: {} };
+    return { strategy: 'quick_single', reason: 'empty_subtasks', dag_width: 0, max_complexity: 'S', dagContext };
   }
 
-  const dag_width = computeDagWidth(subtasks, graph_type);
+  const { width: dag_width, levels, edges } = computeDagInfo(subtasks, graph_type);
   const max_complexity = getMaxComplexity(subtasks);
+  const dagContext = { dag_width, levels, edges, max_complexity, taskResults: {} };
   const isHighComplexity = ['L', 'XL'].includes(max_complexity);
   const allSameAgent = new Set(subtasks.map((s) => s.agent)).size === 1;
   const allSmall = subtasks.every((s) => normalizeComplexity(s.complexity) === 'S');
@@ -31,6 +34,7 @@ export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
         reason: 'single_high_complexity',
         dag_width,
         max_complexity,
+        dagContext,
       };
     }
     return {
@@ -38,6 +42,7 @@ export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
       reason: 'single_low_complexity',
       dag_width,
       max_complexity,
+      dagContext,
     };
   }
 
@@ -49,6 +54,7 @@ export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
         reason: 'sequential_chain',
         dag_width,
         max_complexity,
+        dagContext,
       };
     }
     return {
@@ -56,6 +62,7 @@ export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
       reason: 'sequential_chain',
       dag_width,
       max_complexity,
+      dagContext,
     };
   }
 
@@ -66,6 +73,7 @@ export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
       reason: 'same_agent_small_batch',
       dag_width,
       max_complexity,
+      dagContext,
     };
   }
 
@@ -76,6 +84,7 @@ export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
       reason: 'parallel_high_complexity',
       dag_width,
       max_complexity,
+      dagContext,
     };
   }
   return {
@@ -83,31 +92,43 @@ export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
     reason: 'parallel_low_complexity',
     dag_width,
     max_complexity,
+    dagContext,
   };
 }
 
 /**
- * DAG 폭 계산 - 레벨별 최대 병렬 태스크 수
+ * DAG 정보 계산 — 레벨별 태스크 배열, 간선, 최대 폭
  * @param {Array<{id:string, depends_on?:string[]}>} subtasks
  * @param {string} graph_type
- * @returns {number}
+ * @returns {{ width: number, levels: Record<number, string[]>, edges: Array<{from:string, to:string}> }}
  */
-function computeDagWidth(subtasks, graph_type) {
-  if (graph_type === 'SEQUENTIAL') return 1;
-  if (graph_type === 'INDEPENDENT') return subtasks.length;
+function computeDagInfo(subtasks, graph_type) {
+  if (graph_type === 'SEQUENTIAL') {
+    const levels = {};
+    const edges = [];
+    subtasks.forEach((t, i) => {
+      levels[i] = [t.id];
+      if (i > 0) edges.push({ from: subtasks[i - 1].id, to: t.id });
+    });
+    return { width: 1, levels, edges };
+  }
+  if (graph_type === 'INDEPENDENT') {
+    const levels = { 0: subtasks.map((t) => t.id) };
+    return { width: subtasks.length, levels, edges: [] };
+  }
 
   // DAG: 레벨별 계산 (순환 의존 방어)
-  const levels = {};
+  const taskLevels = {};
   const visiting = new Set();
 
   function getLevel(task) {
-    if (levels[task.id] !== undefined) return levels[task.id];
+    if (taskLevels[task.id] !== undefined) return taskLevels[task.id];
     if (visiting.has(task.id)) {
-      levels[task.id] = 0; // 순환 끊기
+      taskLevels[task.id] = 0; // 순환 끊기
       return 0;
     }
     if (!task.depends_on || task.depends_on.length === 0) {
-      levels[task.id] = 0;
+      taskLevels[task.id] = 0;
       return 0;
     }
     visiting.add(task.id);
@@ -116,17 +137,65 @@ function computeDagWidth(subtasks, graph_type) {
       return dep ? getLevel(dep) : 0;
     });
     visiting.delete(task.id);
-    levels[task.id] = Math.max(...depLevels) + 1;
-    return levels[task.id];
+    taskLevels[task.id] = Math.max(...depLevels) + 1;
+    return taskLevels[task.id];
   }
 
   subtasks.forEach(getLevel);
 
-  const levelCounts = {};
-  for (const level of Object.values(levels)) {
-    levelCounts[level] = (levelCounts[level] || 0) + 1;
+  // 레벨별 태스크 그룹핑
+  const levels = {};
+  for (const [id, level] of Object.entries(taskLevels)) {
+    if (!levels[level]) levels[level] = [];
+    levels[level].push(id);
+  }
+
+  // 간선 수집
+  const edges = [];
+  for (const task of subtasks) {
+    if (task.depends_on) {
+      for (const depId of task.depends_on) {
+        edges.push({ from: depId, to: task.id });
+      }
+    }
   }
-  return Math.max(...Object.values(levelCounts), 1);
+
+  const width = Math.max(...Object.values(levels).map((arr) => arr.length), 1);
+  return { width, levels, edges };
+}
+
+/**
+ * 선행 태스크의 결과를 dagContext.edges에서 조회하여 반환
+ * @param {string} taskId - 조회 대상 태스크 ID
+ * @param {{ dagContext?: { edges: Array<{from:string, to:string}>, taskResults: Record<string, *> } }} pipelineState
+ * @returns {Record<string, *>} 선행 태스크 ID → 결과 매핑
+ */
+export function getUpstreamResults(taskId, pipelineState) {
+  const ctx = pipelineState?.dagContext;
+  if (!ctx) return {};
+  const upstreamIds = ctx.edges.filter((e) => e.to === taskId).map((e) => e.from);
+  const results = {};
+  for (const id of upstreamIds) {
+    if (id in (ctx.taskResults || {})) {
+      results[id] = ctx.taskResults[id];
+    }
+  }
+  return results;
+}
+
+/**
+ * 태스크 완료 시 결과를 dagContext에 기록
+ * @param {string} taskId - 완료된 태스크 ID
+ * @param {*} result - 태스크 결과
+ * @param {{ dagContext?: { taskResults: Record<string, *> } }} pipelineState
+ * @returns {boolean} 기록 성공 여부
+ */
+export function updateTaskResult(taskId, result, pipelineState) {
+  const ctx = pipelineState?.dagContext;
+  if (!ctx) return false;
+  if (!ctx.taskResults) ctx.taskResults = {};
+  ctx.taskResults[taskId] = result;
+  return true;
 }
 
 /**

package/hud/hud-qos-status.mjs

@@ -1410,6 +1410,17 @@ function scanGeminiSessionTokens() {
 // ============================================================================
 // 라인 렌더러
 // ============================================================================
+// 최근 벤치마크 diff 파일 읽기 (cx-auto-tokens/diffs/ 에서 최신 1개)
+function readLatestBenchmarkDiff() {
+  const diffsDir = join(homedir(), ".omc", "state", "cx-auto-tokens", "diffs");
+  if (!existsSync(diffsDir)) return null;
+  try {
+    const files = readdirSync(diffsDir).filter(f => f.endsWith(".json")).sort().reverse();
+    if (files.length === 0) return null;
+    return readJson(join(diffsDir, files[0]), null);
+  } catch { return null; }
+}
+
 // 토큰 절약액 누적치 읽기 (tfx-auto token tracker)
 function readTokenSavings() {
   const savingsPath = join(homedir(), ".omc", "state", "tfx-auto-tokens", "savings-total.json");
@@ -1429,6 +1440,29 @@ function formatSavings(dollars) {
   return `$${dollars.toFixed(2)}`;
 }
 
+/**
+ * 파이프라인 벤치마크 diff 결과를 HUD 요약 문자열로 포맷
+ * @param {object} diff - computeDiff() 반환 결과
+ * @returns {string} 토큰 소비 요약 (input/output, 비용, 절감률)
+ */
+function formatTokenSummary(diff) {
+  if (!diff?.delta?.total || !diff?.savings) return "";
+  const t = diff.delta.total;
+  const s = diff.savings;
+
+  const inputStr = formatTokenCount(t.input);
+  const outputStr = formatTokenCount(t.output);
+  const actualStr = formatSavings(s.actualCost);
+  const claudeStr = formatSavings(s.claudeCost);
+  const savedPct = s.claudeCost > 0
+    ? Math.round((s.saved / s.claudeCost) * 100)
+    : 0;
+
+  return `${dim("tok:")}${inputStr}${dim("in")} ${outputStr}${dim("out")} ` +
+    `${dim("cost:")}${actualStr} ` +
+    `${dim("sv:")}${green(formatSavings(s.saved))}${dim("(")}${savedPct}%${dim(")")}`;
+}
+
 // sv 퍼센트 포맷 (1000+ → k 표기, 5자 고정폭)
 const SV_CELL_WIDTH = 5;
 function formatSvPct(value) {
@@ -1800,6 +1834,15 @@ async function main() {
   const teamRow = getTeamRow();
   if (teamRow) rows.push(teamRow);
 
+  // 최근 벤치마크 diff → 토큰 요약 행 추가
+  const latestDiff = readLatestBenchmarkDiff();
+  if (latestDiff) {
+    const summary = formatTokenSummary(latestDiff);
+    if (summary) {
+      rows.push({ prefix: `${dim("$")}:`, left: summary, right: "" });
+    }
+  }
+
   // 비활성 프로바이더 dim 처리: 데이터 없으면 전체 줄 dim
   const codexActive = codexBuckets != null;
   const geminiActive = (geminiSession?.total || 0) > 0 || geminiBucket != null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "5.0.3",
+  "version": "5.1.1",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "type": "module",
   "bin": {

package/scripts/tfx-route.sh

@@ -637,23 +637,14 @@ route_agent() {
       CLI_ARGS="-m gemini-3-flash-preview -y --prompt"
       CLI_EFFORT="flash"; DEFAULT_TIMEOUT=900; RUN_MODE="bg"; OPUS_OVERSIGHT="false" ;;
 
-    # ─── 탐색/검증/테스트 (Codex 우선, claude-native fallback은 apply_cli_mode auto에서) ───
-    explore)
-      CLI_TYPE="codex"; CLI_CMD="codex"
-      CLI_ARGS="exec --profile fast ${codex_base}"
-      CLI_EFFORT="fast"; DEFAULT_TIMEOUT=600; RUN_MODE="fg"; OPUS_OVERSIGHT="false" ;;
-    verifier)
-      CLI_TYPE="codex"; CLI_CMD="codex"
-      CLI_ARGS="exec --profile thorough ${codex_base} review"
-      CLI_EFFORT="thorough"; DEFAULT_TIMEOUT=1200; RUN_MODE="fg"; OPUS_OVERSIGHT="false" ;;
-    test-engineer)
-      CLI_TYPE="codex"; CLI_CMD="codex"
-      CLI_ARGS="exec ${codex_base}"
-      CLI_EFFORT="high"; DEFAULT_TIMEOUT=1200; RUN_MODE="bg"; OPUS_OVERSIGHT="false" ;;
-    qa-tester)
-      CLI_TYPE="codex"; CLI_CMD="codex"
-      CLI_ARGS="exec --profile thorough ${codex_base} review"
-      CLI_EFFORT="thorough"; DEFAULT_TIMEOUT=1200; RUN_MODE="bg"; OPUS_OVERSIGHT="false" ;;
+    # ─── 탐색/검증/테스트 (Claude-native 우선, TFX_NO_CLAUDE_NATIVE=1일 때만 Codex 리매핑) ───
+    explore|verifier|test-engineer|qa-tester)
+      CLI_TYPE="claude-native"; CLI_CMD=""; CLI_ARGS=""
+      CLI_EFFORT="n/a"; DEFAULT_TIMEOUT=600; RUN_MODE="fg"; OPUS_OVERSIGHT="false"
+      case "$agent" in
+        test-engineer|qa-tester) DEFAULT_TIMEOUT=1200; RUN_MODE="bg" ;;
+      esac
+      ;;
 
     # ─── 경량 ───
     spark)

package/scripts/token-snapshot.mjs

@@ -12,6 +12,7 @@
 import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync, statSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
 
 const HOME = homedir();
 const STATE_DIR = join(HOME, ".omc", "state", "cx-auto-tokens");
@@ -519,7 +520,18 @@ function generateReport(sessionId) {
   return reportData;
 }
 
-// ── CLI 핸들러 ──
+// ── Named exports (파이프라인 벤치마크 훅용) ──
+export { takeSnapshot, computeDiff, estimateSavings, formatTokenCount, formatCost, DIFFS_DIR, STATE_DIR };
+
+// ── CLI 핸들러 (직접 실행 시에만) ──
+const __filename = fileURLToPath(import.meta.url);
+const isDirectRun = process.argv[1] && join(dirname(process.argv[1])) === dirname(__filename)
+  && process.argv[1].endsWith("token-snapshot.mjs");
+
+if (!isDirectRun) {
+  // imported as module — skip CLI
+} else {
+
 const [,, command, ...args] = process.argv;
 
 switch (command) {
@@ -559,3 +571,5 @@ switch (command) {
   node token-snapshot.mjs report <session-id>  종합 보고서 생성
     (session-id 대신 "all"로 전체 보고서)`);
 }
+
+} // end isDirectRun guard