triflux 3.1.0-dev.5 → 3.2.0-dev.1

package/bin/triflux.mjs

@@ -826,6 +826,7 @@ ${updateNotice}
     ${DIM}  --dev${RESET}         ${GRAY}dev 태그로 업데이트${RESET}
     ${WHITE_BRIGHT}tfx list${RESET}       ${GRAY}설치된 스킬 목록${RESET}
     ${WHITE_BRIGHT}tfx hub${RESET}        ${GRAY}MCP 메시지 버스 관리 (start/stop/status)${RESET}
+    ${WHITE_BRIGHT}tfx team${RESET}       ${GRAY}멀티-CLI 팀 모드 (tmux + Hub)${RESET}
     ${WHITE_BRIGHT}tfx notion-read${RESET} ${GRAY}Notion 페이지 → 마크다운 (Codex/Gemini MCP)${RESET}
     ${WHITE_BRIGHT}tfx version${RESET}    ${GRAY}버전 표시${RESET}
 
@@ -1060,6 +1061,12 @@ switch (cmd) {
   case "update":  cmdUpdate(); break;
   case "list": case "ls": cmdList(); break;
   case "hub":     cmdHub(); break;
+  case "team": {
+    const { pathToFileURL } = await import("node:url");
+    const { cmdTeam } = await import(pathToFileURL(join(PKG_ROOT, "hub", "team", "cli.mjs")).href);
+    await cmdTeam();
+    break;
+  }
   case "notion-read": case "nr": {
     const scriptPath = join(PKG_ROOT, "scripts", "notion-read.mjs");
     const nrArgs = process.argv.slice(3).map(a => `"${a}"`).join(" ");

package/hub/team/cli.mjs

@@ -0,0 +1,368 @@
+// hub/team/cli.mjs — tfx team CLI 진입점
+// bin/triflux.mjs에서 import하여 사용
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { execSync, spawn } from "node:child_process";
+
+import { createSession, attachSession, killSession, sessionExists, listSessions, capturePaneOutput } from "./session.mjs";
+import { buildCliCommand, startCliInPane, injectPrompt, sendKeys } from "./pane.mjs";
+import { orchestrate, decomposeTask } from "./orchestrator.mjs";
+import { detectMultiplexer } from "./session.mjs";
+
+// ── 상수 ──
+const PKG_ROOT = dirname(dirname(dirname(new URL(import.meta.url).pathname))).replace(/^\/([A-Z]:)/, "$1");
+const HUB_PID_DIR = join(homedir(), ".claude", "cache", "tfx-hub");
+const HUB_PID_FILE = join(HUB_PID_DIR, "hub.pid");
+const TEAM_STATE_FILE = join(HUB_PID_DIR, "team-state.json");
+
+// ── 색상 ──
+const AMBER = "\x1b[38;5;214m";
+const GREEN = "\x1b[38;5;82m";
+const RED = "\x1b[38;5;196m";
+const GRAY = "\x1b[38;5;245m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+const WHITE = "\x1b[97m";
+const YELLOW = "\x1b[33m";
+
+function ok(msg) { console.log(`  ${GREEN}✓${RESET} ${msg}`); }
+function warn(msg) { console.log(`  ${YELLOW}⚠${RESET} ${msg}`); }
+function fail(msg) { console.log(`  ${RED}✗${RESET} ${msg}`); }
+
+// ── 팀 상태 관리 ──
+
+function loadTeamState() {
+  try {
+    return JSON.parse(readFileSync(TEAM_STATE_FILE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function saveTeamState(state) {
+  mkdirSync(HUB_PID_DIR, { recursive: true });
+  writeFileSync(TEAM_STATE_FILE, JSON.stringify(state, null, 2) + "\n");
+}
+
+function clearTeamState() {
+  try { unlinkSync(TEAM_STATE_FILE); } catch {}
+}
+
+// ── Hub 유틸 ──
+
+function getHubInfo() {
+  if (!existsSync(HUB_PID_FILE)) return null;
+  try {
+    const info = JSON.parse(readFileSync(HUB_PID_FILE, "utf8"));
+    process.kill(info.pid, 0); // 프로세스 생존 확인
+    return info;
+  } catch {
+    return null;
+  }
+}
+
+function startHubDaemon() {
+  const serverPath = join(PKG_ROOT, "hub", "server.mjs");
+  if (!existsSync(serverPath)) {
+    fail("hub/server.mjs 없음 — hub 모듈이 설치되지 않음");
+    return null;
+  }
+
+  const child = spawn(process.execPath, [serverPath], {
+    env: { ...process.env },
+    stdio: "ignore",
+    detached: true,
+  });
+  child.unref();
+
+  // PID 파일 확인 (최대 3초 대기)
+  const deadline = Date.now() + 3000;
+  while (Date.now() < deadline) {
+    if (existsSync(HUB_PID_FILE)) {
+      return JSON.parse(readFileSync(HUB_PID_FILE, "utf8"));
+    }
+    execSync('node -e "setTimeout(()=>{},100)"', { stdio: "ignore", timeout: 500 });
+  }
+  return null;
+}
+
+// ── 인자 파싱 ──
+
+function parseTeamArgs() {
+  const args = process.argv.slice(3);
+  let agents = ["codex", "codex", "gemini"]; // 기본: codex x2 + gemini
+  let layout = "2x2";
+  let task = "";
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--agents" && args[i + 1]) {
+      agents = args[++i].split(",").map((s) => s.trim().toLowerCase());
+    } else if (args[i] === "--layout" && args[i + 1]) {
+      layout = args[++i];
+    } else if (!args[i].startsWith("-")) {
+      task = args[i];
+    }
+  }
+
+  return { agents, layout, task };
+}
+
+// ── 서브커맨드 ──
+
+async function teamStart() {
+  // 1. tmux 확인
+  const mux = detectMultiplexer();
+  if (!mux) {
+    console.log(`
+  ${RED}${BOLD}tmux 미발견${RESET}
+
+  tfx team은 tmux가 필요합니다:
+    WSL2:   ${WHITE}wsl sudo apt install tmux${RESET}
+    macOS:  ${WHITE}brew install tmux${RESET}
+    Linux:  ${WHITE}apt install tmux${RESET}
+
+  Windows에서는 WSL2를 권장합니다:
+    1. ${WHITE}wsl --install${RESET}
+    2. ${WHITE}wsl sudo apt install tmux${RESET}
+    3. ${WHITE}tfx team "작업"${RESET}
+`);
+    process.exit(1);
+  }
+
+  // 2. 인자 파싱
+  const { agents, layout, task } = parseTeamArgs();
+  if (!task) {
+    console.log(`\n  ${AMBER}${BOLD}⬡ tfx team${RESET}\n`);
+    console.log(`  사용법: ${WHITE}tfx team "작업 설명"${RESET}`);
+    console.log(`          ${WHITE}tfx team --agents codex,gemini "작업"${RESET}`);
+    console.log(`          ${WHITE}tfx team --layout 1x3 "작업"${RESET}\n`);
+    return;
+  }
+
+  // 3. Hub 확인 + lazy-start
+  console.log(`\n  ${AMBER}${BOLD}⬡ tfx team${RESET}\n`);
+  let hub = getHubInfo();
+  if (!hub) {
+    process.stdout.write(`  Hub 시작 중...`);
+    hub = startHubDaemon();
+    if (hub) {
+      console.log(` ${GREEN}✓${RESET}`);
+    } else {
+      console.log(` ${RED}✗${RESET}`);
+      warn("Hub 시작 실패 — 수동으로 실행: tfx hub start");
+      // Hub 없이도 계속 진행 (통신만 불가)
+    }
+  } else {
+    ok(`Hub: ${DIM}${hub.url}${RESET}`);
+  }
+
+  // 4. 세션 ID 생성
+  const sessionId = `tfx-team-${Date.now().toString(36).slice(-4)}`;
+
+  // 5. 작업 분해
+  const subtasks = decomposeTask(task, agents.length);
+
+  console.log(`  세션:  ${WHITE}${sessionId}${RESET}`);
+  console.log(`  레이아웃: ${layout} (${agents.length + 1} panes)`);
+  console.log(`  에이전트: ${agents.map((a) => `${AMBER}${a}${RESET}`).join(", ")}`);
+  for (let i = 0; i < subtasks.length; i++) {
+    const preview = subtasks[i].length > 40 ? subtasks[i].slice(0, 40) + "…" : subtasks[i];
+    console.log(`    ${DIM}[${agents[i]}] ${preview}${RESET}`);
+  }
+  console.log("");
+
+  // 6. tmux 세션 생성
+  const session = createSession(sessionId, {
+    layout,
+    paneCount: agents.length + 1, // +1 for dashboard
+  });
+
+  // 7. Dashboard 시작 (Pane 0)
+  const dashCmd = `node ${PKG_ROOT}/hub/team/dashboard.mjs --session ${sessionId} --interval 2`;
+  startCliInPane(session.panes[0], dashCmd);
+
+  // 8. CLI 에이전트 시작 (Pane 1~N)
+  const assignments = [];
+  for (let i = 0; i < agents.length; i++) {
+    const cli = agents[i];
+    const target = session.panes[i + 1];
+    const command = buildCliCommand(cli);
+    startCliInPane(target, command);
+    assignments.push({ target, cli, subtask: subtasks[i] });
+  }
+
+  // 9. CLI 초기화 대기 (3초 — interactive 모드 진입 시간)
+  ok("CLI 초기화 대기 (3초)...");
+  await new Promise((r) => setTimeout(r, 3000));
+
+  // 10. 프롬프트 주입
+  const hubUrl = hub?.url || "http://127.0.0.1:27888/mcp";
+  await orchestrate(sessionId, assignments, { hubUrl });
+  ok("프롬프트 주입 완료");
+
+  // 11. 팀 상태 저장
+  const panes = { [session.panes[0]]: { role: "dashboard" } };
+  for (let i = 0; i < agents.length; i++) {
+    panes[session.panes[i + 1]] = {
+      cli: agents[i],
+      agentId: `${agents[i]}-${session.panes[i + 1].split(".").pop()}`,
+      subtask: subtasks[i],
+    };
+  }
+  saveTeamState({
+    sessionName: sessionId,
+    agents,
+    task,
+    layout,
+    startedAt: Date.now(),
+    hubUrl,
+    panes,
+  });
+
+  // 12. tmux attach
+  console.log(`\n  ${GREEN}${BOLD}팀 세션 준비 완료${RESET}`);
+  console.log(`  ${DIM}Ctrl+B → 방향키로 pane 전환${RESET}`);
+  console.log(`  ${DIM}Ctrl+B → D로 세션 분리 (백그라운드)${RESET}\n`);
+  attachSession(sessionId);
+}
+
+function teamStatus() {
+  const state = loadTeamState();
+  if (!state) {
+    console.log(`\n  ${DIM}활성 팀 세션 없음${RESET}\n`);
+    return;
+  }
+
+  const alive = sessionExists(state.sessionName);
+  const status = alive ? `${GREEN}● active${RESET}` : `${RED}● dead${RESET}`;
+  const uptime = alive ? `${Math.round((Date.now() - state.startedAt) / 60000)}분` : "-";
+
+  console.log(`\n  ${AMBER}${BOLD}⬡ tfx team${RESET} ${status}\n`);
+  console.log(`    세션:   ${state.sessionName}`);
+  console.log(`    작업:   ${state.task}`);
+  console.log(`    에이전트: ${state.agents.join(", ")}`);
+  console.log(`    Uptime: ${uptime}`);
+  console.log("");
+}
+
+function teamAttach() {
+  const state = loadTeamState();
+  if (!state || !sessionExists(state.sessionName)) {
+    console.log(`\n  ${DIM}활성 팀 세션 없음${RESET}\n`);
+    return;
+  }
+  attachSession(state.sessionName);
+}
+
+function teamStop() {
+  const state = loadTeamState();
+  if (!state) {
+    console.log(`\n  ${DIM}활성 팀 세션 없음${RESET}\n`);
+    return;
+  }
+
+  if (sessionExists(state.sessionName)) {
+    killSession(state.sessionName);
+    ok(`세션 종료: ${state.sessionName}`);
+  } else {
+    console.log(`  ${DIM}세션 이미 종료됨${RESET}`);
+  }
+
+  // 상태 파일 정리
+  clearTeamState();
+  console.log("");
+}
+
+function teamKill() {
+  // 모든 tfx-team- 세션 강제 종료
+  const sessions = listSessions();
+  if (sessions.length === 0) {
+    console.log(`\n  ${DIM}활성 팀 세션 없음${RESET}\n`);
+    return;
+  }
+  for (const s of sessions) {
+    killSession(s);
+    ok(`종료: ${s}`);
+  }
+  clearTeamState();
+  console.log("");
+}
+
+function teamSend() {
+  const state = loadTeamState();
+  if (!state || !sessionExists(state.sessionName)) {
+    console.log(`\n  ${DIM}활성 팀 세션 없음${RESET}\n`);
+    return;
+  }
+
+  const paneIdx = parseInt(process.argv[4], 10);
+  const message = process.argv.slice(5).join(" ");
+  if (isNaN(paneIdx) || !message) {
+    console.log(`\n  사용법: ${WHITE}tfx team send <pane번호> "메시지"${RESET}\n`);
+    return;
+  }
+
+  const target = `${state.sessionName}:0.${paneIdx}`;
+  injectPrompt(target, message);
+  ok(`Pane ${paneIdx}에 메시지 주입 완료`);
+  console.log("");
+}
+
+function teamList() {
+  const sessions = listSessions();
+  if (sessions.length === 0) {
+    console.log(`\n  ${DIM}활성 팀 세션 없음${RESET}\n`);
+    return;
+  }
+  console.log(`\n  ${AMBER}${BOLD}⬡ 팀 세션 목록${RESET}\n`);
+  for (const s of sessions) {
+    console.log(`    ${GREEN}●${RESET} ${s}`);
+  }
+  console.log("");
+}
+
+function teamHelp() {
+  console.log(`
+  ${AMBER}${BOLD}⬡ tfx team${RESET} ${DIM}멀티-CLI 팀 모드 (tmux + Hub)${RESET}
+
+  ${BOLD}시작${RESET}
+    ${WHITE}tfx team "작업 설명"${RESET}           ${GRAY}기본 (codex x2 + gemini)${RESET}
+    ${WHITE}tfx team --agents codex,gemini "작업"${RESET}  ${GRAY}에이전트 지정${RESET}
+    ${WHITE}tfx team --layout 1x3 "작업"${RESET}    ${GRAY}레이아웃 지정${RESET}
+
+  ${BOLD}제어${RESET}
+    ${WHITE}tfx team status${RESET}    ${GRAY}현재 팀 상태${RESET}
+    ${WHITE}tfx team attach${RESET}    ${GRAY}tmux 세션 연결${RESET}
+    ${WHITE}tfx team send${RESET} ${DIM}N "msg"${RESET}  ${GRAY}Pane N에 입력${RESET}
+    ${WHITE}tfx team stop${RESET}      ${GRAY}graceful 종료${RESET}
+    ${WHITE}tfx team kill${RESET}      ${GRAY}모든 팀 세션 강제 종료${RESET}
+    ${WHITE}tfx team list${RESET}      ${GRAY}활성 세션 목록${RESET}
+`);
+}
+
+// ── 메인 진입점 ──
+
+/**
+ * tfx team 서브커맨드 라우터
+ * bin/triflux.mjs에서 호출
+ */
+export async function cmdTeam() {
+  const sub = process.argv[3];
+
+  switch (sub) {
+    case "status":  return teamStatus();
+    case "attach":  return teamAttach();
+    case "stop":    return teamStop();
+    case "kill":    return teamKill();
+    case "send":    return teamSend();
+    case "list":    return teamList();
+    case "help": case "--help": case "-h":
+      return teamHelp();
+    case undefined:
+      return teamHelp();
+    default:
+      return teamStart();
+  }
+}

package/hub/team/dashboard.mjs

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+// hub/team/dashboard.mjs — 실시간 팀 상태 표시
+// 실행: watch -n 1 -c 'node hub/team/dashboard.mjs --session tfx-team-xxx'
+// 또는: node hub/team/dashboard.mjs --session tfx-team-xxx (단일 출력)
+import { get } from "node:http";
+import { capturePaneOutput } from "./session.mjs";
+
+// ── 색상 ──
+const AMBER = "\x1b[38;5;214m";
+const GREEN = "\x1b[38;5;82m";
+const RED = "\x1b[38;5;196m";
+const GRAY = "\x1b[38;5;245m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+
+/**
+ * Hub /status 엔드포인트 조회
+ * @param {string} hubUrl — 예: http://127.0.0.1:27888
+ * @returns {Promise<object|null>}
+ */
+function fetchStatus(hubUrl) {
+  return new Promise((resolve) => {
+    const url = `${hubUrl}/status`;
+    const req = get(url, { timeout: 2000 }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+    req.on("error", () => resolve(null));
+    req.on("timeout", () => {
+      req.destroy();
+      resolve(null);
+    });
+  });
+}
+
+/**
+ * 진행률 바 생성
+ * @param {number} pct — 0~100
+ * @param {number} width — 바 너비 (기본 8)
+ * @returns {string}
+ */
+function progressBar(pct, width = 8) {
+  const filled = Math.round((pct / 100) * width);
+  const empty = width - filled;
+  return `${GREEN}${"█".repeat(filled)}${GRAY}${"░".repeat(empty)}${RESET}`;
+}
+
+/**
+ * 업타임 포맷
+ * @param {number} ms
+ * @returns {string}
+ */
+function formatUptime(ms) {
+  if (ms < 60000) return `${Math.round(ms / 1000)}초`;
+  if (ms < 3600000) return `${Math.round(ms / 60000)}분`;
+  return `${Math.round(ms / 3600000)}시간`;
+}
+
+/**
+ * 대시보드 렌더링
+ * @param {string} sessionName — tmux 세션 이름
+ * @param {object} opts
+ * @param {string} opts.hubUrl — Hub URL (기본 http://127.0.0.1:27888)
+ * @param {object} opts.teamState — team-state.json 내용
+ */
+export async function renderDashboard(sessionName, opts = {}) {
+  const { hubUrl = "http://127.0.0.1:27888", teamState = {} } = opts;
+  const W = 50;
+  const border = "─".repeat(W);
+
+  // Hub 상태 조회
+  const status = await fetchStatus(hubUrl);
+  const hubOnline = !!status;
+  const hubState = hubOnline ? `${GREEN}● online${RESET}` : `${RED}● offline${RESET}`;
+  const uptime = status?.hub?.uptime ? formatUptime(status.hub.uptime) : "-";
+  const queueSize = status?.hub?.queue_depth ?? 0;
+
+  // 헤더
+  console.log(`${AMBER}┌─ ${sessionName} ${GRAY}${"─".repeat(Math.max(0, W - sessionName.length - 3))}${AMBER}┐${RESET}`);
+  console.log(`${AMBER}│${RESET} Hub: ${hubState}  Uptime: ${DIM}${uptime}${RESET}  Queue: ${DIM}${queueSize}${RESET}`);
+  console.log(`${AMBER}│${RESET}`);
+
+  // 에이전트 상태
+  const panes = teamState?.panes || {};
+  const paneEntries = Object.entries(panes).filter(([, v]) => v.role !== "dashboard");
+
+  if (paneEntries.length === 0) {
+    console.log(`${AMBER}│${RESET}  ${DIM}에이전트 정보 없음${RESET}`);
+  } else {
+    for (const [paneTarget, paneInfo] of paneEntries) {
+      const { cli = "?", agentId = "?", subtask = "" } = paneInfo;
+      const label = `[${agentId}]`;
+      const cliTag = cli.charAt(0).toUpperCase() + cli.slice(1);
+
+      // Hub에서 에이전트 상태 확인
+      const agentStatus = status?.agents?.find?.((a) => a.agent_id === agentId);
+      const online = agentStatus ? `${GREEN}● online${RESET}` : `${GRAY}○ -${RESET}`;
+
+      // 진행률 추정 (메시지 기반, 단순 휴리스틱)
+      const msgCount = agentStatus?.message_count ?? 0;
+      const pct = msgCount === 0 ? 0 : Math.min(100, msgCount * 25);
+
+      console.log(`${AMBER}│${RESET}  ${BOLD}${label}${RESET} ${cliTag}  ${online}  ${progressBar(pct)} ${DIM}${pct}%${RESET}`);
+
+      // pane 미리보기 (마지막 2줄)
+      const preview = capturePaneOutput(paneTarget, 2)
+        .split("\n")
+        .filter(Boolean)
+        .slice(-1)[0] || "";
+      if (preview) {
+        const truncated = preview.length > W - 8 ? preview.slice(0, W - 11) + "..." : preview;
+        console.log(`${AMBER}│${RESET}    ${DIM}> ${truncated}${RESET}`);
+      }
+      console.log(`${AMBER}│${RESET}`);
+    }
+  }
+
+  // 푸터
+  console.log(`${AMBER}└${GRAY}${border}${AMBER}┘${RESET}`);
+}
+
+/** team-state.json 로드 */
+async function loadTeamState() {
+  try {
+    const { readFileSync } = await import("node:fs");
+    const { join } = await import("node:path");
+    const { homedir } = await import("node:os");
+    const statePath = join(homedir(), ".claude", "cache", "tfx-hub", "team-state.json");
+    return JSON.parse(readFileSync(statePath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+// ── CLI 실행 (자체 갱신 루프 — watch 불필요) ──
+if (process.argv[1]?.includes("dashboard.mjs")) {
+  const sessionIdx = process.argv.indexOf("--session");
+  const sessionName = sessionIdx !== -1 ? process.argv[sessionIdx + 1] : null;
+  const intervalSec = parseInt(process.argv[process.argv.indexOf("--interval") + 1] || "2", 10);
+
+  if (!sessionName) {
+    console.error("사용법: node dashboard.mjs --session <세션이름> [--interval 2]");
+    process.exit(1);
+  }
+
+  // Ctrl+C로 종료
+  process.on("SIGINT", () => process.exit(0));
+
+  // 갱신 루프
+  while (true) {
+    const teamState = await loadTeamState();
+    // 화면 클리어 (ANSI)
+    process.stdout.write("\x1b[2J\x1b[H");
+    await renderDashboard(sessionName, { teamState });
+    console.log(`${DIM}  ${intervalSec}초 간격 갱신 | Ctrl+C로 종료${RESET}`);
+    await new Promise((r) => setTimeout(r, intervalSec * 1000));
+  }
+}

package/hub/team/orchestrator.mjs

@@ -0,0 +1,102 @@
+// hub/team/orchestrator.mjs — 작업 분배 + 프롬프트 구성
+// 의존성: pane.mjs만 사용
+import { injectPrompt } from "./pane.mjs";
+
+/**
+ * 작업 분해 (LLM 없이 구분자 기반)
+ * @param {string} taskDescription — 전체 작업 설명
+ * @param {number} agentCount — 에이전트 수
+ * @returns {string[]} 각 에이전트의 서브태스크
+ */
+export function decomposeTask(taskDescription, agentCount) {
+  if (agentCount <= 0) return [];
+  if (agentCount === 1) return [taskDescription];
+
+  // '+', ',', '\n' 기준으로 분리
+  const parts = taskDescription
+    .split(/[+,\n]+/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  if (parts.length === 0) return [taskDescription];
+
+  // 에이전트보다 서브태스크가 적으면 마지막 에이전트에 전체 태스크 부여
+  if (parts.length < agentCount) {
+    const result = [...parts];
+    while (result.length < agentCount) {
+      result.push(taskDescription);
+    }
+    return result;
+  }
+
+  // 에이전트보다 서브태스크가 많으면 앞에서부터 N개, 나머지는 마지막에 합침
+  if (parts.length > agentCount) {
+    const result = parts.slice(0, agentCount - 1);
+    result.push(parts.slice(agentCount - 1).join(" + "));
+    return result;
+  }
+
+  return parts;
+}
+
+/**
+ * 에이전트별 초기 프롬프트 생성
+ * @param {string} subtask — 이 에이전트의 서브태스크
+ * @param {object} config
+ * @param {string} config.cli — codex/gemini/claude
+ * @param {string} config.agentId — 에이전트 식별자
+ * @param {string} config.hubUrl — Hub URL
+ * @param {string} config.sessionName — tmux 세션 이름
+ * @returns {string}
+ */
+export function buildPrompt(subtask, config) {
+  const { cli, agentId, hubUrl } = config;
+
+  // Hub MCP 도구 사용 안내 (CLI별 차이 없이 공통)
+  const hubInstructions = `
+[Hub 메시지 도구]
+tfx-hub MCP 서버(${hubUrl})가 연결되어 있다면 아래 도구를 사용할 수 있다:
+- register: 에이전트 등록 (agent_id: "${agentId}", cli: "${cli}")
+- publish: 결과 발행 (topic: "task.result")
+- poll_messages: 다른 에이전트 메시지 수신
+- ask: 다른 에이전트에게 질문
+
+MCP 도구가 없으면 REST API 사용:
+  curl -s -X POST ${hubUrl.replace("/mcp", "")}/bridge/register -H 'Content-Type: application/json' -d '{"agent_id":"${agentId}","cli":"${cli}","timeout_sec":600}'
+  curl -s -X POST ${hubUrl.replace("/mcp", "")}/bridge/result -H 'Content-Type: application/json' -d '{"agent_id":"${agentId}","topic":"task.result","payload":{"summary":"결과 요약"}}'
+`.trim();
+
+  return `너는 tfx-hub 팀의 에이전트 ${agentId}이다.
+
+[작업]
+${subtask}
+
+[규칙]
+- 작업 완료 후 반드시 결과를 Hub에 발행하라
+- 에이전트 ID: ${agentId}
+- 다른 에이전트 결과가 필요하면 poll_messages로 확인
+
+${hubInstructions}
+
+작업을 시작하라.`;
+}
+
+/**
+ * 팀 오케스트레이션 실행 — 각 pane에 프롬프트 주입
+ * @param {string} sessionName — tmux 세션 이름
+ * @param {Array<{target: string, cli: string, subtask: string}>} assignments
+ * @param {object} opts
+ * @param {string} opts.hubUrl — Hub URL
+ * @returns {Promise<void>}
+ */
+export async function orchestrate(sessionName, assignments, opts = {}) {
+  const { hubUrl = "http://127.0.0.1:27888/mcp" } = opts;
+
+  for (const { target, cli, subtask } of assignments) {
+    const agentId = `${cli}-${target.split(".").pop()}`;
+    const prompt = buildPrompt(subtask, { cli, agentId, hubUrl, sessionName });
+    injectPrompt(target, prompt);
+    // pane 간 100ms 간격 (안정성)
+    await new Promise((r) => setTimeout(r, 100));
+  }
+}

package/hub/team/pane.mjs

@@ -0,0 +1,101 @@
+// hub/team/pane.mjs — pane별 CLI 실행 + stdin 주입
+// 의존성: child_process, fs, os, path (Node.js 내장)만 사용
+import { execSync } from "node:child_process";
+import { writeFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { detectMultiplexer } from "./session.mjs";
+
+/** Windows 경로를 MSYS2/Git Bash tmux용 POSIX 경로로 변환 */
+function toTmuxPath(p) {
+  if (process.platform !== "win32") return p;
+  // C:\Users\... → /c/Users/...
+  return p.replace(/\\/g, "/").replace(/^([A-Za-z]):/, (_, d) => `/${d.toLowerCase()}`);
+}
+
+/** tmux 커맨드 실행 (session.mjs와 동일 패턴) */
+function tmux(args, opts = {}) {
+  const mux = detectMultiplexer();
+  if (!mux) throw new Error("tmux 미발견");
+  const prefix = mux === "wsl-tmux" ? "wsl tmux" : "tmux";
+  const result = execSync(`${prefix} ${args}`, {
+    encoding: "utf8",
+    timeout: 10000,
+    stdio: ["pipe", "pipe", "pipe"],
+    ...opts,
+  });
+  return result != null ? result.trim() : "";
+}
+
+/**
+ * CLI 에이전트 시작 커맨드 생성
+ * @param {'codex'|'gemini'|'claude'} cli
+ * @returns {string} 실행할 셸 커맨드
+ */
+export function buildCliCommand(cli) {
+  switch (cli) {
+    case "codex":
+      // interactive REPL 진입 — MCP는 ~/.codex/config.json에 사전 등록
+      return "codex";
+    case "gemini":
+      // interactive 모드 — MCP는 ~/.gemini/settings.json에 사전 등록
+      return "gemini";
+    case "claude":
+      // interactive 모드
+      return "claude";
+    default:
+      return cli; // 커스텀 CLI 허용
+  }
+}
+
+/**
+ * tmux pane에 CLI 시작
+ * @param {string} target — 예: tfx-team-abc:0.1
+ * @param {string} command — 실행할 커맨드
+ */
+export function startCliInPane(target, command) {
+  // 특수문자 이스케이프: 작은따옴표 내부에서 안전하도록
+  const escaped = command.replace(/'/g, "'\\''");
+  tmux(`send-keys -t ${target} '${escaped}' Enter`);
+}
+
+/**
+ * pane에 프롬프트 주입 (load-buffer + paste-buffer 방식)
+ * 멀티라인 + 특수문자 안전, 크기 제한 없음
+ * @param {string} target — 예: tfx-team-abc:0.1
+ * @param {string} prompt — 주입할 텍스트
+ */
+export function injectPrompt(target, prompt) {
+  // 임시 파일에 프롬프트 저장
+  const tmpDir = join(tmpdir(), "tfx-team");
+  mkdirSync(tmpDir, { recursive: true });
+
+  // pane ID를 파일명에 포함 (충돌 방지)
+  const safeTarget = target.replace(/[:.]/g, "-");
+  const tmpFile = join(tmpDir, `prompt-${safeTarget}-${Date.now()}.txt`);
+
+  try {
+    writeFileSync(tmpFile, prompt, "utf8");
+
+    // tmux load-buffer → paste-buffer → Enter (Windows 경로 변환 필요)
+    tmux(`load-buffer ${toTmuxPath(tmpFile)}`);
+    tmux(`paste-buffer -t ${target}`);
+    tmux(`send-keys -t ${target} Enter`);
+  } finally {
+    // 임시 파일 정리
+    try {
+      unlinkSync(tmpFile);
+    } catch {
+      // 정리 실패 무시
+    }
+  }
+}
+
+/**
+ * pane에 키 입력 전송
+ * @param {string} target — 예: tfx-team-abc:0.1
+ * @param {string} keys — tmux 키 표현 (예: 'C-c', 'Enter')
+ */
+export function sendKeys(target, keys) {
+  tmux(`send-keys -t ${target} ${keys}`);
+}

package/hub/team/session.mjs

@@ -0,0 +1,186 @@
+// hub/team/session.mjs — tmux 세션 생명주기 관리
+// 의존성: child_process (Node.js 내장)만 사용
+import { execSync } from "node:child_process";
+
+/** tmux 실행 가능 여부 확인 */
+function hasTmux() {
+  try {
+    execSync("tmux -V", { stdio: "ignore", timeout: 3000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** WSL2 내 tmux 사용 가능 여부 (Windows 전용) */
+function hasWslTmux() {
+  try {
+    execSync("wsl tmux -V", { stdio: "ignore", timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 터미널 멀티플렉서 감지
+ * @returns {'tmux'|'wsl-tmux'|null}
+ */
+export function detectMultiplexer() {
+  if (hasTmux()) return "tmux";
+  if (process.platform === "win32" && hasWslTmux()) return "wsl-tmux";
+  return null;
+}
+
+/**
+ * tmux 커맨드 실행 (wsl-tmux 투명 지원)
+ * @param {string} args — tmux 서브커맨드 + 인자
+ * @param {object} opts — execSync 옵션
+ * @returns {string} stdout
+ */
+function tmux(args, opts = {}) {
+  const mux = detectMultiplexer();
+  if (!mux) {
+    throw new Error(
+      "tmux 미발견.\n\n" +
+      "tfx team은 tmux가 필요합니다:\n" +
+      "  WSL2:   wsl sudo apt install tmux\n" +
+      "  macOS:  brew install tmux\n" +
+      "  Linux:  apt install tmux\n\n" +
+      "Windows에서는 WSL2를 권장합니다:\n" +
+      "  1. wsl --install\n" +
+      "  2. wsl sudo apt install tmux\n" +
+      "  3. tfx team \"작업\"  (자동으로 WSL tmux 사용)"
+    );
+  }
+  const prefix = mux === "wsl-tmux" ? "wsl tmux" : "tmux";
+  const result = execSync(`${prefix} ${args}`, {
+    encoding: "utf8",
+    timeout: 10000,
+    stdio: ["pipe", "pipe", "pipe"],
+    ...opts,
+  });
+  // stdio: "ignore" 시 execSync가 null 반환 — 안전 처리
+  return result != null ? result.trim() : "";
+}
+
+/**
+ * tmux 세션 생성 + 레이아웃 분할
+ * @param {string} sessionName — 세션 이름
+ * @param {object} opts
+ * @param {'2x2'|'1xN'} opts.layout — 레이아웃 (기본 2x2)
+ * @param {number} opts.paneCount — pane 수 (기본 4)
+ * @returns {{ sessionName: string, panes: string[] }}
+ */
+export function createSession(sessionName, opts = {}) {
+  const { layout = "2x2", paneCount = 4 } = opts;
+
+  // 기존 세션 정리
+  if (sessionExists(sessionName)) {
+    killSession(sessionName);
+  }
+
+  // 새 세션 생성 (detached)
+  tmux(`new-session -d -s ${sessionName} -x 220 -y 55`);
+
+  const panes = [`${sessionName}:0.0`];
+
+  if (layout === "2x2" && paneCount >= 3) {
+    // 2x2 그리드: 좌|우 → 좌상/좌하 → 우상/우하
+    tmux(`split-window -h -t ${sessionName}:0`);
+    tmux(`split-window -v -t ${sessionName}:0.0`);
+    if (paneCount >= 4) {
+      tmux(`split-window -v -t ${sessionName}:0.2`);
+    }
+    // pane ID 재수집
+    panes.length = 0;
+    for (let i = 0; i < Math.min(paneCount, 4); i++) {
+      panes.push(`${sessionName}:0.${i}`);
+    }
+  } else {
+    // 1xN 수직 분할
+    for (let i = 1; i < paneCount; i++) {
+      tmux(`split-window -v -t ${sessionName}:0`);
+    }
+    // even-vertical 레이아웃 적용
+    tmux(`select-layout -t ${sessionName}:0 even-vertical`);
+    panes.length = 0;
+    for (let i = 0; i < paneCount; i++) {
+      panes.push(`${sessionName}:0.${i}`);
+    }
+  }
+
+  return { sessionName, panes };
+}
+
+/**
+ * tmux 세션 연결 (포그라운드 전환)
+ * @param {string} sessionName
+ */
+export function attachSession(sessionName) {
+  const mux = detectMultiplexer();
+  const prefix = mux === "wsl-tmux" ? "wsl tmux" : "tmux";
+  // stdio: inherit로 사용자에게 제어권 반환
+  execSync(`${prefix} attach-session -t ${sessionName}`, {
+    stdio: "inherit",
+    timeout: 0, // 타임아웃 없음 (사용자가 detach할 때까지)
+  });
+}
+
+/**
+ * tmux 세션 존재 확인
+ * @param {string} sessionName
+ * @returns {boolean}
+ */
+export function sessionExists(sessionName) {
+  try {
+    tmux(`has-session -t ${sessionName}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * tmux 세션 종료
+ * @param {string} sessionName
+ */
+export function killSession(sessionName) {
+  try {
+    tmux(`kill-session -t ${sessionName}`, { stdio: "ignore" });
+  } catch {
+    // 이미 종료된 세션 — 무시
+  }
+}
+
+/**
+ * tfx-team- 접두사 세션 목록
+ * @returns {string[]}
+ */
+export function listSessions() {
+  try {
+    const output = tmux('list-sessions -F "#{session_name}"');
+    return output
+      .split("\n")
+      .filter((s) => s.startsWith("tfx-team-"));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * pane 마지막 N줄 캡처
+ * @param {string} target — 예: tfx-team-abc:0.1
+ * @param {number} lines — 캡처할 줄 수 (기본 5)
+ * @returns {string}
+ */
+export function capturePaneOutput(target, lines = 5) {
+  try {
+    // -l 플래그는 일부 tmux 빌드(MSYS2)에서 미지원 → 전체 캡처 후 JS에서 절삭
+    const full = tmux(`capture-pane -t ${target} -p`);
+    const nonEmpty = full.split("\n").filter((l) => l.trim() !== "");
+    return nonEmpty.slice(-lines).join("\n");
+  } catch {
+    return "";
+  }
+}

package/package.json

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

package/skills/tfx-team/SKILL.md

@@ -0,0 +1,172 @@
+---
+name: tfx-team
+description: 멀티-CLI 팀 모드. tfx-auto와 동일한 트리아지/분해, 실행은 tmux + Hub 기반 interactive 세션.
+triggers:
+  - tfx-team
+argument-hint: '"작업 설명" | --agents codex,gemini "작업" | status | stop'
+---
+
+# tfx-team — tmux + Hub 기반 멀티-CLI 팀 오케스트레이터
+
+> tfx-auto와 **동일한 트리아지/분해 로직**, 실행 백엔드만 다름.
+>
+> | | tfx-auto | tfx-team |
+> |--|----------|----------|
+> | 트리아지 | Codex 분류 → Opus 분해 | **동일** |
+> | 실행 | `tfx-route.sh` one-shot | **tmux pane interactive** |
+> | 관찰 | stdout 반환 후 종료 | **실시간 네이티브 터미널** |
+> | 통신 | 없음 (독립 실행) | **Hub MCP 메시지 버스** |
+> | 개입 | 불가 | **`tfx team send N "추가 지시"`** |
+
+## 사용법
+
+```
+/tfx-team "인증 리팩터링 + UI 개선 + 보안 리뷰"
+/tfx-team --agents codex,gemini "프론트+백엔드"
+/tfx-team status
+/tfx-team stop
+```
+
+## 실행 워크플로우
+
+### Phase 1: 입력 파싱
+
+```
+입력: "3:codex 리뷰"         → 수동 모드: N=3, agent=codex
+입력: "인증 + UI + 테스트"    → 자동 모드: Codex 분류 → Opus 분해
+입력: "status"               → 제어 커맨드 (tfx team status)
+입력: "stop"                 → 제어 커맨드 (tfx team stop)
+```
+
+**제어 커맨드 감지:**
+- `status`, `stop`, `kill`, `attach`, `list`, `send` → `Bash("node bin/triflux.mjs team {cmd}")` 직행
+- 그 외 → Phase 2 트리아지
+
+### Phase 2: 트리아지 (tfx-auto와 동일)
+
+#### 자동 모드 — Codex 분류 → Opus 분해
+
+```bash
+# Step 2a: Codex 분류 (무료)
+Bash("codex exec --full-auto --skip-git-repo-check '다음 작업을 분석하고 각 부분에 적합한 agent를 분류하라.
+
+  agent 선택:
+  - codex: 코드 구현/수정/분석/리뷰/디버깅/설계 (기본값)
+  - gemini: 문서/UI/디자인/멀티모달
+  - claude: 코드베이스 탐색/테스트 실행/검증 (최후 수단)
+
+  작업: {task}
+
+  JSON:
+  { \"parts\": [{ \"description\": \"...\", \"agent\": \"codex|gemini|claude\" }] }
+'")
+```
+
+> Codex 분류 실패 시 → Opus(오케스트레이터)가 직접 분류+분해
+
+```
+# Step 2b: Opus 인라인 분해
+분류 결과 → 에이전트 배정:
+  codex → --agents에 codex 추가
+  gemini → --agents에 gemini 추가
+  claude → --agents에 claude 추가 (또는 codex로 대체 — claude는 최후 수단)
+
+결과: agents 배열 + subtasks 배열
+```
+
+#### 수동 모드 (`N:agent_type`)
+
+Codex 분류 건너뜀 → Opus가 직접 N개 서브태스크 분해.
+
+### Phase 3: tmux 팀 실행
+
+트리아지 결과를 `tfx team` CLI로 실행:
+
+```bash
+# agents 배열과 작업을 tfx team에 전달
+Bash("node {PKG_ROOT}/bin/triflux.mjs team --agents {agents.join(',')} \"{task}\"")
+```
+
+**내부 동작 (hub/team/ 모듈):**
+1. Hub lazy-start (`hub/server.mjs`)
+2. tmux 세션 생성 (2x2 or 1xN 레이아웃)
+3. Pane 0: Dashboard (실시간 상태)
+4. Pane 1~N: 각 CLI interactive 모드 시작 (codex/gemini/claude)
+5. 3초 대기 (CLI 초기화)
+6. 각 pane에 서브태스크 프롬프트 주입 (load-buffer + paste-buffer)
+7. tmux attach → 사용자에게 제어권
+
+### Phase 4: 실시간 관찰 + 개입
+
+tmux 세션 내에서:
+- `Ctrl+B → 방향키`: pane 전환
+- `Ctrl+B → D`: 세션 분리 (백그라운드)
+- `Ctrl+B → Z`: pane 전체화면
+
+세션 분리 후 제어:
+```bash
+/tfx-team status            # 팀 상태 확인
+/tfx-team send 1 "추가 지시"  # Pane 1에 입력
+/tfx-team attach            # 세션 재연결
+/tfx-team stop              # graceful 종료
+```
+
+### Phase 5: 에이전트 간 통신
+
+Hub MCP 도구가 각 CLI에 등록되어 있으면 자동 통신:
+- `register`: 에이전트 등록
+- `publish`: 결과 발행 (topic: task.result)
+- `poll_messages`: 다른 에이전트 메시지 수신
+- `ask`: 다른 에이전트에게 질문
+
+MCP 미등록 시 REST 폴백 (프롬프트에 curl 명령 포함).
+
+## 에이전트 매핑
+
+| 분류 결과 | CLI | 비고 |
+|----------|-----|------|
+| codex | `codex` (interactive) | MCP: ~/.codex/config.json |
+| gemini | `gemini` (interactive) | MCP: ~/.gemini/settings.json |
+| claude | `claude` (interactive) | MCP: .mcp.json |
+
+> **중요:** tfx-auto와 달리 세부 에이전트(executor, debugger 등)로 분류하지 않음.
+> tmux pane에는 CLI 단위(codex/gemini/claude)로 실행하고,
+> 프롬프트에 역할(구현/리뷰/디버깅)을 명시하여 CLI가 알아서 수행.
+
+## tfx-auto와의 차이 요약
+
+| 항목 | tfx-auto | tfx-team |
+|------|----------|----------|
+| 트리아지 | Codex 분류 → Opus 분해 | **동일** |
+| 실행 단위 | 에이전트(executor, reviewer 등) | CLI(codex, gemini, claude) |
+| 실행 방식 | `tfx-route.sh` (one-shot, 블랙박스) | tmux pane (interactive, 관찰 가능) |
+| 결과 수집 | stdout 파싱 | Hub publish/poll |
+| 개입 | 불가 | `tfx team send` |
+| 통신 | 없음 | Hub MCP 메시지 버스 |
+| Dashboard | 없음 | Pane 0 실시간 상태 |
+| tmux 필요 | 아니오 | **예** |
+| 종료 | 자동 (실행 완료) | 수동 (`tfx team stop`) |
+
+## 전제 조건
+
+- **tmux** — 필수 (Git Bash: v3.6a, WSL2, macOS, Linux)
+- **codex/gemini CLI** — 해당 에이전트 사용 시
+- **tfx setup** — Hub MCP 자동 등록 (사전 실행 권장)
+
+## 에러 처리
+
+| 에러 | 처리 |
+|------|------|
+| tmux 미설치 | 안내 메시지 + WSL2 설치 가이드 |
+| Hub 시작 실패 | `tfx hub start` 수동 실행 안내 |
+| CLI 미설치 | 해당 pane 건너뜀 + 경고 |
+| MCP 미등록 | REST 폴백 (curl) |
+| Codex 분류 실패 | Opus 직접 분류+분해 |
+
+## 관련
+
+| 항목 | 설명 |
+|------|------|
+| `hub/team/` | tmux + Hub 팀 모듈 (session, pane, orchestrator, dashboard, cli) |
+| `tfx-auto` | one-shot 실행 오케스트레이터 (기존, 병행 유지) |
+| `tfx-hub` | MCP 메시지 버스 관리 (start/stop/status) |