triflux 6.0.19 → 6.0.21

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

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

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

@@ -10,6 +10,7 @@ export function parseTeamArgs(args = []) {
   let autoAttach = false;
   let progressive = true;
   let timeoutSec = 300;
+  let verbose = false;
 
   for (let index = 0; index < args.length; index += 1) {
     const current = args[index];
@@ -29,6 +30,10 @@ export function parseTeamArgs(args = []) {
       }
     } else if (current === "--auto-attach") {
       autoAttach = true;
+    } else if (current === "--no-auto-attach") {
+      autoAttach = false;
+    } else if (current === "--verbose") {
+      verbose = true;
     } else if (current === "--no-progressive") {
       progressive = false;
     } else if (current === "--timeout" && args[index + 1]) {
@@ -48,5 +53,6 @@ export function parseTeamArgs(args = []) {
     autoAttach,
     progressive,
     timeoutSec,
+    verbose,
   };
 }

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

@@ -4,23 +4,21 @@ import { ok, warn } from "../../render.mjs";
 import { buildTasks } from "../../services/task-model.mjs";
 import { clearTeamState } from "../../services/state-store.mjs";
 
-export async function startHeadlessTeam({ sessionId, task, lead, agents, subtasks, layout, assigns, autoAttach, progressive, timeoutSec }) {
-  console.log(`  ${AMBER}모드: headless (Lead-Direct v6.0.0)${RESET}`);
-
+export async function startHeadlessTeam({ sessionId, task, lead, agents, subtasks, layout, assigns, autoAttach, progressive, timeoutSec, verbose }) {
   // --assign이 있으면 그것을 사용, 없으면 agents+subtasks 조합
   const assignments = assigns && assigns.length > 0
     ? assigns.map((a, i) => ({ cli: a.cli, prompt: a.prompt, role: a.role || `worker-${i + 1}` }))
     : subtasks.map((subtask, i) => ({ cli: agents[i] || agents[0], prompt: subtask, role: `worker-${i + 1}` }));
 
-  ok(`헤드리스 실행 시작 (${assignments.length}워커, progressive=${progressive !== false})`);
+  ok(`headless ${assignments.length}워커 시작`);
 
   const handle = await runHeadlessInteractive(sessionId, assignments, {
     timeoutSec: timeoutSec || 300,
     layout,
-    autoAttach: autoAttach !== false, // 기본 true
-    progressive: progressive !== false, // 기본 true
-    progressIntervalSec: 10,
-    onProgress(event) {
+    autoAttach: !!autoAttach,
+    progressive: progressive !== false,
+    progressIntervalSec: verbose ? 10 : 0,
+    onProgress: verbose ? function onProgress(event) {
       if (event.type === "session_created") {
         console.log(`  ${DIM}세션: ${event.sessionName}${RESET}`);
       } else if (event.type === "worker_added") {
@@ -34,28 +32,36 @@ export async function startHeadlessTeam({ sessionId, task, lead, agents, subtask
         const icon = event.matched && event.exitCode === 0 ? `${GREEN}✓${RESET}` : `${AMBER}✗${RESET}`;
         console.log(`  ${icon} [${event.paneName}] ${event.cli} exit=${event.exitCode}${event.sessionDead ? " (dead)" : ""}`);
       }
-    },
+    } : undefined,
   });
 
-  // 결과 요약
+  // 최소 결과 요약
   const results = handle.results;
   const succeeded = results.filter((r) => r.matched && r.exitCode === 0);
   const failed = results.filter((r) => !r.matched || r.exitCode !== 0);
 
-  console.log(`\n  ${GREEN}${BOLD}헤드리스 실행 완료${RESET}`);
-  console.log(`  ${DIM}성공: ${succeeded.length} / 실패: ${failed.length} / 전체: ${results.length}${RESET}`);
+  ok(`헤드리스 완료: ${succeeded.length}성공 / ${failed.length}실패 / ${results.length}전체`);
 
   if (failed.length > 0) {
-    warn("실패 워커:");
-    for (const r of failed) console.log(`    ${r.paneName} (${r.cli}): exit=${r.exitCode}`);
+    for (const r of failed) console.log(`  ${AMBER}✗${RESET} ${r.paneName} (${r.cli}) exit=${r.exitCode}`);
   }
 
-  // 결과 출력 + JSON stdout
+  // 결과 파일 경로 (Lead가 필요시 Read()로 확인)
   for (const r of results) {
-    if (r.output) {
-      const preview = r.output.length > 200 ? `${r.output.slice(0, 200)}…` : r.output;
-      console.log(`\n  ${DIM}── ${r.paneName} (${r.cli}${r.role ? `, ${r.role}` : ""}) ──${RESET}`);
-      console.log(`  ${preview}`);
+    const icon = r.matched && r.exitCode === 0 ? `${GREEN}✓${RESET}` : `${AMBER}✗${RESET}`;
+    if (r.resultFile) {
+      console.log(`  ${icon} ${r.paneName}: ${r.resultFile}`);
+    }
+  }
+
+  // --verbose: 기존 장황한 출력 (200자 preview)
+  if (verbose) {
+    for (const r of results) {
+      if (r.output) {
+        const preview = r.output.length > 200 ? `${r.output.slice(0, 200)}…` : r.output;
+        console.log(`\n  ${DIM}── ${r.paneName} (${r.cli}${r.role ? `, ${r.role}` : ""}) ──${RESET}`);
+        console.log(`  ${preview}`);
+      }
     }
   }
 

package/hub/team/headless.mjs

@@ -6,7 +6,7 @@
 import { join } from "node:path";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { execSync, execFileSync } from "node:child_process";
+import { execSync, execFileSync, spawn } from "node:child_process";
 import {
   createPsmuxSession,
   killPsmuxSession,
@@ -39,14 +39,16 @@ const ANSI_DIM = "\x1b[2m";
 export function buildHeadlessCommand(cli, prompt, resultFile) {
   // 프롬프트의 단일 인용부호를 이스케이프
   const escaped = prompt.replace(/'/g, "''");
+  // Clear-Host: 실행 즉시 이전 PS 프롬프트 + 명령 텍스트를 깨끗이 지움
+  const cls = "Clear-Host; ";
 
   switch (cli) {
     case "codex":
-      return `codex exec '${escaped}' -o '${resultFile}' --color never`;
+      return `${cls}codex exec '${escaped}' -o '${resultFile}' --color never`;
     case "gemini":
-      return `gemini -p '${escaped}' -o text > '${resultFile}' 2>'${resultFile}.err'`;
+      return `${cls}gemini -p '${escaped}' -o text > '${resultFile}' 2>'${resultFile}.err'`;
     case "claude":
-      return `claude -p '${escaped}' --output-format text > '${resultFile}' 2>&1`;
+      return `${cls}claude -p '${escaped}' --output-format text > '${resultFile}' 2>&1`;
     default:
       throw new Error(`지원하지 않는 CLI: ${cli}`);
   }
@@ -156,7 +158,8 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
       const paneName = `worker-${i + 1}`;
       const resultFile = join(RESULT_DIR, `${sessionName}-${paneName}.txt`).replace(/\\/g, "/");
       const cmd = buildHeadlessCommand(assignment.cli, assignment.prompt, resultFile);
-      const dispatch = dispatchCommand(sessionName, paneName, cmd);
+      const scriptDir = join(RESULT_DIR, sessionName);
+      const dispatch = dispatchCommand(sessionName, paneName, cmd, { scriptDir, scriptName: paneName });
 
       // P1 fix: 비-progressive에서는 pane 리네임 금지 — 캡처 로그 경로가 타이틀 기반이므로
       // 리네임하면 waitForCompletion이 "codex (role).log"를 찾지만 실제는 "worker-N.log"로 불일치
@@ -216,6 +219,7 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
       matched: completion.matched,
       exitCode: completion.exitCode,
       output,
+      resultFile: d.resultFile,
       sessionDead: completion.sessionDead || false,
     };
   }));
@@ -238,11 +242,9 @@ export async function runHeadlessWithCleanup(assignments, opts = {}) {
   try {
     return await runHeadless(sessionName, assignments, runOpts);
   } finally {
-    try {
-      killPsmuxSession(sessionName);
-    } catch {
-      // 이미 종료된 세션 — 무시
-    }
+    try { killPsmuxSession(sessionName); } catch { /* 무시 */ }
+    // WT split pane은 psmux 종료 시 셸이 끝나면서 자동으로 닫힘
+    // 수동 close-pane 불필요 (레이스 컨디션으로 WT 에러 발생)
   }
 }
 
@@ -280,6 +282,7 @@ export function applyTrifluxTheme(sessionName) {
  * 반투명 + 비포커스 시 더 투명 + Catppuccin 테마.
  * @returns {boolean} 성공 여부
  */
+
 /**
  * WT 기본 프로필의 폰트 크기를 읽는다.
  * @returns {number} 기본 폰트 크기 (못 읽으면 12)
@@ -359,44 +362,72 @@ export function ensureWtProfile(workerCount = 2) {
  */
 export function autoAttachTerminal(sessionName, opts = {}, workerCount = 2) {
   try {
-    // Windows Terminal이 설치되어 있는지 확인
     execSync("where wt.exe", { stdio: "ignore" });
   } catch {
-    return false; // wt.exe 미설치 — 사용자에게 수동 attach 안내 필요
+    return false;
   }
 
-  // triflux WT 프로필 확보 (투명도 + 테마 + 폰트 크기)
   ensureWtProfile(workerCount);
 
-  const shells = ["pwsh.exe", "powershell.exe"];
-  // 방법 1: split-pane — 같은 WT 창에서 가로 분할
-  // 워커 수에 따라 split 비율 조정: 1-2→30%, 3-4→40%, 5-6→50%, 7+→60%
-  const splitSize = Math.min(0.6, 0.2 + workerCount * 0.05).toFixed(2);
-  if (process.env.WT_SESSION) {
-    for (const shell of shells) {
-      try {
-        // 1) 하단 분할 생성
-        execSync(
-          `wt.exe -w 0 sp -H --size ${splitSize} --profile triflux --title triflux -- ${shell} -Command "psmux attach -t ${sessionName}"`,
-          { stdio: "ignore", timeout: 5000 },
-        );
-        // 2) 포커스를 Claude Code(위 pane)로 되돌림
-        try { execSync(`wt.exe -w 0 mf up`, { stdio: "ignore", timeout: 2000 }); } catch { /* 무시 */ }
-        return true;
-      } catch { /* 다음 shell */ }
-    }
-  }
-  // 방법 2 fallback: 새 탭 (WT_SESSION 없거나 sp 실패 시)
-  for (const shell of shells) {
+  const mode = opts.mode || "auto";
+
+  if (mode === "split" && process.env.WT_SESSION) {
+    // inner split — 같은 WT 창에서 가로 분할. psmux를 직접 실행 (pwsh 불필요).
     try {
-      execSync(
-        `start "" /b wt.exe nt --profile triflux --title triflux -- ${shell} -Command "psmux attach -t ${sessionName}"`,
-        { stdio: "ignore", shell: true, timeout: 5000 },
-      );
+      const child = spawn("wt.exe", [
+        "-w", "0", "sp", "-H", "-s", "0.50",
+        "--profile", "triflux", "--title", "triflux",
+        "--", "psmux", "attach", "-t", sessionName,
+      ], { detached: true, stdio: "ignore" });
+      child.unref();
+      try { spawn("wt.exe", ["-w", "0", "mf", "up"], { detached: true, stdio: "ignore" }).unref(); } catch { /* 무시 */ }
       return true;
+    } catch { /* fallthrough to window */ }
+  }
+
+  // v6.0.22: 읽기전용 뷰어 + 최소화 트릭.
+  // 1. 현재 HWND 캡처 → 2. WT 열기(읽기전용 뷰어) → 3. 새 창 즉시 최소화
+  // → Windows가 자동으로 이전 창에 포커스 복원. 사용자는 작업표시줄에서 확인.
+  const logDir = join(tmpdir(), "psmux-steering", sessionName).replace(/\\/g, "/");
+  const cols = Math.max(100, 60 + workerCount * 15);
+  const rows = Math.max(25, 15 + workerCount * 4);
+
+  // 읽기전용 뷰어 스크립트 생성
+  const viewerScript = join(tmpdir(), "tfx-viewer-" + sessionName + ".ps1").replace(/\\/g, "/");
+  writeFileSync(viewerScript, [
+    "$Host.UI.RawUI.WindowTitle = '" + sessionName + "'",
+    "Write-Host \"`e[38;5;214m⬡ triflux viewer (read-only)`e[0m — " + sessionName + "\"",
+    "Write-Host 'Log: " + logDir + "'",
+    "Write-Host '---'",
+    "for ($i=0; $i -lt 10; $i++) { if (Test-Path '" + logDir + "') { break }; Start-Sleep 1 }",
+    "Get-Content -Path '" + logDir + "\\*.log' -Wait -Tail 50",
+  ].join("\n"), "utf8");
+
+  // v6.0.23: 같은 WT 창에 탭 추가 (-w 0).
+  // WT에 "이전 탭" CLI 명령이 없으므로, 탭 추가 후 Ctrl+Shift+Tab 시뮬레이션.
+  try {
+    const child = spawn("wt.exe", [
+      "-w", "0", "nt",
+      "--profile", "triflux",
+      "--title", sessionName,
+      "--", "pwsh.exe", "-NoProfile", "-NoLogo", "-File", viewerScript,
+    ], { detached: true, stdio: "ignore" });
+    child.unref();
+  } catch {
+    return false;
+  }
+
+  // 300ms 후 Ctrl+Shift+Tab → "이전 탭"으로 복귀 (탭 인덱스 무관)
+  const prevTabScript = "Start-Sleep -Milliseconds 300; Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('^+{TAB}')";
+  for (const shell of ["pwsh.exe", "powershell.exe"]) {
+    try {
+      spawn(shell, ["-NoProfile", "-NonInteractive", "-Command", prevTabScript], {
+        detached: true, stdio: "ignore",
+      }).unref();
+      break;
     } catch { /* 다음 shell */ }
   }
-  return false;
+  return true;
 }
 
 /**
@@ -460,7 +491,8 @@ export async function runHeadlessInteractive(sessionName, assignments, opts = {}
   runOpts.onProgress = (event) => {
     if (autoAttach && event.type === "session_created" && !terminalAttached) {
       terminalAttached = true;
-      autoAttachTerminal(sessionName, {}, assignments.length);
+      // v6.0.20: 항상 별도 창 (포커스 문제 회피)
+      autoAttachTerminal(sessionName, { mode: "window" }, assignments.length);
     }
     if (userOnProgress) userOnProgress(event);
   };
@@ -531,11 +563,13 @@ export async function runHeadlessInteractive(sessionName, assignments, opts = {}
       return psmuxSessionExists(sessionName);
     },
 
-    /** 세션 종료 */
+    /** 세션 종료 — WT pane은 psmux 종료 시 자동으로 닫힘 */
     kill() {
       if (this._killed) return;
       this._killed = true;
       try { killPsmuxSession(sessionName); } catch { /* 무시 */ }
+      // WT split pane은 psmux 종료 → 셸 종료 → 자동 닫힘
+      // 수동 close-pane 불필요 (레이스 컨디션으로 WT 0x80070002 에러 발생)
     },
   };
 

package/hub/team/psmux.mjs

@@ -630,6 +630,7 @@ export function dispatchCommand(sessionName, paneNameOrTarget, commandText) {
 
   const token = randomToken(paneName);
   const wrapped = `${commandText}; $trifluxExit = if ($null -ne $LASTEXITCODE) { [int]$LASTEXITCODE } else { 0 }; Write-Output "${COMPLETION_PREFIX}${token}:$trifluxExit"`;
+
   sendLiteralToPane(pane.paneId, wrapped, true);
 
   return { paneId: pane.paneId, paneName, token, logPath };

package/package.json

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

package/scripts/headless-guard.mjs

@@ -1,62 +1,69 @@
 #!/usr/bin/env node
 /**
- * headless-guard.mjs — PreToolUse 훅 (auto-route 모드)
+ * headless-guard.mjs — PreToolUse 훅 (상시 활성 auto-route)
  *
- * Phase 3 headless 모드 활성 중 Lead가 Bash(tfx-route.sh)로 개별 호출하면
- * deny 대신 자동으로 headless 명령으로 변환한다.
+ * psmux가 설치된 환경에서 Bash(tfx-route.sh) 개별 호출을
+ * 자동으로 headless 명령으로 변환한다.
+ *
+ * v2: 마커 파일 의존 제거. psmux 설치 여부만으로 판단.
+ *     Opus가 SKILL.md를 무시해도 auto-route가 작동한다.
  *
  * 동작:
- * - 마커 존재 + Bash(tfx-route.sh agent prompt mcp) → updatedInput: tfx multi --headless --assign
- * - 마커 존재 + Agent(codex/gemini CLI 워커) → deny (tool 타입 변환 불가, 안내 메시지)
- * - 마커 없음 → 전부 통과
- * - 마커 30분 초과 → 자동 만료 (stale 방지)
+ * - psmux 설치 + Bash(tfx-route.sh) → updatedInput: tfx multi --headless --assign
+ * - psmux 설치 + Bash(codex exec / gemini -p) → deny
+ * - psmux 설치 + Agent(codex/gemini CLI 래핑) → deny
+ * - psmux 미설치 → 전부 통과
  *
- * Exit 0 + stdout JSON: auto-route (updatedInput)
- * Exit 2 + stderr: deny (Agent CLI 래핑만)
- * Exit 0 (no stdout): allow
+ * 성능: psmux 감지 결과를 5분간 캐시 ($TMPDIR/tfx-psmux-check.json)
  */
 
-import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-const LOCK_FILE = join(tmpdir(), "tfx-headless-guard.lock");
-const MAX_AGE_MS = 30 * 60 * 1000; // 30분
+const CACHE_FILE = join(tmpdir(), "tfx-psmux-check.json");
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5분
 
-function isLockActive() {
-  if (!existsSync(LOCK_FILE)) return false;
+function isPsmuxInstalled() {
+  // 캐시 확인
   try {
-    const ts = Number(readFileSync(LOCK_FILE, "utf8").trim());
-    if (Date.now() - ts > MAX_AGE_MS) {
-      unlinkSync(LOCK_FILE);
-      return false;
+    if (existsSync(CACHE_FILE)) {
+      const cache = JSON.parse(readFileSync(CACHE_FILE, "utf8"));
+      if (Date.now() - cache.ts < CACHE_TTL_MS) return cache.ok;
     }
-    return true;
-  } catch {
-    return false;
-  }
+  } catch { /* cache miss */ }
+
+  // psmux -V 실행
+  let ok = false;
+  try {
+    execFileSync("psmux", ["-V"], { timeout: 2000, stdio: "ignore" });
+    ok = true;
+  } catch { /* not installed */ }
+
+  // 캐시 저장
+  try {
+    writeFileSync(CACHE_FILE, JSON.stringify({ ts: Date.now(), ok }));
+  } catch { /* ignore */ }
+
+  return ok;
 }
 
 /**
  * tfx-route.sh 명령에서 agent, prompt를 파싱한다.
- * 형식: bash ~/.claude/scripts/tfx-route.sh {agent} '{prompt}' {mcp} [timeout] [context]
  */
 function parseRouteCommand(cmd) {
-  // MCP 프로필 목록 (tfx-route.sh의 마지막 위치 인자)
   const MCP_PROFILES = ["implement", "analyze", "review", "docs"];
 
-  // 전략: agent명 추출 후, 나머지에서 MCP 프로필을 역방향으로 찾아 프롬프트 경계를 결정
   const agentMatch = cmd.match(/tfx-route\.sh\s+(\S+)\s+/);
   if (!agentMatch) return null;
 
   const agent = agentMatch[1];
   const afterAgent = cmd.slice(agentMatch.index + agentMatch[0].length);
 
-  // MCP 프로필을 역방향으로 찾기
   let mcp = "";
   let promptRaw = afterAgent;
   for (const profile of MCP_PROFILES) {
-    // 프롬프트 뒤에 오는 MCP 프로필 (공백 구분)
     const profileIdx = afterAgent.lastIndexOf(` ${profile}`);
     if (profileIdx >= 0) {
       mcp = profile;
@@ -65,26 +72,24 @@ function parseRouteCommand(cmd) {
     }
   }
 
-  // 프롬프트에서 바깥쪽 따옴표 제거
   const prompt = promptRaw
     .replace(/^['"]/, "")
     .replace(/['"]$/, "")
-    .replace(/'\\''/g, "'")  // bash '\'' → '
-    .replace(/'"'"'/g, "'")  // bash '"'"' → '
+    .replace(/'\\''/g, "'")
+    .replace(/'"'"'/g, "'")
     .trim();
 
   return { agent, prompt, mcp };
 }
 
 function autoRoute(updatedCommand, reason) {
-  const output = {
+  process.stdout.write(JSON.stringify({
     hookSpecificOutput: {
       hookEventName: "PreToolUse",
       updatedInput: { command: updatedCommand },
       additionalContext: reason,
     },
-  };
-  process.stdout.write(JSON.stringify(output));
+  }));
   process.exit(0);
 }
 
@@ -94,7 +99,8 @@ function deny(reason) {
 }
 
 async function main() {
-  if (!isLockActive()) process.exit(0);
+  // psmux 미설치 → 전부 통과
+  if (!isPsmuxInstalled()) process.exit(0);
 
   let raw = "";
   for await (const chunk of process.stdin) raw += chunk;
@@ -109,58 +115,45 @@ async function main() {
   const toolName = input.tool_name || "";
   const toolInput = input.tool_input || {};
 
-  // ── Bash: tfx-route.sh → headless auto-route ──
+  // ── Bash ──
   if (toolName === "Bash") {
     const cmd = toolInput.command || "";
 
-    // 이미 headless 명령이면 통과
+    // headless 명령은 통과
     if (cmd.includes("tfx multi") || cmd.includes("triflux.mjs multi")) {
       process.exit(0);
     }
 
-    // 마커 조작 통과
-    if (cmd.includes("tfx-headless-guard")) {
-      process.exit(0);
-    }
-
-    // codex/gemini 직접 CLI 호출 감지 → deny (auto-route 불가: 원본 agent/role 정보 없음)
+    // codex/gemini 직접 CLI 호출 → deny
     if (/\bcodex\s+exec\b/.test(cmd) || /\bgemini\s+(-p|--prompt)\b/.test(cmd)) {
       deny(
-        "[headless-guard] Phase 3 활성 중. codex/gemini를 직접 호출하지 마세요. " +
-        'Bash("tfx multi --teammate-mode headless --assign \'codex:prompt:role\' ...") 로 headless 엔진에 위임하세요.',
+        "[headless-guard] codex/gemini 직접 호출 대신 headless를 사용하세요. " +
+        'Bash("tfx multi --teammate-mode headless --assign \'codex:prompt:role\' ...")',
       );
     }
 
-    // tfx-route.sh 개별 호출 → headless 자동 변환
-    if (cmd.includes("tfx-route.sh")) {
+    // tfx-route.sh 실행만 감지: 명령이 bash로 시작할 때만 (커밋 메시지/echo 등 무시)
+    if (/^\s*bash\s+.*tfx-route\.sh\s/.test(cmd)) {
       const parsed = parseRouteCommand(cmd);
       if (parsed) {
-        const role = parsed.agent;
-        // 프롬프트에서 싱글쿼트 이스케이프
         const safePrompt = parsed.prompt.replace(/'/g, "'\\''");
-        const headlessCmd =
-          `tfx multi --teammate-mode headless --auto-attach ` +
-          `--assign '${parsed.agent}:${safePrompt}:${role}' --timeout 600`;
         autoRoute(
-          headlessCmd,
-          `[headless-guard] auto-route: tfx-route.sh → headless 변환. 원본 agent=${parsed.agent}, mcp=${parsed.mcp}`,
+          `tfx multi --teammate-mode headless --auto-attach --assign '${parsed.agent}:${safePrompt}:${parsed.agent}' --timeout 600`,
+          `[headless-guard] auto-route: tfx-route.sh ${parsed.agent} → headless. mcp=${parsed.mcp}`,
         );
       }
-      // 파싱 실패 시 deny fallback
       deny(
-        "[headless-guard] Phase 3 활성 중. tfx-route.sh 명령을 headless로 변환할 수 없습니다. " +
-        'Bash("tfx multi --teammate-mode headless --auto-attach --assign \'cli:prompt:role\' ...") 형식을 사용하세요.',
+        "[headless-guard] tfx-route.sh를 headless로 변환 실패. " +
+        'Bash("tfx multi --teammate-mode headless --assign \'cli:prompt:role\' ...") 형식을 사용하세요.',
       );
     }
   }
 
-  // ── Agent: CLI 워커 래핑 시도 → deny (tool 타입 변환 불가) ──
+  // ── Agent: CLI 워커 래핑 → deny ──
   if (toolName === "Agent") {
-    const prompt = (toolInput.prompt || "").toLowerCase();
-    const desc = (toolInput.description || "").toLowerCase();
-    const combined = `${prompt} ${desc}`;
+    const combined = `${(toolInput.prompt || "").toLowerCase()} ${(toolInput.description || "").toLowerCase()}`;
 
-    const cliWorkerPatterns = [
+    const cliPatterns = [
       /codex\s+(exec|run|실행)/,
       /gemini\s+(-p|run|실행)/,
       /tfx-route/,
@@ -168,10 +161,9 @@ async function main() {
       /bash.*gemini/,
     ];
 
-    if (cliWorkerPatterns.some((p) => p.test(combined))) {
+    if (cliPatterns.some((p) => p.test(combined))) {
       deny(
-        "[headless-guard] Phase 3 활성 중. " +
-        "Codex/Gemini를 Agent()로 래핑하지 말고 headless --assign으로 전달하세요. " +
+        "[headless-guard] Codex/Gemini를 Agent()로 래핑하지 마세요. " +
         'Bash("tfx multi --teammate-mode headless --assign \'codex:prompt:role\' ...")',
       );
     }

package/skills/tfx-multi/SKILL.md

@@ -75,29 +75,17 @@ preflight와 Agent 생성을 병렬로 실행하여 사용자 체감 지연을
 
 ### Phase 3: Lead-Direct Headless 실행 (v6.0.0, 기본)
 
-> **MANDATORY: 2개+ CLI 워커 실행 시 headless 엔진 필수**
-> 서브태스크가 2개 이상이면 반드시 아래 `Bash()` 명령으로 headless 엔진을 실행한다.
-> `Agent()` 백그라운드나 `Bash(tfx-route.sh)` 개별 호출로 대체하지 않는다.
+> **MANDATORY: CLI 워커는 headless 엔진으로 실행**
+> CLI 워커(Codex/Gemini)는 반드시 아래 `Bash()` 명령으로 headless 엔진을 통해 실행한다.
+> `Bash(tfx-route.sh)` 개별 호출이나 `Agent()` CLI 래핑은 PreToolUse 훅이 자동 차단/변환한다.
 > headless 엔진이 psmux 세션 생성 → WT 자동 팝업 → CLI dispatch → 결과 수집을 전부 처리한다.
 
-**Step 1 — headless guard 활성화 (Phase 3 진입 시 반드시 먼저 실행):**
-
-```
-Bash("node -e \"require('fs').writeFileSync(require('os').tmpdir()+'/tfx-headless-guard.lock', String(Date.now()))\"")
-```
-
-**Step 2 — headless 엔진 실행 (Lead가 호출하는 유일한 명령):**
+**실행 명령 (Lead가 호출하는 유일한 명령):**
 
 ```
 Bash("tfx multi --teammate-mode headless --auto-attach --assign 'codex:{프롬프트1}:{역할1}' --assign 'gemini:{프롬프트2}:{역할2}' --timeout 600")
 ```
 
-**Step 3 — headless guard 해제 (Phase 3 완료 후):**
-
-```
-Bash("node -e \"try{require('fs').unlinkSync(require('os').tmpdir()+'/tfx-headless-guard.lock')}catch{}\"")
-```
-
 **예시:**
 
 ```