triflux 8.12.5 → 9.1.0

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "triflux",
       "description": "CLI-first multi-model orchestrator for Claude Code. Routes tasks to Codex, Gemini, and Claude CLIs with automatic triage (Sonnet classification + Opus decomposition), DAG-based parallel execution, and cost-optimized routing. Includes 16 skills, HUD status bar, and shell-based CLI routing wrapper.",
-      "version": "7.1.4",
+      "version": "9.0.0",
       "author": {
         "name": "tellang"
       },
@@ -27,5 +27,5 @@
       ]
     }
   ],
-  "version": "7.1.4"
+  "version": "9.0.0"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "8.11.2",
+  "version": "9.0.0",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "author": {
     "name": "tellang"

package/README.ko.md

@@ -10,7 +10,7 @@
 
 <p align="center">
   <strong>Consensus Intelligence 기반 Tri-CLI 오케스트레이션</strong><br>
-  <em>Claude + Codex + Gemini — 3자 토론, Anti-Herding 검증, Deep/Light 변형을 갖춘 35개 스킬.</em>
+  <em>Claude + Codex + Gemini — 자연어 라우팅, 교차 모델 리뷰, Deep/Light 변형을 갖춘 38개 스킬.</em>
 </p>
 
 <p align="center">
@@ -27,7 +27,7 @@
 <p align="center">
   <a href="#빠른-시작">빠른 시작</a> ·
   <a href="#tri-cli-합의-엔진">Tri-CLI 합의 엔진</a> ·
-  <a href="#35개-스킬">35개 스킬</a> ·
+  <a href="#38개-스킬">38개 스킬</a> ·
   <a href="#아키텍처">아키텍처</a> ·
   <a href="#deep-vs-light">Deep vs Light</a> ·
   <a href="#보안">보안</a>
@@ -80,21 +80,26 @@ tfx setup
 
 ---
 
-## v8의 새로운 기능
+## v9의 새로운 기능
 
-**triflux v8**은 **Tri-CLI Consensus Intelligence**를 도입합니다. Claude, Codex, Gemini가 각각 독립적으로 분석한 뒤, 구조화된 토론을 거쳐 교차 검증하는 근본적으로 새로운 접근 방식입니다. 모든 Deep 스킬은 Anti-Herding(편향 오염 방지)과 Consensus Gate를 통한 출력 보장을 제공합니다.
+**triflux v9**은 **하네스 네이티브 인텔리전스**를 도입합니다. 자연어로 말하면 적절한 스킬로 자동 라우팅되고, 교차 모델 리뷰로 동일 모델의 self-approve를 차단합니다.
 
-### 주요 특징
+### v9 주요 특징
+
+- **자연어 라우팅** — "리뷰해줘"라고 말하면 `/tfx-review`가 자동 호출. "제대로/꼼꼼히" 수정자로 Deep 변형 자동 에스컬레이션
+- **교차 모델 리뷰** — Claude가 작성하면 Codex가 리뷰, Codex가 작성하면 Claude가 리뷰. 동일 모델 self-approve 차단. 커밋 전 미검증 파일 nudge
+- **맥락 격리** — 현재 맥락과 무관한 요청을 감지하면 별도 psmux 세션으로 분리 제안
+- **38개 스킬** — Light 14개 + Deep 10개 + Infrastructure 14개, 10개 도메인으로 구성
+- **Codex Swarm 강화** — PowerShell `.ps1` 런처, 프로파일 기반 실행, `/merge-worktree`로 결과 자동 수집
+- **스킬 메타데이터** — 모든 스킬에 래퍼/인프라/Light-Deep 관계 표기. 트리거 충돌 해소
+
+### v8 기반 (계속 유지)
 
-- **35개 스킬** — Light 11개 + Deep 10개 + Infrastructure 12개, 9개 도메인으로 구성
 - **Tri-Debate Engine** — 3개 CLI가 독립 분석 후 Anti-Herding, 교차 검증, 합의 점수 산출
 - **Deep/Light 변형** — 모든 기능에 토큰 효율적인 Light 모드와 정밀한 Deep 모드를 제공
-- **Consensus Gate** — Deep 스킬은 3개 CLI 중 2개 이상의 동의를 요구하며, 학습된 가중치로 CLI 신뢰도를 추적
-- **Anti-Herding** — 1라운드는 상호 참조 없이 병렬 실행하여 편향 오염을 원천 차단
-- **Expert Panel** — `tfx-panel`을 통한 가상 전문가 시뮬레이션 (Fowler, Newman, Porter 등)
-- **94% 토큰 절감** — `tfx-index`가 58K 토큰 분량의 파일 읽기를 3KB 프로젝트 맵으로 대체
-- **Persistence Loop** — `tfx-persist`(정식 이름, 3자 검증), `/tfx-ralph`(호환 별칭), `tfx-sisyphus`(자동 라우팅)가 검증 완료까지 반복 실행
-- **Hub IPC** — Named Pipe 및 HTTP MCP 브리지를 활용한 초고속 상주형 Hub 서버
+- **Consensus Gate** — Deep 스킬은 3개 CLI 중 2개 이상의 동의 요구
+- **Expert Panel** — `tfx-panel`을 통한 가상 전문가 시뮬레이션
+- **Hub IPC** — Named Pipe 및 HTTP MCP 브리지를 활용한 상주형 Hub 서버
 - **psmux / Windows 네이티브** — `tmux`(WSL)와 `psmux`(Windows Terminal) 하이브리드 지원
 
 ---
@@ -128,7 +133,7 @@ Phase 3: Resolution (합의율 < 70%일 경우)
 
 ---
 
-## 35개 스킬
+## 38개 스킬
 
 ### 리서치
 

package/README.md

@@ -10,7 +10,7 @@
 
 <p align="center">
   <strong>Tri-CLI Orchestration with Consensus Intelligence</strong><br>
-  <em>Claude + Codex + Gemini — 3-party debate, anti-herding verification, and 35 skills with Deep/Light variants.</em>
+  <em>Claude + Codex + Gemini — natural language routing, cross-model review, 38 skills with Deep/Light variants.</em>
 </p>
 
 <p align="center">
@@ -27,7 +27,7 @@
 <p align="center">
   <a href="#quick-start">Quick Start</a> ·
   <a href="#tri-cli-consensus">Tri-CLI Consensus</a> ·
-  <a href="#35-skills">35 Skills</a> ·
+  <a href="#38-skills">38 Skills</a> ·
   <a href="#architecture">Architecture</a> ·
   <a href="#deep-vs-light">Deep vs Light</a> ·
   <a href="#security">Security</a>
@@ -80,21 +80,26 @@ tfx setup
 
 ---
 
-## What's New in v8
+## What's New in v9
 
-**triflux v8** introduces **Tri-CLI Consensus Intelligence** — a fundamentally new approach where Claude, Codex, and Gemini independently analyze, then cross-validate through structured debate. Every Deep skill guarantees anti-herding (no bias contamination) and consensus-gated output.
+**triflux v9** introduces **Harness-Native Intelligence** — speak naturally, and triflux routes to the right skill automatically. Cross-model review ensures no model approves its own work.
 
-### Highlights
+### v9 Highlights
+
+- **Natural Language Routing** — Say "review this" or "리뷰해줘" instead of memorizing `/tfx-review`. Depth modifiers ("thoroughly", "제대로") auto-escalate to Deep variants
+- **Cross-Model Review** — Claude writes → Codex reviews. Codex writes → Claude reviews. Same-model self-approve is blocked. Pre-commit nudge for unreviewed files
+- **Context Isolation** — Off-topic requests auto-detected; spawns a clean psmux session so your main context stays focused
+- **38 Skills** — 14 Light + 10 Deep + 14 Infrastructure, organized across 10 domains
+- **Codex Swarm Hardened** — PowerShell `.ps1` launchers, profile-based execution (no `--dangerously` flag), `/merge-worktree` auto-invocation for result collection
+- **Skill Metadata** — Every skill labeled: wrapper/infrastructure/Light-Deep pairs. Trigger conflicts resolved
+
+### v8 Foundations (carried forward)
 
-- **35 Skills** — 11 Light + 10 Deep + 12 Infrastructure, organized across 9 domains
 - **Tri-Debate Engine** — 3-CLI independent analysis with anti-herding, cross-validation, and consensus scoring
 - **Deep/Light Variants** — Every capability has a token-efficient Light mode and a thorough Deep mode
 - **Consensus Gate** — Deep skills require 2/3+ CLI agreement; learned weights track CLI reliability over time
-- **Anti-Herding** — Round 1 runs in parallel with zero cross-visibility to prevent bias contamination
-- **Expert Panel** — Virtual expert simulation (Fowler, Newman, Porter, etc.) via `tfx-panel`
-- **94% Token Reduction** — `tfx-index` creates a 3KB project map replacing 58K tokens of file reads
-- **Persistence Loops** — `tfx-persist` (canonical, 3-party verified), `/tfx-ralph` (compat alias), and `tfx-sisyphus` (auto-routing) run until verified complete
-- **Hub IPC** — Lightning-fast resident Hub server with Named Pipe & HTTP MCP bridge
+- **Expert Panel** — Virtual expert simulation via `tfx-panel`
+- **Hub IPC** — Resident Hub server with Named Pipe & HTTP MCP bridge
 - **psmux / Windows Native** — Hybrid support for `tmux` (WSL) and `psmux` (Windows Terminal)
 
 ---
@@ -128,7 +133,7 @@ Phase 3: Resolution (if consensus < 70%)
 
 ---
 
-## 35 Skills
+## 38 Skills
 
 ### Research
 

package/package.json

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

package/scripts/cross-review-gate.mjs

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+
+const SESSION_TTL_SEC = 30 * 60;
+const STATE_REL_PATH = join(".omc", "state", "cross-review.json");
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let raw = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on("end", () => resolve(raw));
+    process.stdin.on("error", () => resolve(""));
+  });
+}
+
+function parseJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function nowSec() {
+  return Math.floor(Date.now() / 1000);
+}
+
+function resolveBaseDir(payload) {
+  if (typeof payload?.cwd === "string" && payload.cwd.trim()) return payload.cwd;
+  if (typeof payload?.directory === "string" && payload.directory.trim()) return payload.directory;
+  return process.cwd();
+}
+
+function expectedReviewer(author) {
+  if (author === "claude") return "codex";
+  if (author === "codex") return "claude";
+  if (author === "gemini") return "claude";
+  return "";
+}
+
+function shouldTrackPath(filePath) {
+  if (typeof filePath !== "string" || !filePath.trim()) return false;
+
+  const lower = filePath.toLowerCase();
+  if (lower.startsWith(".omc/") || lower.startsWith(".claude/")) return false;
+  if (lower === "package-lock.json" || lower.endsWith("/package-lock.json")) return false;
+  if (/\.(md|lock|yml|yaml)$/i.test(lower)) return false;
+  return true;
+}
+
+function loadState(statePath) {
+  if (!existsSync(statePath)) return null;
+
+  try {
+    const state = JSON.parse(readFileSync(statePath, "utf8"));
+    const startedAt = Number(state?.session_start || 0);
+    const expired = !startedAt || nowSec() - startedAt > SESSION_TTL_SEC;
+    if (expired) {
+      try {
+        unlinkSync(statePath);
+      } catch {}
+      return null;
+    }
+    return state;
+  } catch {
+    return null;
+  }
+}
+
+function isGitCommitCommand(command) {
+  if (typeof command !== "string") return false;
+  return /\bgit\s+commit\b/i.test(command);
+}
+
+function nudge(message) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      additionalContext: message,
+    },
+  }));
+  process.exit(0);
+}
+
+function deny(message) {
+  process.stderr.write(message);
+  process.exit(2);
+}
+
+function summarizePending(entries) {
+  return entries
+    .map((item) => {
+      const reviewer = item.expectedReviewer || "cross-reviewer";
+      return `  * ${item.path} (author=${item.author}, reviewer=${reviewer})`;
+    })
+    .join("\n");
+}
+
+async function main() {
+  if (process.env.TFX_SKIP_CROSS_REVIEW === "1") {
+    process.exit(0);
+  }
+
+  const raw = await readStdin();
+  if (!raw.trim()) process.exit(0);
+
+  const payload = parseJson(raw);
+  if (!payload) process.exit(0);
+
+  const toolName = payload.tool_name || "";
+  const toolInput = payload.tool_input || {};
+
+  if (toolName !== "Bash") process.exit(0);
+  if (!isGitCommitCommand(toolInput.command || "")) process.exit(0);
+
+  // cwd 전파: tracker와 동일한 resolveBaseDir 사용
+  const baseDir = resolveBaseDir(payload);
+  const statePath = join(baseDir, STATE_REL_PATH);
+
+  const state = loadState(statePath);
+  if (!state || !state.files || typeof state.files !== "object") process.exit(0);
+
+  const pending = [];
+  const selfApproved = [];
+
+  for (const [path, info] of Object.entries(state.files)) {
+    if (!shouldTrackPath(path)) continue;
+    const meta = info && typeof info === "object" ? info : {};
+    const author = String(meta.author || "").toLowerCase();
+    const reviewer = String(meta.reviewer || "").toLowerCase();
+    const reviewed = meta.reviewed === true;
+    const requiredReviewer = expectedReviewer(author);
+
+    // tracker가 설정한 self_approved 플래그 명시적 체크
+    if (meta.self_approved === true) {
+      selfApproved.push({ path, author, reviewer: meta.reviewer || author, expectedReviewer: requiredReviewer });
+      continue;
+    }
+
+    if (reviewed && reviewer && reviewer === author) {
+      selfApproved.push({ path, author, reviewer, expectedReviewer: requiredReviewer });
+      continue;
+    }
+
+    if (reviewed && requiredReviewer && reviewer && reviewer !== requiredReviewer) {
+      selfApproved.push({ path, author, reviewer, expectedReviewer: requiredReviewer });
+      continue;
+    }
+
+    if (!reviewed) {
+      pending.push({ path, author, expectedReviewer: requiredReviewer });
+    }
+  }
+
+  if (selfApproved.length > 0) {
+    const lines = selfApproved
+      .map((item) => `  * ${item.path} (author=${item.author}, reviewer=${item.reviewer}, required=${item.expectedReviewer || "n/a"})`)
+      .join("\n");
+    deny(
+      `[cross-review] self-approve 차단: 동일/비허용 reviewer가 감지되었습니다.\n${lines}\n` +
+      "규칙: author=claude -> reviewer=codex, author=codex -> reviewer=claude",
+    );
+  }
+
+  if (pending.length > 0) {
+    nudge(
+      `[cross-review] git commit 전에 교차 검증이 필요합니다.\n${summarizePending(pending)}\n` +
+      "규칙: author=claude -> reviewer=codex, author=codex -> reviewer=claude",
+    );
+  }
+
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0));

package/scripts/cross-review-tracker.mjs

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
+
+const SESSION_TTL_SEC = 30 * 60;
+const STATE_REL_PATH = join(".omc", "state", "cross-review.json");
+const EXCLUDED_FILE_PATTERN = /\.(md|lock|yml|yaml)$/i;
+
+function nowSec() {
+  return Math.floor(Date.now() / 1000);
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let raw = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on("end", () => resolve(raw));
+    process.stdin.on("error", () => resolve(""));
+  });
+}
+
+function parseJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function resolveBaseDir(payload) {
+  if (typeof payload?.cwd === "string" && payload.cwd.trim()) return payload.cwd;
+  if (typeof payload?.directory === "string" && payload.directory.trim()) return payload.directory;
+  return process.cwd();
+}
+
+function resolveStatePath(baseDir) {
+  return join(baseDir, STATE_REL_PATH);
+}
+
+function createEmptyState() {
+  return {
+    files: {},
+    session_start: nowSec(),
+  };
+}
+
+function loadState(statePath) {
+  if (!existsSync(statePath)) return createEmptyState();
+
+  try {
+    const parsed = JSON.parse(readFileSync(statePath, "utf8"));
+    const sessionStart = Number(parsed?.session_start || 0);
+    const expired = !sessionStart || nowSec() - sessionStart > SESSION_TTL_SEC;
+    if (expired) {
+      try {
+        unlinkSync(statePath);
+      } catch {}
+      return createEmptyState();
+    }
+
+    return {
+      files: parsed?.files && typeof parsed.files === "object" ? parsed.files : {},
+      session_start: sessionStart,
+    };
+  } catch {
+    return createEmptyState();
+  }
+}
+
+function saveState(statePath, state) {
+  mkdirSync(dirname(statePath), { recursive: true });
+  writeFileSync(statePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+
+function normalizePath(filePath, baseDir) {
+  if (typeof filePath !== "string" || !filePath.trim()) return "";
+
+  const raw = filePath.trim();
+  let normalized = raw;
+
+  if (isAbsolute(raw)) {
+    const relPath = relative(baseDir, raw);
+    if (relPath.startsWith("..")) return "";
+    normalized = relPath;
+  }
+
+  return normalized.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+function shouldTrackPath(filePath) {
+  if (!filePath) return false;
+  const lower = filePath.toLowerCase();
+
+  if (lower.startsWith(".omc/") || lower.startsWith(".claude/")) return false;
+  if (lower === "package-lock.json" || lower.endsWith("/package-lock.json")) return false;
+  if (EXCLUDED_FILE_PATTERN.test(lower)) return false;
+  return true;
+}
+
+function extractFilePath(toolInput) {
+  if (!toolInput || typeof toolInput !== "object") return "";
+  const candidate = toolInput.file_path ?? toolInput.path ?? toolInput.filePath ?? "";
+  return typeof candidate === "string" ? candidate : "";
+}
+
+function extractCandidatePaths(payload, baseDir) {
+  const candidates = new Set();
+
+  const looksLikePath = (value) => {
+    if (typeof value !== "string") return false;
+    const trimmed = value.trim();
+    if (!trimmed || /\s/.test(trimmed)) return false;
+    if (trimmed.length > 260) return false;
+    if (!trimmed.includes(".") && !trimmed.includes("/") && !trimmed.includes("\\")) return false;
+    return /^[./\\A-Za-z0-9_-]/.test(trimmed);
+  };
+
+  const addPath = (value) => {
+    if (!looksLikePath(value)) return;
+    const normalized = normalizePath(value, baseDir);
+    if (shouldTrackPath(normalized)) candidates.add(normalized);
+  };
+
+  const scanValue = (value, depth = 0) => {
+    if (depth > 3 || value == null) return;
+    if (typeof value === "string") {
+      addPath(value);
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) scanValue(item, depth + 1);
+      return;
+    }
+    if (typeof value !== "object") return;
+
+    for (const [key, child] of Object.entries(value)) {
+      const keyLower = key.toLowerCase();
+      if (keyLower.includes("file") || keyLower.includes("path")) {
+        scanValue(child, depth + 1);
+      }
+    }
+  };
+
+  addPath(extractFilePath(payload?.tool_input));
+
+  scanValue(payload?.tool_response);
+  scanValue(payload?.tool_output);
+  scanValue(payload?.result);
+  scanValue(payload?.output);
+
+  return [...candidates];
+}
+
+function collectStrings(value, out = [], depth = 0) {
+  if (depth > 4) return out;
+  if (typeof value === "string") {
+    out.push(value);
+    return out;
+  }
+  if (!value || typeof value !== "object") return out;
+  if (Array.isArray(value)) {
+    for (const item of value) collectStrings(item, out, depth + 1);
+    return out;
+  }
+
+  for (const key of Object.keys(value)) {
+    collectStrings(value[key], out, depth + 1);
+  }
+  return out;
+}
+
+function detectCliActor(payload) {
+  const lines = collectStrings(payload).join("\n");
+  const match = lines.match(/\bcli\s*[:=]\s*(claude|codex|gemini)\b/i);
+  return match ? match[1].toLowerCase() : "";
+}
+
+function detectAuthor(payload) {
+  const actor = detectCliActor(payload);
+  if (actor) return actor;
+  return "claude";
+}
+
+function expectedReviewer(author) {
+  if (author === "claude") return "codex";
+  if (author === "codex") return "claude";
+  if (author === "gemini") return "claude";
+  return "";
+}
+
+function applyReviewer(state, reviewer, ts) {
+  for (const [filePath, meta] of Object.entries(state.files)) {
+    if (!meta || typeof meta !== "object") continue;
+    if (!shouldTrackPath(filePath)) continue;
+
+    const author = String(meta.author || "").toLowerCase();
+    const expected = expectedReviewer(author);
+
+    if (expected && reviewer === expected) {
+      meta.reviewed = true;
+      meta.reviewer = reviewer;
+      meta.reviewed_ts = ts;
+      delete meta.self_approved;
+      continue;
+    }
+
+    if (reviewer === author) {
+      meta.reviewed = false;
+      meta.reviewer = reviewer;
+      meta.reviewed_ts = ts;
+      meta.self_approved = true;
+    }
+  }
+}
+
+async function main() {
+  if (process.env.TFX_SKIP_CROSS_REVIEW === "1") {
+    process.exit(0);
+  }
+
+  const raw = await readStdin();
+  if (!raw.trim()) {
+    process.exit(0);
+  }
+
+  const payload = parseJson(raw);
+  if (!payload) {
+    process.exit(0);
+  }
+
+  const baseDir = resolveBaseDir(payload);
+  const statePath = resolveStatePath(baseDir);
+  const state = loadState(statePath);
+  const toolName = payload.tool_name || "";
+  const ts = nowSec();
+  let changed = false;
+
+  if (toolName === "Edit" || toolName === "Write") {
+    const toolInput = payload.tool_input || {};
+    const normalizedPath = normalizePath(extractFilePath(toolInput), baseDir);
+    if (shouldTrackPath(normalizedPath)) {
+      state.files[normalizedPath] = {
+        author: detectAuthor(payload),
+        ts,
+        reviewed: false,
+      };
+      changed = true;
+    }
+  } else if (toolName === "Bash") {
+    const actor = detectCliActor(payload);
+    if (actor) {
+      const paths = extractCandidatePaths(payload, baseDir);
+      if (paths.length > 0) {
+        for (const path of paths) {
+          state.files[path] = {
+            author: actor,
+            ts,
+            reviewed: false,
+          };
+        }
+      } else {
+        applyReviewer(state, actor, ts);
+      }
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    saveState(statePath, state);
+  }
+
+  process.exit(0);
+}
+
+main().catch(() => process.exit(0));