triflux 8.12.5 → 9.0.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "8.12.5",
+  "version": "9.0.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));

package/scripts/session-spawn-helper.mjs

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+import { readFileSync, existsSync } from "node:fs";
+import { spawn, execFileSync } from "node:child_process";
+import { resolve } from "node:path";
+
+const SESSION_PREFIX = "tfx-isolated";
+const DEFAULT_ATTACH_PROFILE = "triflux";
+const SESSION_EXPIRE_MS = 30 * 60 * 1000;
+
+const STOP_WORDS = new Set([
+  "a", "an", "and", "as", "at", "be", "by", "for", "from", "in",
+  "is", "it", "of", "on", "or", "that", "the", "to", "with",
+  "작업", "요청", "합니다", "그리고", "에서", "으로",
+]);
+
+// ── psmux helpers ──
+
+function hasPsmux() {
+  try {
+    execFileSync("psmux", ["-V"], { timeout: 2000, stdio: "ignore" });
+    return true;
+  } catch { return false; }
+}
+
+function psmux(...args) {
+  execFileSync("psmux", args, { timeout: 5000, stdio: "ignore" });
+}
+
+function psmuxCapture(sessionName) {
+  try {
+    return execFileSync("psmux", ["capture-pane", "-t", sessionName, "-p"], {
+      timeout: 5000, encoding: "utf8",
+    }).trim();
+  } catch { return ""; }
+}
+
+function psmuxHasSession(sessionName) {
+  try {
+    execFileSync("psmux", ["has-session", "-t", sessionName], { timeout: 2000, stdio: "ignore" });
+    return true;
+  } catch { return false; }
+}
+
+// ── core functions ──
+
+export function createIsolatedSessionName(timestamp = Date.now()) {
+  return `${SESSION_PREFIX}-${Math.trunc(timestamp)}`;
+}
+
+export function createIsolatedSession(options = {}) {
+  const ts = options.timestamp ?? Date.now();
+  const sessionName = options.name || createIsolatedSessionName(ts);
+
+  psmux("new-session", "-s", sessionName, "-d");
+
+  // cd to project root
+  const projectRoot = options.projectRoot || process.cwd();
+  psmux("send-keys", "-t", sessionName, `cd '${projectRoot}'`, "Enter");
+
+  // send prompt as claude command
+  if (options.prompt) {
+    const safePrompt = options.prompt.replace(/'/g, "'\\''");
+    psmux("send-keys", "-t", sessionName, `claude --prompt '${safePrompt}'`, "Enter");
+  }
+
+  return { sessionName };
+}
+
+export function attachWithWindowsTerminal(sessionName, options = {}) {
+  const profile = options.profile || DEFAULT_ATTACH_PROFILE;
+  const title = options.title || sessionName;
+
+  // sp (split-pane), not new-tab
+  const wtArgs = ["sp", "-p", profile, "--title", title, "--", "psmux", "attach-session", "-t", sessionName];
+  const child = spawn("wt.exe", wtArgs, { detached: true, stdio: "ignore", windowsHide: false });
+  child.unref();
+  return wtArgs;
+}
+
+export function waitForCompletion(sessionName, opts = {}) {
+  const pollMs = opts.pollMs || 3000;
+  const maxMs = opts.maxMs || SESSION_EXPIRE_MS;
+  const start = Date.now();
+
+  return new Promise((res) => {
+    const check = () => {
+      if (!psmuxHasSession(sessionName) || Date.now() - start > maxMs) {
+        const output = psmuxCapture(sessionName);
+        // cleanup expired session
+        try { psmux("kill-session", "-t", sessionName); } catch {}
+        res({ sessionName, output, expired: Date.now() - start > maxMs });
+        return;
+      }
+      setTimeout(check, pollMs);
+    };
+    check();
+  });
+}
+
+// ── context drift (kept from codex) ──
+
+function tokenize(text) {
+  return String(text || "").toLowerCase()
+    .split(/[^\p{L}\p{N}_-]+/u)
+    .filter((t) => t.length >= 2 && !STOP_WORDS.has(t));
+}
+
+export function evaluateContextDrift(input = {}) {
+  const taskTokens = Array.from(new Set(tokenize(input.taskPrompt)));
+  if (!taskTokens.length) return { drift: false, overlapRatio: 1, reason: "task-token-empty" };
+
+  const outputTokens = new Set(tokenize(input.latestOutput));
+  const matched = taskTokens.filter((t) => outputTokens.has(t));
+  const ratio = matched.length / taskTokens.length;
+  const threshold = input.minOverlapRatio ?? 0.2;
+
+  return { drift: ratio < threshold, overlapRatio: ratio, reason: ratio < threshold ? "token-overlap-low" : "token-overlap-ok" };
+}
+
+// ── CLI ──
+
+function parseArgs(argv) {
+  const a = { spawn: false, prompt: "", attach: false, background: false, name: "" };
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--spawn") { a.spawn = true; continue; }
+    if (arg === "--attach") { a.attach = true; continue; }
+    if (arg === "--background") { a.background = true; continue; }
+    if ((arg === "--prompt" || arg === "-p") && argv[i + 1]) { a.prompt = argv[++i]; continue; }
+    if ((arg === "--name" || arg === "-n") && argv[i + 1]) { a.name = argv[++i]; continue; }
+  }
+  return a;
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+
+  if (!args.spawn) {
+    process.stdout.write([
+      "session-spawn-helper: psmux 격리 세션 생성 도구",
+      "",
+      "사용법:",
+      "  node scripts/session-spawn-helper.mjs --spawn --prompt '작업 내용' [--attach] [--background] [--name 세션명]",
+      "",
+      "옵션:",
+      "  --spawn        세션 생성 (필수)",
+      "  --prompt TEXT   Claude에 전달할 프롬프트",
+      "  --attach        WT split-pane으로 attach",
+      "  --background    attach 없이 실행, 완료 시 결과 출력",
+      "  --name NAME     세션 이름 (기본: tfx-isolated-{ts})",
+      "",
+    ].join("\n"));
+    process.exit(0);
+  }
+
+  if (!hasPsmux()) {
+    process.stderr.write("ERROR: psmux가 설치되어 있지 않습니다. npm install -g psmux\n");
+    process.exit(1);
+  }
+
+  const { sessionName } = createIsolatedSession({
+    name: args.name || undefined,
+    prompt: args.prompt || undefined,
+    projectRoot: process.cwd(),
+  });
+
+  process.stdout.write(`[session-spawn] 세션 생성: ${sessionName}\n`);
+
+  if (args.attach) {
+    attachWithWindowsTerminal(sessionName);
+    process.stdout.write(`[session-spawn] WT split-pane attach 완료\n`);
+  }
+
+  if (args.background) {
+    process.stdout.write(`[session-spawn] 백그라운드 대기 중...\n`);
+    const result = await waitForCompletion(sessionName);
+    const preview = (result.output || "(no output)").slice(0, 200);
+    process.stdout.write(`[session-spawn] 완료: ${sessionName} | expired=${result.expired} | preview=${preview}\n`);
+  }
+}
+
+if (process.argv[1]?.endsWith("session-spawn-helper.mjs")) {
+  main().catch((e) => { process.stderr.write(`${e.message}\n`); process.exit(1); });
+}

package/skills/merge-worktree/SKILL.md

@@ -0,0 +1,144 @@
+---
+name: merge-worktree
+description: "워크트리 브랜치를 main으로 squash-merge + conventional commit 자동 생성. codex-swarm 워크트리 자동 인식. '머지해', 'merge worktree', '워크트리 머지', '결과 수집', 'squash merge' 요청에 사용."
+argument-hint: "[target-branch]"
+disable-model-invocation: true
+---
+
+# Merge Worktree
+
+워크트리 브랜치를 대상 브랜치로 squash-merge하고 conventional commit 메시지를 자동 작성한다.
+
+## Current context
+
+* Git dir: `!git rev-parse --git-dir`
+* Current branch: `!git branch --show-current`
+* Recent commits: `!git log --oneline -20`
+* Working tree status: `!git status --short`
+
+## Instructions
+
+### Phase 1: Validation
+
+1. **Worktree 확인**: `git rev-parse --git-dir` 출력에 `/worktrees/`가 포함되어야 한다. 아니면 중지.
+
+2. **현재 브랜치 확인**: `git branch --show-current`
+
+3. **대상 브랜치 결정**:
+   * `$ARGUMENTS`가 있으면 해당 브랜치 사용
+   * 없으면 `main` 존재 확인, 없으면 `master`
+
+4. **원본 레포 경로 확인**: `git rev-parse --git-common-dir`의 부모 디렉토리
+
+5. **클린 상태 확인**: `git status --porcelain`이 비어있어야 한다. 미커밋 변경이 있으면 먼저 커밋/스태시 안내.
+
+### Phase 2: Research
+
+1. **커밋 이력**: `git log --oneline <target>..HEAD`
+
+2. **변경 파일 요약**: `git diff <target>...HEAD --stat`
+
+3. **전체 diff**: `git diff <target>...HEAD` — 꼼꼼히 읽는다.
+
+4. **핵심 파일 읽기**: 가장 큰 변경, 신규 파일, 삭제 파일을 Read로 확인.
+
+5. **변경 분류**:
+   * Features (신규 기능)
+   * Fixes (버그 수정)
+   * Refactors (구조 변경)
+   * Tests (테스트)
+   * Docs (문서)
+   * Config/Chore (빌드, CI, 의존성)
+
+6. **dominant type 결정**: `feat`, `fix`, `refactor`, `docs`, `chore`, `test` 중 하나
+
+### Phase 3: 대상 브랜치 준비
+
+1. **대상 브랜치 최근 커밋 확인**: `git -C <원본레포> log --oneline -10 <target>`
+
+2. **WIP 커밋 감지**: `wip:`, `auto-commit`, `WIP` 시작 커밋이 있으면 사용자에게 경고.
+
+3. **최신 fetch**: `git -C <원본레포> fetch origin <target> 2>/dev/null`
+
+### Phase 4: Squash Merge
+
+1. **대상 브랜치 checkout**:
+   ```
+   git -C <원본레포> checkout <target>
+   ```
+
+2. **squash merge 실행**:
+   ```
+   git -C <원본레포> merge --squash <워크트리브랜치>
+   ```
+
+3. **충돌 처리**: 충돌 발생 시 충돌 파일 목록 + 마커를 보여주고 **중지**. 자동 해결 시도 금지.
+
+### Phase 5: 커밋 메시지 작성 + 커밋
+
+Phase 2 분석 기반으로 아래 구조의 커밋 메시지를 작성한다:
+
+```
+<type>: <명령형 요약, 72자 이내, 마침표 없음>
+
+<무엇을 왜 했는지 2-4문장. 동기와 접근 방식 중심.>
+
+Changes:
+* <그룹별 변경 사항>
+* <하위 항목은 서브 불릿>
+```
+
+**규칙:**
+* `<type>`은 `feat`, `fix`, `refactor`, `docs`, `chore`, `test` 중 하나
+* 여러 유형이 섞이면 dominant 사용
+* 요약: 명령형 ("add", "fix", "refactor"), 마침표 없음, 72자 제한
+* 본문: *왜*와 *맥락*, *무엇*만이 아님
+* Changes: 관련 항목 그룹핑, 중요한 것 먼저
+* Co-Authored-By 푸터 **절대 추가 금지** (글로벌 설정 `includeCoAuthoredBy: false`)
+
+**커밋 실행**:
+```bash
+git -C <원본레포> commit -m "$(cat <<'EOF'
+<커밋 메시지>
+EOF
+)"
+```
+
+### Phase 6: 정리 + 검증
+
+1. **커밋 확인**: `git -C <원본레포> log --oneline -3`
+
+2. **워크트리 자동 정리**:
+   ```bash
+   git -C <원본레포> worktree remove <워크트리경로>
+   git -C <원본레포> branch -d <워크트리브랜치>
+   ```
+
+3. **codex-swarm 정리 감지**: 워크트리 경로가 `.codex-swarm/wt-*` 패턴이면:
+   * 같은 `.codex-swarm/` 디렉토리에 다른 워크트리가 남아있는지 확인
+   * 모든 워크트리가 머지 완료되었으면 `.codex-swarm/` 전체 정리 제안
+   * `git worktree prune` 실행
+
+4. **결과 보고**:
+   * 커밋 해시 + 요약
+   * 머지 대상 브랜치
+   * 워크트리 정리 완료 여부
+   * push 안내 (`git push`)
+
+## codex-swarm 연동
+
+이 스킬은 `tfx-codex-swarm`의 Step 10 "결과 수집"에서 자동으로 호출된다.
+codex-swarm이 완료한 각 워크트리에 대해 순차적으로 실행:
+
+```
+각 워크트리에 대해:
+  1. 워크트리로 cd
+  2. /merge-worktree main
+  3. 다음 워크트리로 이동
+```
+
+## 주의사항
+
+* force-push, destructive 연산은 사용자 확인 없이 절대 실행 금지
+* pre-commit hook 건너뛰기(`--no-verify`) 금지
+* 예상치 못한 상황이면 추측하지 말고 **중지 후 설명**

package/skills/tfx-analysis/SKILL.md

@@ -11,6 +11,7 @@ argument-hint: "<분석 대상 — 파일, 디렉토리, 또는 주제>"
 
 # tfx-analysis — Light Code Analysis
 
+> **Deep 버전**: tfx-deep-analysis. "제대로/꼼꼼히" 수정자로 자동 에스컬레이션.
 > Codex 단일 분석으로 빠른 인사이트. SuperClaude sc:analyze 영감.
 
 ## 용도

package/skills/tfx-auto-codex/SKILL.md

@@ -8,6 +8,7 @@ argument-hint: "\"작업 설명\" | N:agent_type \"작업 설명\""
 
 # tfx-auto-codex — Codex 리드형 tfx-auto
 
+> **래퍼**: tfx-auto의 Codex 전용 바로가기. TFX_NO_CLAUDE_NATIVE=1.
 > 목적: 기존 `tfx-auto`의 오케스트레이션 패턴을 유지하면서
 > Claude 네이티브 역할(`explore`, `verifier`, `test-engineer`, `qa-tester`)을
 > Codex로 치환해 Codex/Gemini만으로 실행한다.

package/skills/tfx-autopilot/SKILL.md

@@ -1,11 +1,10 @@
 ---
 name: tfx-autopilot
-description: "간단한 작업을 자율적으로 구현해야 할 때 사용한다. 'autopilot', '자동으로', '알아서 해', '그냥 해줘', 'auto' 같은 요청에 반드시 사용. 명확한 단일 작업을 빠르게 자동 구현+검증할 때 적극 활용."
+description: "간단한 작업을 자율적으로 구현해야 할 때 사용한다. 'autopilot', '자동으로', '알아서 해', '그냥 해줘' 같은 요청에 반드시 사용. 명확한 단일 작업을 빠르게 자동 구현+검증할 때 적극 활용."
 triggers:
   - autopilot
   - 자동
   - 알아서 해
-  - auto
 argument-hint: "<구현할 작업 설명>"
 ---
 

package/skills/tfx-codex/SKILL.md

@@ -8,6 +8,7 @@ argument-hint: "\"작업 설명\" | N:codex \"작업 설명\""
 
 # tfx-codex — Codex-Only 오케스트레이터
 
+> **래퍼**: tfx-auto의 Codex 전용 바로가기. TFX_CLI_MODE=codex.
 > **HARD RULE**: Claude는 이 스킬에서 Edit/Write를 사용하면 안 된다. 모든 코드 수정은 Codex CLI를 통해 수행한다.
 > Codex CLI만 사용하여 모든 외부 CLI 작업을 라우팅합니다.
 > Gemini CLI가 없는 환경에서 사용합니다.

package/skills/tfx-codex-swarm/SKILL.md

@@ -13,8 +13,18 @@ description: OMX 스킬을 활용하는 Codex 다중 세션 스폰 오케스트
 - `codex` CLI 설치됨
 - `psmux` 설치됨 (세션 관리)
 - `git` (worktree 생성)
-- Windows Terminal (탭 기반 attach)
 - Windows Terminal (`wt.exe` 탭 기반 attach)
+- MCP 싱글톤 데몬 (`supergateway` + `mcp-remote`) — 선택적이나 스웜 시 강력 권장
+
+## 설정
+
+| 설정 | 기본값 | 설명 |
+|------|--------|------|
+| MAX_CONCURRENCY | 4 | 동시 실행 세션 수. 초과분은 큐 대기 후 순차 시작 |
+| WT_ATTACH_MODE | attach | `attach`: split-pane 직접 attach (기본). `dashboard`: 모니터링 탭만 |
+| MCP_DAEMON_REQUIRED | true | MCP 싱글톤 데몬 사전 확인 필수. false면 세션별 MCP 직접 스폰 (비권장) |
+
+사용자가 명시하지 않으면 기본값 사용. AskUserQuestion으로 오버라이드 가능.
 
 ## 워크플로우
 
@@ -267,7 +277,13 @@ git worktree add .codex-swarm/wt-issue-{N} codex/issue-{N}
 cp {PRD_PATH} .codex-swarm/wt-issue-{N}/{PRD_PATH}
 ```
 
-### Step 7: psmux 세션 생성 + Codex 실행
+### Step 7: psmux 세션 생성 + Codex 실행 (웨이브 방식)
+
+**MAX_CONCURRENCY(기본 4)에 따라 웨이브 단위로 실행한다.**
+- Wave 1: 태스크 1~MAX_CONCURRENCY 동시 시작
+- Wave 2+: 이전 웨이브에서 완료된 슬롯만큼 다음 태스크 시작
+- 완료 감지: `psmux capture-pane`으로 codex 종료 여부 확인 (30초 폴링)
+- 전체 태스크 > MAX_CONCURRENCY일 때만 큐잉 적용
 
 각 태스크에 대해 psmux 세션을 생성하고 Codex를 실행한다:
 
@@ -293,33 +309,39 @@ psmux send-keys -t "codex-swarm-{id}" \
 # --skip-git-repo-check: codex exec 전용이므로 대화식 모드에서 사용 불가
 ```
 
-### Step 8: WT triflux 프로파일로 attach
+### Step 8: WT attach
 
 > WT `triflux` 프로파일 사용 필수 (`commandline: "psmux"`, One Half Dark, acrylic).
-> triflux 프로파일은 psmux를 기본 셸로 쓰므로 attach가 바로 동작한다.
-> **레이아웃 규칙:**
-> - 세션 1-3개: split-pane only (탭 불필요)
-> - 세션 4개+: **테마/웨이브별 탭 그룹핑** + 탭 내부 split-pane
->   - 같은 카테고리/웨이브는 하나의 탭에 묶는다
->   - 탭 내부 2-4개 split (가로 `-H` / 세로 `-V` 적절 배분)
->   - 사용자가 탭/split 레이아웃을 명시하면 해당 지시를 우선한다
+> 기본은 **split-pane 직접 attach**. 4개 이하 2x2 그리드, 5개 이상은 사용자 확인.
 
 ```bash
-# 세션 1-3개: split-pane only
-wt.exe -w new \
-  -p triflux --title "{title1}" psmux attach-session -t codex-swarm-{id1} \; \
-  split-pane -H -p triflux --title "{title2}" psmux attach-session -t codex-swarm-{id2} \; \
-  split-pane -V -p triflux --title "{title3}" psmux attach-session -t codex-swarm-{id3}
+# 2개: 상하 분할
+wt.exe -w 0 \
+  sp -H -p triflux --title "{t1}" psmux attach-session -t {id1} \; \
+  sp -V -p triflux --title "{t2}" psmux attach-session -t {id2}
 
-# 세션 4개+: 테마별 탭 + 탭 내부 split (예: Wave1=3개, Wave2=4개)
+# 4개: 2x2 그리드
 wt.exe -w 0 \
-  -p triflux --title "W1:{title1}" psmux attach-session -t {id1} \; \
-  split-pane -H -p triflux --title "W1:{title2}" psmux attach-session -t {id2} \; \
-  split-pane -V -p triflux --title "W1:{title3}" psmux attach-session -t {id3} \; \
-  new-tab -p triflux --title "W2:{title4}" psmux attach-session -t {id4} \; \
-  split-pane -H -p triflux --title "W2:{title5}" psmux attach-session -t {id5} \; \
-  split-pane -V -p triflux --title "W2:{title6}" psmux attach-session -t {id6} \; \
-  move-focus up \; split-pane -V -p triflux --title "W2:{title7}" psmux attach-session -t {id7}
+  sp -H -p triflux --title "{t1}" psmux attach-session -t {id1} \; \
+  sp -V -p triflux --title "{t2}" psmux attach-session -t {id2} \; \
+  move-focus up \; \
+  sp -V -p triflux --title "{t3}" psmux attach-session -t {id3} \; \
+  move-focus down \; \
+  sp -V -p triflux --title "{t4}" psmux attach-session -t {id4}
+```
+
+5개 이상이면 AskUserQuestion으로 확인 후 dashboard 모드 제안:
+```bash
+# dashboard 모드 (모니터링 전용)
+wt.exe -w 0 -p triflux --title "swarm-dashboard" bash -c '
+  while true; do
+    clear; echo "=== Codex Swarm Dashboard ==="
+    for s in $(psmux list-sessions -F "#{session_name}" 2>/dev/null | grep codex-swarm); do
+      echo "  [$s] $(psmux capture-pane -t "$s" -p | tail -1)"
+    done
+    sleep 10
+  done
+'
 ```
 
 ### Step 9: 상태 보고
@@ -439,6 +461,21 @@ for bin in codex psmux git; do
     exit 1
   }
 done
+
+# MCP 싱글톤 데몬 검사 (MCP_DAEMON_REQUIRED=true일 때)
+if [ "$MCP_DAEMON_REQUIRED" != "false" ]; then
+  DAEMON_OK=true
+  for port in 9001 9002 9003 9004 9005; do
+    curl -s --max-time 1 "http://localhost:$port/sse" >/dev/null 2>&1 || {
+      DAEMON_OK=false
+      break
+    }
+  done
+  if [ "$DAEMON_OK" = "false" ]; then
+    echo "WARN: MCP daemons not running. Starting..."
+    powershell -ExecutionPolicy Bypass -File "$HOME/.codex/mcp-daemon/start-daemons.ps1"
+  fi
+fi
 ```
 
 ## 정리

package/skills/tfx-codex-swarm/mcp-daemon/start-daemons.ps1

@@ -0,0 +1,54 @@
+# MCP Singleton Daemons - supergateway wrapper
+# Each OMX MCP server runs once, codex sessions connect via mcp-remote
+# Usage: powershell -ExecutionPolicy Bypass -File start-daemons.ps1
+
+$OMX_BASE = "$env:APPDATA/npm/node_modules/oh-my-codex/dist/mcp"
+$SG_CMD = "$env:APPDATA\npm\supergateway.cmd"
+$DAEMON_DIR = Split-Path -Parent $MyInvocation.MyCommand.Path
+
+$servers = @(
+    @{ Name = "omx_state";      Script = "state-server.js";      Port = 9001 }
+    @{ Name = "omx_memory";     Script = "memory-server.js";     Port = 9002 }
+    @{ Name = "omx_code_intel"; Script = "code-intel-server.js"; Port = 9003 }
+    @{ Name = "omx_trace";      Script = "trace-server.js";      Port = 9004 }
+    @{ Name = "omx_team_run";   Script = "team-server.js";       Port = 9005 }
+)
+
+foreach ($srv in $servers) {
+    $port = $srv.Port
+    $name = $srv.Name
+    $script = "$OMX_BASE/$($srv.Script)"
+
+    # Check if already running on this port
+    $existing = Get-NetTCPConnection -LocalPort $port -ErrorAction SilentlyContinue
+    if ($existing) {
+        Write-Host "[SKIP] $name already running on port $port"
+        continue
+    }
+
+    # Create individual launcher .cmd
+    $launcher = Join-Path $DAEMON_DIR "run-$name.cmd"
+    $content = "@echo off`r`ncall `"$SG_CMD`" --stdio `"node $script`" --port $port"
+    Set-Content -Path $launcher -Value $content -Encoding ASCII
+
+    Write-Host "[START] $name on port $port"
+    Start-Process -WindowStyle Hidden -FilePath $launcher
+
+    Start-Sleep -Milliseconds 800
+}
+
+Start-Sleep -Milliseconds 1000
+
+# Verify
+$ok = 0
+foreach ($srv in $servers) {
+    $c = Get-NetTCPConnection -LocalPort $srv.Port -ErrorAction SilentlyContinue
+    if ($c) {
+        Write-Host "[OK] $($srv.Name) listening on port $($srv.Port)"
+        $ok++
+    } else {
+        Write-Host "[FAIL] $($srv.Name) NOT listening on port $($srv.Port)"
+    }
+}
+Write-Host ""
+Write-Host "$ok / $($servers.Count) daemons running"

package/skills/tfx-codex-swarm/mcp-daemon/stop-daemons.ps1

@@ -0,0 +1,15 @@
+# Stop all MCP singleton daemons
+# Usage: powershell -ExecutionPolicy Bypass -File stop-daemons.ps1
+
+9001..9005 | ForEach-Object {
+    $port = $_
+    $conn = Get-NetTCPConnection -LocalPort $port -ErrorAction SilentlyContinue
+    if ($conn) {
+        $pid = $conn[0].OwningProcess
+        Write-Host "[STOP] Killing PID $pid on port $port"
+        Stop-Process -Id $pid -Force -ErrorAction SilentlyContinue
+    } else {
+        Write-Host "[SKIP] Nothing on port $port"
+    }
+}
+Write-Host "All MCP daemons stopped."

package/skills/tfx-consensus/SKILL.md

@@ -7,6 +7,7 @@ argument-hint: "(내부 전용 — Deep 스킬이 자동 호출)"
 
 # tfx-consensus — Tri-CLI Consensus Engine
 
+> **인프라**: 다른 스킬이 내부적으로 사용. 직접 호출할 필요 없음.
 > 모든 Deep 스킬의 공통 기반. 3개 CLI의 독립 결과를 교차검증하여 합의 도출.
 
 ## HARD RULES

package/skills/tfx-deep-analysis/SKILL.md

@@ -10,6 +10,7 @@ argument-hint: "<분석 대상 — 파일, 디렉토리, 또는 주제>"
 
 # tfx-deep-analysis — Tri-CLI Deep Analysis
 
+> **Light 버전**: tfx-analysis. 기본값. 깊이 수정자 없으면 Light 선택.
 > Claude(아키텍처) + Codex(구현/보안) + Gemini(UX/문서화) → Tri-Debate → 합의.
 > 3자 전문 관점의 편향 없는 분석.
 

package/skills/tfx-deep-plan/SKILL.md

@@ -13,6 +13,7 @@ argument-hint: "<구현할 기능 설명>"
 
 # tfx-deep-plan — Tri-Model Consensus Planning
 
+> **Light 버전**: tfx-plan. 기본값. 깊이 수정자 없으면 Light 선택.
 3개 모델(Opus 4.6 · GPT 5.4 · Gemini)이 독립 설계 후 교차검증하여 합의된 계획을 도출한다.
 
 ---

package/skills/tfx-deep-qa/SKILL.md

@@ -11,6 +11,7 @@ argument-hint: "[테스트 대상 경로 또는 기능 설명]"
 
 # tfx-deep-qa — Tri-CLI Deep Verification
 
+> **Light 버전**: tfx-qa. 기본값. 깊이 수정자 없으면 Light 선택.
 > 3-CLI 독립 검증 → 교차검증 → 2+ 합의 항목만 보고. false-positive 87% 감소.
 
 ## 핵심 원리

package/skills/tfx-deep-research/SKILL.md

@@ -14,6 +14,7 @@ argument-hint: "[--depth quick|standard|deep] <리서치 주제>"
 
 # tfx-deep-research — Multi-Source Deep Research with Tri-CLI Consensus
 
+> **Light 버전**: tfx-research. 기본값. 깊이 수정자 없으면 Light 선택.
 > 쿼리 분해 → 3-CLI 독립 병렬 검색 → 교차검증 → 합의 기반 종합 보고서.
 > STORM(Stanford) perspective-guided + GPT-Researcher recursive tree + Tavily deep research pipeline 영감.
 

package/skills/tfx-deep-review/SKILL.md

@@ -12,6 +12,7 @@ argument-hint: "[파일 경로 또는 변경 설명]"
 
 # tfx-deep-review — Tri-CLI Deep Code Review
 
+> **Light 버전**: tfx-review. 기본값. 깊이 수정자 없으면 Light 선택.
 > 3-CLI 독립 리뷰 → 교차검증 → 2+ 합의 항목만 보고. Diffray + Calimero 영감.
 
 ## 핵심 원리

package/skills/tfx-gemini/SKILL.md

@@ -8,6 +8,7 @@ argument-hint: "\"작업 설명\" | N:gemini \"작업 설명\""
 
 # tfx-gemini — Gemini-Only 오케스트레이터
 
+> **래퍼**: tfx-auto의 Gemini 전용 바로가기. TFX_CLI_MODE=gemini.
 > Gemini CLI만 사용하여 모든 외부 CLI 작업을 라우팅합니다.
 > Codex CLI가 없는 환경에서 사용합니다.
 

package/skills/tfx-hub/SKILL.md

@@ -11,6 +11,7 @@ argument-hint: "<start|stop|status|자유형 작업 설명>"
 
 # tfx-hub — MCP 메시지 버스 관리 + 개방형 작업
 
+> **인프라**: 다른 스킬이 내부적으로 사용. 직접 호출할 필요 없음.
 > CLI 에이전트(Codex/Gemini/Claude) 간 실시간 메시지 허브를 관리합니다.
 > **커맨드 매칭 + fallthrough**: start/stop/status에 매칭되면 즉시 실행,
 > 매칭 안 되면 **hub 도메인 컨텍스트를 활용한 범용 작업**으로 처리합니다.

package/skills/tfx-multi/SKILL.md

@@ -8,6 +8,7 @@ argument-hint: '"작업 설명" | --agents codex,gemini "작업" | --tmux "작
 
 # tfx-multi v3 — 파이프라인 기반 멀티-CLI 팀 오케스트레이터
 
+> **인프라**: 다른 스킬이 내부적으로 사용. 직접 호출할 필요 없음.
 > Claude Code Native Teams의 Shift+Down 네비게이션을 복원한다.
 > Codex/Gemini 워커마다 최소 프롬프트(~100 토큰)의 슬림 Agent 래퍼를 spawn하여 네비게이션에 등록하고,
 > 실제 작업은 `tfx-route.sh`가 수행한다. task 상태는 `team_task_list`를 truth source로 검증한다.

package/skills/tfx-plan/SKILL.md

@@ -11,6 +11,7 @@ argument-hint: "<구현할 기능 설명>"
 
 # tfx-plan — Light Implementation Plan
 
+> **Deep 버전**: tfx-deep-plan. "제대로/꼼꼼히" 수정자로 자동 에스컬레이션.
 > Claude Opus 단독 빠른 계획. 복잡한 합의 없이 즉시 태스크 분해.
 
 ## 워크플로우

package/skills/tfx-qa/SKILL.md

@@ -11,6 +11,7 @@ argument-hint: "[테스트 명령 또는 파일 경로]"
 
 # tfx-qa — Light Test-Fix Cycle
 
+> **Deep 버전**: tfx-deep-qa. "제대로/꼼꼼히" 수정자로 자동 에스컬레이션.
 > 테스트 실행 → 실패 분석 → 자동 수정 → 재실행. 최대 3회. OMC ultraqa 영감.
 
 ## 용도

package/skills/tfx-ralph/SKILL.md

@@ -2,16 +2,13 @@
 name: tfx-ralph
 description: "작업이 완전히 끝날 때까지 멈추지 않고 반복 실행해야 할 때 사용한다. 'ralph', '끝까지 해', '멈추지 마', 'don't stop', '완료될 때까지', '다 될 때까지 계속' 같은 요청에 반드시 사용. 여러 기준을 모두 충족해야 하는 복잡한 구현 작업에 적극 활용."
 triggers:
-  - ralph
-  - don't stop
-  - 끝까지
-  - until done
-  - 멈추지 마
+  - tfx-ralph
 argument-hint: "<완료할 작업 설명>"
 ---
 
 # tfx-ralph — Alias for tfx-persist
 
+> **래퍼**: tfx-persist의 alias. 동일 기능.
 > `tfx-ralph`는 `tfx-persist`의 alias이다. 동일한 Tri-Verified Persistence Loop을 실행한다.
 > The boulder never stops — but it stops being wrong.
 

package/skills/tfx-research/SKILL.md

@@ -13,6 +13,7 @@ argument-hint: "<검색 주제>"
 
 # tfx-research — Light Web Research
 
+> **Deep 버전**: tfx-deep-research. "제대로/꼼꼼히" 수정자로 자동 에스컬레이션.
 > 빠른 단일 소스 검색 + 요약. 토큰 최소화, 즉시 결과.
 
 ## 용도

package/skills/tfx-review/SKILL.md

@@ -11,6 +11,7 @@ argument-hint: "[파일 경로 또는 변경 설명]"
 
 # tfx-review — Light Code Review
 
+> **Deep 버전**: tfx-deep-review. "제대로/꼼꼼히" 수정자로 자동 에스컬레이션.
 > **HARD RULE**: 리뷰 결과를 생성할 때 Claude가 직접 git log/diff를 실행하지 마라. Codex code-reviewer에게 위임하라.
 > Codex 단일 리뷰로 빠른 피드백. 토큰 최소화.