triflux 10.3.4 → 10.7.0

package/bin/triflux.mjs

@@ -1,19 +1,49 @@
 #!/usr/bin/env node
+import { setTimeout as delay } from "node:timers/promises";
+import { execFileSync, execSync, spawn } from "child_process";
 // triflux CLI — setup, doctor, version
-import { copyFileSync, existsSync, readFileSync, readSync, writeFileSync, mkdirSync, chmodSync, readdirSync, unlinkSync, statSync, openSync, closeSync } from "fs";
-import { join, dirname, basename, resolve } from "path";
+import {
+  chmodSync,
+  closeSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  readSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "fs";
 import { homedir, tmpdir } from "os";
-import { execSync, execFileSync, spawn } from "child_process";
+import { basename, dirname, join, resolve } from "path";
 import { fileURLToPath } from "url";
-import { setTimeout as delay } from "node:timers/promises";
 import { loadDelegatorSchemaBundle } from "../hub/delegator/tool-definitions.mjs";
-import { detectMultiplexer, getSessionAttachedCount, killSession, listSessions, tmuxExec } from "../hub/team/session.mjs";
-import { forceCleanupTeam } from "../hub/team/nativeProxy.mjs";
-import { cleanupStaleOmcTeams, inspectStaleOmcTeams } from "../hub/team/staleState.mjs";
+import {
+  checkNetworkAvailability,
+  validateRuntimeCachePaths,
+} from "../hub/lib/cache-guard.mjs";
 import { getPipelineStateDbPath } from "../hub/pipeline/state.mjs";
-import { serializeHandoff } from "../scripts/lib/handoff.mjs";
+import { forceCleanupTeam } from "../hub/team/nativeProxy.mjs";
+import {
+  detectMultiplexer,
+  getSessionAttachedCount,
+  killSession,
+  listSessions,
+  tmuxExec,
+} from "../hub/team/session.mjs";
+import {
+  cleanupStaleOmcTeams,
+  inspectStaleOmcTeams,
+} from "../hub/team/staleState.mjs";
+import {
+  ensureGlobalClaudeRoutingSection,
+  ensureTfxSection,
+  getLatestRoutingTable,
+} from "../scripts/claudemd-sync.mjs";
 import { ensureGeminiProfiles } from "../scripts/lib/gemini-profiles.mjs";
-import { probePsmuxSupport, formatPsmuxInstallGuidance, formatPsmuxUpdateGuidance } from "../scripts/lib/psmux-info.mjs";
+import { serializeHandoff } from "../scripts/lib/handoff.mjs";
 import {
   addRegistryServer,
   createDefaultRegistry,
@@ -25,19 +55,27 @@ import {
   syncRegistryTargets,
 } from "../scripts/lib/mcp-guard-engine.mjs";
 import {
-  SYNC_MAP, SKILL_ALIASES, REQUIRED_CODEX_PROFILES, LEGACY_CODEX_MODELS,
-  syncAliasedSkillDir, hasProfileSection, replaceProfileSection,
-  ensureCodexProfiles, getVersion, cleanupStaleSkills, 
-  extractManagedHookFilename, getManagedRegistryHooks, ensureHooksInSettings,
+  formatPsmuxInstallGuidance,
+  formatPsmuxUpdateGuidance,
+  probePsmuxSupport,
+} from "../scripts/lib/psmux-info.mjs";
+import {
+  cleanupStaleSkills,
   ensureCodexHubServerConfig,
+  ensureCodexProfiles,
+  ensureHooksInSettings,
+  extractManagedHookFilename,
+  getManagedRegistryHooks,
+  getVersion,
+  hasProfileSection,
+  LEGACY_CODEX_MODELS,
+  REQUIRED_CODEX_PROFILES,
+  replaceProfileSection,
+  SKILL_ALIASES,
+  SYNC_MAP,
+  syncAliasedSkillDir,
 } from "../scripts/setup.mjs";
-import {
-  ensureGlobalClaudeRoutingSection,
-  ensureTfxSection,
-  getLatestRoutingTable,
-} from "../scripts/claudemd-sync.mjs";
 import { cleanupTmpFiles } from "../scripts/tmp-cleanup.mjs";
-import { checkNetworkAvailability, validateRuntimeCachePaths } from "../hub/lib/cache-guard.mjs";
 
 const PKG_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 const CLAUDE_DIR = join(homedir(), ".claude");
@@ -48,7 +86,6 @@ const PKG = JSON.parse(readFileSync(join(PKG_ROOT, "package.json"), "utf8"));
 // 이 배열에 포함된 버전에서만 star prompt를 표시한다 (빈 배열 = 모든 버전에서 표시)
 const STAR_PROMPT_VERSIONS = [];
 
-
 // ── 색상 체계 (triflux brand: amber/orange accent) ──
 const CYAN = "\x1b[36m";
 const GREEN = "\x1b[32m";
@@ -88,48 +125,107 @@ const CLI_COMMAND_SCHEMAS = Object.freeze({
     usage: "tfx setup [--dry-run]",
     description: "파일 동기화 + HUD/MCP 설정",
     options: [
-      { name: "--dry-run", type: "boolean", description: "실제 변경 없이 예정 작업을 JSON으로 출력" },
+      {
+        name: "--dry-run",
+        type: "boolean",
+        description: "실제 변경 없이 예정 작업을 JSON으로 출력",
+      },
     ],
   },
   doctor: {
-    usage: "tfx doctor [--fix] [--reset] [--json]",
+    usage: "tfx doctor [--fix] [--reset] [--audit] [--diagnose] [--json]",
     description: "설치 상태 진단 및 자동 복구",
     options: [
-      { name: "--fix", type: "boolean", description: "파일/캐시 자동 복구 후 재진단" },
-      { name: "--reset", type: "boolean", description: "캐시 초기화 후 재생성" },
-      { name: "--json", type: "boolean", description: "구조화된 진단 결과 JSON 출력" },
+      {
+        name: "--fix",
+        type: "boolean",
+        description: "파일/캐시 자동 복구 후 재진단",
+      },
+      {
+        name: "--reset",
+        type: "boolean",
+        description: "캐시 초기화 후 재생성",
+      },
+      {
+        name: "--audit",
+        type: "boolean",
+        description: "설정 보안/성능 정적 감사",
+      },
+      {
+        name: "--diagnose",
+        type: "boolean",
+        description: "진단 번들(zip) 생성: spawn-trace + hook timing + system info",
+      },
+      {
+        name: "--json",
+        type: "boolean",
+        description: "구조화된 진단 결과 JSON 출력",
+      },
     ],
   },
   version: {
     usage: "tfx version [--json]",
     description: "triflux 및 동기화된 스크립트 버전 표시",
     options: [
-      { name: "--json", type: "boolean", description: "버전 정보를 JSON으로 출력" },
+      {
+        name: "--json",
+        type: "boolean",
+        description: "버전 정보를 JSON으로 출력",
+      },
     ],
   },
   handoff: {
-    usage: "tfx handoff [--target local|remote] [--decision <text>] [--decision-file <path>] [--output <path>] [--json]",
+    usage:
+      "tfx handoff [--target local|remote] [--decision <text>] [--decision-file <path>] [--output <path>] [--json]",
     description: "현재 작업 컨텍스트를 세션 핸드오프 프롬프트로 직렬화",
     options: [
-      { name: "--target", type: "string", description: "주입 대상 (local|remote, 기본값 remote)" },
-      { name: "--decision", type: "string", description: "핸드오프 결정사항 (반복 지정 가능)" },
-      { name: "--decision-file", type: "string", description: "결정사항 파일 (라인/불릿 단위)" },
-      { name: "--output", type: "string", description: "생성한 핸드오프 프롬프트 저장 경로" },
-      { name: "--json", type: "boolean", description: "핸드오프 결과를 JSON으로 출력" },
+      {
+        name: "--target",
+        type: "string",
+        description: "주입 대상 (local|remote, 기본값 remote)",
+      },
+      {
+        name: "--decision",
+        type: "string",
+        description: "핸드오프 결정사항 (반복 지정 가능)",
+      },
+      {
+        name: "--decision-file",
+        type: "string",
+        description: "결정사항 파일 (라인/불릿 단위)",
+      },
+      {
+        name: "--output",
+        type: "string",
+        description: "생성한 핸드오프 프롬프트 저장 경로",
+      },
+      {
+        name: "--json",
+        type: "boolean",
+        description: "핸드오프 결과를 JSON으로 출력",
+      },
     ],
   },
   list: {
     usage: "tfx list [--json]",
     description: "패키지 스킬과 사용자 스킬 목록 표시",
     options: [
-      { name: "--json", type: "boolean", description: "스킬 목록을 JSON으로 출력" },
+      {
+        name: "--json",
+        type: "boolean",
+        description: "스킬 목록을 JSON으로 출력",
+      },
     ],
   },
   schema: {
     usage: "tfx schema [command-or-tool]",
     description: "CLI 커맨드 파라미터와 Hub delegator schema 번들 출력",
     options: [
-      { name: "command-or-tool", type: "string", description: "예: doctor, setup, delegate, delegate-reply, status" },
+      {
+        name: "command-or-tool",
+        type: "string",
+        description: "예: doctor, setup, delegate, delegate-reply, status",
+      },
     ],
   },
   hooks: {
@@ -141,7 +237,8 @@ const CLI_COMMAND_SCHEMAS = Object.freeze({
       apply: "오케스트레이터 적용 (settings.json 통합)",
       restore: "원래 settings.json 훅 복원",
       status: "오케스트레이터 적용 상태 확인",
-      "set-priority": "특정 훅 우선순위 변경: hooks set-priority <hookId> <priority>",
+      "set-priority":
+        "특정 훅 우선순위 변경: hooks set-priority <hookId> <priority>",
       toggle: "특정 훅 활성/비활성 토글: hooks toggle <hookId>",
     },
   },
@@ -151,22 +248,44 @@ const CLI_COMMAND_SCHEMAS = Object.freeze({
     subcommands: {
       list: {
         usage: "tfx mcp list [--json]",
-        options: [{ name: "--json", type: "boolean", description: "registry + 실제 설정 상태를 JSON으로 출력" }],
+        options: [
+          {
+            name: "--json",
+            type: "boolean",
+            description: "registry + 실제 설정 상태를 JSON으로 출력",
+          },
+        ],
       },
       sync: {
         usage: "tfx mcp sync [--json]",
-        options: [{ name: "--json", type: "boolean", description: "동기화 결과를 JSON으로 출력" }],
+        options: [
+          {
+            name: "--json",
+            type: "boolean",
+            description: "동기화 결과를 JSON으로 출력",
+          },
+        ],
       },
       add: {
         usage: "tfx mcp add <name> --url <url> [--json]",
         options: [
           { name: "--url", type: "string", description: "등록할 MCP URL" },
-          { name: "--json", type: "boolean", description: "등록 결과를 JSON으로 출력" },
+          {
+            name: "--json",
+            type: "boolean",
+            description: "등록 결과를 JSON으로 출력",
+          },
         ],
       },
       remove: {
         usage: "tfx mcp remove <name> [--json]",
-        options: [{ name: "--json", type: "boolean", description: "제거 결과를 JSON으로 출력" }],
+        options: [
+          {
+            name: "--json",
+            type: "boolean",
+            description: "제거 결과를 JSON으로 출력",
+          },
+        ],
       },
     },
   },
@@ -176,25 +295,54 @@ const CLI_COMMAND_SCHEMAS = Object.freeze({
     subcommands: {
       start: { usage: "tfx hub start [--port N]" },
       stop: { usage: "tfx hub stop" },
-      ensure: { usage: "tfx hub ensure [--port N] [--json]", description: "헬스체크 + 자동 시작 (idempotent)" },
+      ensure: {
+        usage: "tfx hub ensure [--port N] [--json]",
+        description: "헬스체크 + 자동 시작 (idempotent)",
+      },
       status: {
         usage: "tfx hub status [--json]",
-        options: [{ name: "--json", type: "boolean", description: "허브 상태를 JSON으로 출력" }],
+        options: [
+          {
+            name: "--json",
+            type: "boolean",
+            description: "허브 상태를 JSON으로 출력",
+          },
+        ],
       },
     },
   },
   multi: {
-    usage: "tfx multi [--dashboard-layout lite|single|split-2col|split-3col|auto] <subcommand|task>",
+    usage:
+      "tfx multi [--dashboard-layout lite|single|split-2col|split-3col|auto] <subcommand|task>",
     description: "멀티-CLI 팀 모드",
     options: [
-      { name: "--dashboard", type: "boolean", description: "headless dashboard viewer 표시 (기본값: 켜짐)" },
-      { name: "--no-dashboard", type: "boolean", description: "headless dashboard viewer 비활성화" },
-      { name: "--dashboard-layout", type: "string", description: "dashboard viewer 레이아웃 선택: lite|single|split-2col|split-3col|auto" },
+      {
+        name: "--dashboard",
+        type: "boolean",
+        description: "headless dashboard viewer 표시 (기본값: 켜짐)",
+      },
+      {
+        name: "--no-dashboard",
+        type: "boolean",
+        description: "headless dashboard viewer 비활성화",
+      },
+      {
+        name: "--dashboard-layout",
+        type: "string",
+        description:
+          "dashboard viewer 레이아웃 선택: lite|single|split-2col|split-3col|auto",
+      },
     ],
     subcommands: {
       status: {
         usage: "tfx multi status [--json]",
-        options: [{ name: "--json", type: "boolean", description: "팀 상태를 JSON으로 출력" }],
+        options: [
+          {
+            name: "--json",
+            type: "boolean",
+            description: "팀 상태를 JSON으로 출력",
+          },
+        ],
       },
     },
   },
@@ -203,13 +351,27 @@ const CLI_COMMAND_SCHEMAS = Object.freeze({
 // ── 유틸리티 ──
 // ok/warn/fail/info/section 의 console.log는 디버그 로그가 아닌 의도된 CLI 출력입니다.
 
-function ok(msg) { console.log(`  ${GREEN_BRIGHT}✓${RESET} ${msg}`); }
-function warn(msg) { console.log(`  ${YELLOW}⚠${RESET} ${msg}`); }
-function fail(msg) { console.log(`  ${RED_BRIGHT}✗${RESET} ${msg}`); }
-function info(msg) { console.log(`    ${GRAY}${msg}${RESET}`); }
-function section(title) { console.log(`\n  ${AMBER}▸${RESET} ${BOLD}${title}${RESET}`); }
-function stripAnsi(value) { return String(value ?? "").replace(ANSI_PATTERN, ""); }
-function printJson(payload) { process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`); }
+function ok(msg) {
+  console.log(`  ${GREEN_BRIGHT}✓${RESET} ${msg}`);
+}
+function warn(msg) {
+  console.log(`  ${YELLOW}⚠${RESET} ${msg}`);
+}
+function fail(msg) {
+  console.log(`  ${RED_BRIGHT}✗${RESET} ${msg}`);
+}
+function info(msg) {
+  console.log(`    ${GRAY}${msg}${RESET}`);
+}
+function section(title) {
+  console.log(`\n  ${AMBER}▸${RESET} ${BOLD}${title}${RESET}`);
+}
+function stripAnsi(value) {
+  return String(value ?? "").replace(ANSI_PATTERN, "");
+}
+function printJson(payload) {
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+}
 
 function withConsoleSilenced(enabled, fn) {
   if (!enabled) return fn();
@@ -225,12 +387,10 @@ function withConsoleSilenced(enabled, fn) {
   }
 }
 
-function createCliError(message, {
-  exitCode = EXIT_ERROR,
-  reason = "error",
-  fix = null,
-  cause = null,
-} = {}) {
+function createCliError(
+  message,
+  { exitCode = EXIT_ERROR, reason = "error", fix = null, cause = null } = {},
+) {
   const error = new Error(message);
   error.exitCode = exitCode;
   error.reason = reason;
@@ -257,9 +417,12 @@ function inferReason(error, exitCode) {
 function inferFix(error, exitCode) {
   if (typeof error?.fix === "string" && error.fix) return error.fix;
   if (exitCode === EXIT_ARG_ERROR) return "tfx --help";
-  if (exitCode === EXIT_CLI_MISSING) return "필수 CLI를 설치한 뒤 `tfx doctor`로 상태를 다시 확인하세요.";
-  if (exitCode === EXIT_HUB_ERROR) return "`tfx hub start`로 허브를 다시 시작하거나 설치 상태를 확인하세요.";
-  if (exitCode === EXIT_CONFIG_ERROR) return "설정 파일 JSON/TOML 문법을 수정한 뒤 다시 실행하세요.";
+  if (exitCode === EXIT_CLI_MISSING)
+    return "필수 CLI를 설치한 뒤 `tfx doctor`로 상태를 다시 확인하세요.";
+  if (exitCode === EXIT_HUB_ERROR)
+    return "`tfx hub start`로 허브를 다시 시작하거나 설치 상태를 확인하세요.";
+  if (exitCode === EXIT_CONFIG_ERROR)
+    return "설정 파일 JSON/TOML 문법을 수정한 뒤 다시 실행하세요.";
   return null;
 }
 
@@ -288,7 +451,11 @@ function handleFatalError(error, { json = false } = {}) {
 function renderErrorMessage(message, fallback = "unknown error") {
   if (typeof message === "string") {
     const normalized = message.trim().toLowerCase();
-    if (normalized.length > 0 && normalized !== "undefined" && normalized !== "null") {
+    if (
+      normalized.length > 0 &&
+      normalized !== "undefined" &&
+      normalized !== "null"
+    ) {
       return message.trim();
     }
   }
@@ -297,18 +464,40 @@ function renderErrorMessage(message, fallback = "unknown error") {
 
 function which(cmd) {
   try {
-    const result = process.platform === "win32"
-      ? execFileSync("where", [cmd], { encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "ignore"], windowsHide: true })
-      : execFileSync("which", [cmd], { encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "ignore"] });
+    const result =
+      process.platform === "win32"
+        ? execFileSync("where", [cmd], {
+            encoding: "utf8",
+            timeout: 5000,
+            stdio: ["pipe", "pipe", "ignore"],
+            windowsHide: true,
+          })
+        : execFileSync("which", [cmd], {
+            encoding: "utf8",
+            timeout: 5000,
+            stdio: ["pipe", "pipe", "ignore"],
+          });
     return result.trim().split(/\r?\n/)[0] || null;
-  } catch { return null; }
+  } catch {
+    return null;
+  }
 }
 
 function whichInShell(cmd, shell) {
   const shellArgs = {
-    bash: ["bash", ["-c", `source ~/.bashrc 2>/dev/null && command -v "${cmd}" 2>/dev/null`]],
+    bash: [
+      "bash",
+      ["-c", `source ~/.bashrc 2>/dev/null && command -v "${cmd}" 2>/dev/null`],
+    ],
     cmd: ["cmd", ["/c", "where", cmd]],
-    pwsh: ["pwsh", ["-NoProfile", "-c", `(Get-Command '${cmd.replace(/'/g, "''")}' -EA SilentlyContinue).Source`]],
+    pwsh: [
+      "pwsh",
+      [
+        "-NoProfile",
+        "-c",
+        `(Get-Command '${cmd.replace(/'/g, "''")}' -EA SilentlyContinue).Source`,
+      ],
+    ],
   };
   const entry = shellArgs[shell];
   if (!entry) return null;
@@ -320,22 +509,36 @@ function whichInShell(cmd, shell) {
       windowsHide: true,
     }).trim();
     return result.split(/\r?\n/)[0] || null;
-  } catch { return null; }
+  } catch {
+    return null;
+  }
 }
 
 function isDevUpdateRequested(argv = process.argv) {
-  return argv.includes("--dev") || argv.includes("@dev") || argv.includes("dev");
+  return (
+    argv.includes("--dev") || argv.includes("@dev") || argv.includes("dev")
+  );
 }
 
 function checkShellAvailable(shell) {
-  const cmds = { bash: "bash --version", cmd: "cmd /c echo ok", pwsh: "pwsh -NoProfile -c echo ok" };
+  const cmds = {
+    bash: "bash --version",
+    cmd: "cmd /c echo ok",
+    pwsh: "pwsh -NoProfile -c echo ok",
+  };
   try {
-    execSync(cmds[shell], { encoding: "utf8", timeout: 5000, stdio: ["pipe", "pipe", "ignore"], windowsHide: true });
+    execSync(cmds[shell], {
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "ignore"],
+      windowsHide: true,
+    });
     return true;
-  } catch { return false; }
+  } catch {
+    return false;
+  }
 }
 
-
 function parseSessionCreated(rawValue) {
   const value = String(rawValue || "").trim();
   if (!value) return null;
@@ -350,7 +553,10 @@ function parseSessionCreated(rawValue) {
     return Math.floor(parsed / 1000);
   }
 
-  const normalized = value.replace(/^(\d{2})-(\d{2})-(\d{2})(\s+)/, "20$1-$2-$3$4");
+  const normalized = value.replace(
+    /^(\d{2})-(\d{2})-(\d{2})(\s+)/,
+    "20$1-$2-$3$4",
+  );
   const reparsed = Date.parse(normalized);
   if (Number.isFinite(reparsed)) {
     return Math.floor(reparsed / 1000);
@@ -371,7 +577,9 @@ function readTeamSessionCreatedMap() {
   const createdMap = new Map();
 
   try {
-    const output = tmuxExec('list-sessions -F "#{session_name} #{session_created}"');
+    const output = tmuxExec(
+      'list-sessions -F "#{session_name} #{session_created}"',
+    );
     for (const line of output.split(/\r?\n/)) {
       const trimmed = line.trim();
       if (!trimmed) continue;
@@ -408,10 +616,17 @@ function inspectTeamSessions() {
   const createdMap = readTeamSessionCreatedMap();
   const nowSec = Math.floor(Date.now() / 1000);
   const sessions = sessionNames.map((sessionName) => {
-    const createdInfo = createdMap.get(sessionName) || { createdAt: null, createdRaw: "" };
+    const createdInfo = createdMap.get(sessionName) || {
+      createdAt: null,
+      createdRaw: "",
+    };
     const attachedCount = getSessionAttachedCount(sessionName);
-    const ageSec = createdInfo.createdAt == null ? null : Math.max(0, nowSec - createdInfo.createdAt);
-    const stale = ageSec != null && ageSec >= STALE_TEAM_MAX_AGE_SEC && attachedCount === 0;
+    const ageSec =
+      createdInfo.createdAt == null
+        ? null
+        : Math.max(0, nowSec - createdInfo.createdAt);
+    const stale =
+      ageSec != null && ageSec >= STALE_TEAM_MAX_AGE_SEC && attachedCount === 0;
 
     return {
       sessionName,
@@ -459,7 +674,6 @@ async function cleanupStaleTeamSessions(staleSessions) {
   return { cleaned, failed };
 }
 
-
 function previewCodexProfiles() {
   const original = existsSync(CODEX_CONFIG_PATH)
     ? readFileSync(CODEX_CONFIG_PATH, "utf8")
@@ -481,13 +695,19 @@ function previewCodexProfiles() {
     }
   }
 
-  const windowsSandbox = process.platform === "win32" && !updated.includes("[windows]");
+  const windowsSandbox =
+    process.platform === "win32" && !updated.includes("[windows]");
 
   return {
     path: CODEX_CONFIG_PATH,
     profiles,
     windowsSandbox,
-    change: profiles.length > 0 || windowsSandbox ? (original ? "update" : "create") : "noop",
+    change:
+      profiles.length > 0 || windowsSandbox
+        ? original
+          ? "update"
+          : "create"
+        : "noop",
   };
 }
 
@@ -505,7 +725,9 @@ function syncFile(src, dst, label) {
 
   if (!existsSync(dst)) {
     copyFileSync(src, dst);
-    try { chmodSync(dst, 0o755); } catch {}
+    try {
+      chmodSync(dst, 0o755);
+    } catch {}
     ok(`${label}: 설치됨 ${srcVer ? `(v${srcVer})` : ""}`);
     return true;
   }
@@ -514,10 +736,15 @@ function syncFile(src, dst, label) {
   const dstContent = readFileSync(dst, "utf8");
   if (srcContent !== dstContent) {
     copyFileSync(src, dst);
-    try { chmodSync(dst, 0o755); } catch {}
-    const verInfo = (srcVer && dstVer && srcVer !== dstVer)
-      ? `(v${dstVer} → v${srcVer})`
-      : srcVer ? `(v${srcVer}, 내용 변경)` : "(내용 변경)";
+    try {
+      chmodSync(dst, 0o755);
+    } catch {}
+    const verInfo =
+      srcVer && dstVer && srcVer !== dstVer
+        ? `(v${dstVer} → v${srcVer})`
+        : srcVer
+          ? `(v${srcVer}, 내용 변경)`
+          : "(내용 변경)";
     ok(`${label}: 업데이트됨 ${verInfo}`);
     return true;
   }
@@ -561,22 +788,36 @@ function syncClaudeRoutingSectionsForCli() {
       ensureGlobalClaudeRoutingSection(CLAUDE_DIR),
     ];
   } catch (error) {
-    const reason = error instanceof Error ? error.message : "routing_sync_failed";
-    return [{ action: "unchanged", path: join(PKG_ROOT, "CLAUDE.md"), skipped: true, reason }];
+    const reason =
+      error instanceof Error ? error.message : "routing_sync_failed";
+    return [
+      {
+        action: "unchanged",
+        path: join(PKG_ROOT, "CLAUDE.md"),
+        skipped: true,
+        reason,
+      },
+    ];
   }
 }
 
 function getClaudeRoutingSyncSummary(results) {
-  return results.reduce((summary, result) => ({
-    changed: summary.changed + (result.action === "created" || result.action === "updated" ? 1 : 0),
-    skipped: summary.skipped + (result.skipped ? 1 : 0),
-  }), { changed: 0, skipped: 0 });
+  return results.reduce(
+    (summary, result) => ({
+      changed:
+        summary.changed +
+        (result.action === "created" || result.action === "updated" ? 1 : 0),
+      skipped: summary.skipped + (result.skipped ? 1 : 0),
+    }),
+    { changed: 0, skipped: 0 },
+  );
 }
 
 // ── 크로스 셸 진단 ──
 
 function checkCliCrossShell(cmd, installHint) {
-  const shells = process.platform === "win32" ? ["bash", "cmd", "pwsh"] : ["bash"];
+  const shells =
+    process.platform === "win32" ? ["bash", "cmd", "pwsh"] : ["bash"];
   let anyFound = false;
   let bashMissing = false;
   const shellResults = [];
@@ -595,7 +836,12 @@ function checkCliCrossShell(cmd, installHint) {
     } else {
       fail(`${shell}:  미발견`);
       if (shell === "bash") bashMissing = true;
-      shellResults.push({ shell, status: "missing", path: null, fix: installHint });
+      shellResults.push({
+        shell,
+        status: "missing",
+        path: null,
+        fix: installHint,
+      });
     }
   }
 
@@ -620,7 +866,7 @@ function checkCliCrossShell(cmd, installHint) {
       bashMissing,
       shells: shellResults,
       status: "degraded",
-      fix: 'bash PATH를 정리한 뒤 `tfx doctor`를 다시 실행하세요.',
+      fix: "bash PATH를 정리한 뒤 `tfx doctor`를 다시 실행하세요.",
     };
   }
   return {
@@ -677,7 +923,11 @@ function previewStatusLineAction() {
   return {
     type: "statusLine",
     path: settingsPath,
-    change: currentCmd.includes("hud-qos-status.mjs") ? "noop" : (currentCmd ? "update" : "create"),
+    change: currentCmd.includes("hud-qos-status.mjs")
+      ? "noop"
+      : currentCmd
+        ? "update"
+        : "create",
     current: currentCmd || null,
     target: hudPath,
   };
@@ -744,7 +994,9 @@ function previewClaudeRoutingAction() {
   }
 
   const globalContent = readFileSync(globalClaudePath, "utf8");
-  const hasRouting = globalContent.includes("<routing>") || globalContent.includes("## triflux CLI 라우팅");
+  const hasRouting =
+    globalContent.includes("<routing>") ||
+    globalContent.includes("## triflux CLI 라우팅");
 
   return {
     type: "claude-guidance",
@@ -756,7 +1008,9 @@ function previewClaudeRoutingAction() {
 
 function buildSetupDryRunPlan() {
   const actions = [
-    ...SYNC_MAP.map(({ src, dst, label }) => describeSyncAction(src, dst, label)),
+    ...SYNC_MAP.map(({ src, dst, label }) =>
+      describeSyncAction(src, dst, label),
+    ),
     ...listSkillSyncActions(),
   ];
   actions.push(previewClaudeRoutingAction());
@@ -793,8 +1047,13 @@ function cmdSetup(options = {}) {
   }
   {
     const claudeGuide = ensureGlobalClaudeRoutingSection(CLAUDE_DIR);
-    if (claudeGuide.skipped) warn(`CLAUDE.md 라우팅 섹션 확인 실패: ${claudeGuide.reason}`);
-    else if (claudeGuide.action === "created" || claudeGuide.action === "updated") ok("CLAUDE.md: 전역 triflux 라우팅 요약 갱신");
+    if (claudeGuide.skipped)
+      warn(`CLAUDE.md 라우팅 섹션 확인 실패: ${claudeGuide.reason}`);
+    else if (
+      claudeGuide.action === "created" ||
+      claudeGuide.action === "updated"
+    )
+      ok("CLAUDE.md: 전역 triflux 라우팅 요약 갱신");
     else ok("CLAUDE.md: 전역 triflux 라우팅 요약 유지");
   }
 
@@ -833,7 +1092,10 @@ function cmdSetup(options = {}) {
           const rSrc = join(refSrc, refFile);
           const rDst = join(refDst, refFile);
           if (statSync(rSrc).isFile()) {
-            if (!existsSync(rDst) || readFileSync(rSrc, "utf8") !== readFileSync(rDst, "utf8")) {
+            if (
+              !existsSync(rDst) ||
+              readFileSync(rSrc, "utf8") !== readFileSync(rDst, "utf8")
+            ) {
               copyFileSync(rSrc, rDst);
             }
           }
@@ -845,7 +1107,10 @@ function cmdSetup(options = {}) {
       const src = join(srcDir, "SKILL.md");
       if (!existsSync(src)) continue;
       skillTotal++;
-      skillCount += syncAliasedSkillDir(srcDir, join(skillsDst, alias), { alias, source });
+      skillCount += syncAliasedSkillDir(srcDir, join(skillsDst, alias), {
+        alias,
+        source,
+      });
     }
     if (skillCount > 0) {
       ok(`스킬: ${skillCount}/${skillTotal}개 업데이트됨`);
@@ -855,22 +1120,36 @@ function cmdSetup(options = {}) {
     // Stale 스킬 정리 (패키지에서 제거된 tfx-* 스킬 삭제)
     const staleCleanup = cleanupStaleSkills(skillsDst, skillsSrc);
     if (staleCleanup.count > 0) {
-      ok(`구형 스킬 ${staleCleanup.count}개 제거: ${staleCleanup.removed.join(", ")}`);
+      ok(
+        `구형 스킬 ${staleCleanup.count}개 제거: ${staleCleanup.removed.join(", ")}`,
+      );
     }
   }
 
   // ── psmux 기본 셸 자동 수정 (cmd.exe → PowerShell) ──
   if (process.platform === "win32" && which("psmux")) {
     try {
-      const shellOut = execSync("psmux show-options -g default-shell 2>NUL", { encoding: "utf8", timeout: 3000 }).trim();
+      const shellOut = execSync("psmux show-options -g default-shell 2>NUL", {
+        encoding: "utf8",
+        timeout: 3000,
+      }).trim();
       if (!/powershell|pwsh/i.test(shellOut)) {
-        const pwsh = which("pwsh") ? "pwsh" : (which("powershell.exe") ? "powershell.exe" : "");
+        const pwsh = which("pwsh")
+          ? "pwsh"
+          : which("powershell.exe")
+            ? "powershell.exe"
+            : "";
         if (pwsh) {
-          execSync(`psmux set-option -g default-shell "${pwsh}"`, { timeout: 3000, stdio: "pipe" });
+          execSync(`psmux set-option -g default-shell "${pwsh}"`, {
+            timeout: 3000,
+            stdio: "pipe",
+          });
           ok(`psmux 기본 셸 → ${pwsh}`);
         }
       }
-    } catch { /* psmux 서버 미실행 — 무시 */ }
+    } catch {
+      /* psmux 서버 미실행 — 무시 */
+    }
   }
 
   // ── 결과 추적 ──
@@ -878,16 +1157,29 @@ function cmdSetup(options = {}) {
 
   if (!skipClaudeMdSync) {
     const claudeRoutingResults = syncClaudeRoutingSectionsForCli();
-    const claudeRoutingSummary = getClaudeRoutingSyncSummary(claudeRoutingResults);
+    const claudeRoutingSummary =
+      getClaudeRoutingSyncSummary(claudeRoutingResults);
     if (claudeRoutingSummary.changed > 0) {
       ok(`CLAUDE.md 라우팅: ${claudeRoutingSummary.changed}개 파일 반영`);
-      summary.push({ item: "CLAUDE.md 라우팅", status: "✅", detail: `${claudeRoutingSummary.changed}개 파일 반영` });
+      summary.push({
+        item: "CLAUDE.md 라우팅",
+        status: "✅",
+        detail: `${claudeRoutingSummary.changed}개 파일 반영`,
+      });
     } else if (claudeRoutingSummary.skipped > 0) {
       ok("CLAUDE.md 라우팅: 대상 파일 없음 (건너뜀)");
-      summary.push({ item: "CLAUDE.md 라우팅", status: "⏭️", detail: "대상 파일 없음" });
+      summary.push({
+        item: "CLAUDE.md 라우팅",
+        status: "⏭️",
+        detail: "대상 파일 없음",
+      });
     } else {
       ok("CLAUDE.md 라우팅: 최신 상태");
-      summary.push({ item: "CLAUDE.md 라우팅", status: "✅", detail: "최신 상태" });
+      summary.push({
+        item: "CLAUDE.md 라우팅",
+        status: "✅",
+        detail: "최신 상태",
+      });
     }
   }
 
@@ -897,11 +1189,21 @@ function cmdSetup(options = {}) {
     warn(`Codex profiles 설정 실패: ${reason}`);
     summary.push({ item: "Codex profiles", status: "⚠️", detail: reason });
   } else if (codexProfileResult.changed > 0) {
-    ok(`Codex profiles: ${codexProfileResult.changed}개 반영됨 (~/.codex/config.toml)`);
-    summary.push({ item: "Codex profiles", status: "✅", detail: `${codexProfileResult.changed}개 반영됨` });
+    ok(
+      `Codex profiles: ${codexProfileResult.changed}개 반영됨 (~/.codex/config.toml)`,
+    );
+    summary.push({
+      item: "Codex profiles",
+      status: "✅",
+      detail: `${codexProfileResult.changed}개 반영됨`,
+    });
   } else {
     ok("Codex profiles: 이미 준비됨");
-    summary.push({ item: "Codex profiles", status: "✅", detail: "이미 준비됨" });
+    summary.push({
+      item: "Codex profiles",
+      status: "✅",
+      detail: "이미 준비됨",
+    });
   }
 
   // Gemini 프로필
@@ -911,14 +1213,28 @@ function cmdSetup(options = {}) {
     warn(`Gemini profiles 설정 실패: ${reason}`);
     summary.push({ item: "Gemini profiles", status: "⚠️", detail: reason });
   } else if (geminiResult.created) {
-    ok(`Gemini profiles: ${geminiResult.count}개 생성됨 (~/.gemini/triflux-profiles.json)`);
-    summary.push({ item: "Gemini profiles", status: "✅", detail: `${geminiResult.count}개 생성됨` });
+    ok(
+      `Gemini profiles: ${geminiResult.count}개 생성됨 (~/.gemini/triflux-profiles.json)`,
+    );
+    summary.push({
+      item: "Gemini profiles",
+      status: "✅",
+      detail: `${geminiResult.count}개 생성됨`,
+    });
   } else if (geminiResult.added > 0) {
     ok(`Gemini profiles: ${geminiResult.added}개 추가됨`);
-    summary.push({ item: "Gemini profiles", status: "✅", detail: `${geminiResult.added}개 추가됨 (총 ${geminiResult.count}개)` });
+    summary.push({
+      item: "Gemini profiles",
+      status: "✅",
+      detail: `${geminiResult.added}개 추가됨 (총 ${geminiResult.count}개)`,
+    });
   } else {
     ok(`Gemini profiles: ${geminiResult.count}개 준비됨`);
-    summary.push({ item: "Gemini profiles", status: "✅", detail: `${geminiResult.count}개 준비됨` });
+    summary.push({
+      item: "Gemini profiles",
+      status: "✅",
+      detail: `${geminiResult.count}개 준비됨`,
+    });
   }
 
   // hub MCP 사전 등록 (서버 미실행이어도 설정만 등록 — hub start 시 즉시 사용 가능)
@@ -944,12 +1260,18 @@ function cmdSetup(options = {}) {
       const currentCmd = settings.statusLine?.command || "";
       if (currentCmd.includes("hud-qos-status.mjs")) {
         ok("statusLine 이미 설정됨");
-        summary.push({ item: "HUD statusLine", status: "✅", detail: "이미 설정됨" });
+        summary.push({
+          item: "HUD statusLine",
+          status: "✅",
+          detail: "이미 설정됨",
+        });
       } else {
         const nodePath = process.execPath.replace(/\\/g, "/");
         const hudForward = hudPath.replace(/\\/g, "/");
         const nodeRef = nodePath.includes(" ") ? `"${nodePath}"` : nodePath;
-        const hudRef = hudForward.includes(" ") ? `"${hudForward}"` : hudForward;
+        const hudRef = hudForward.includes(" ")
+          ? `"${hudForward}"`
+          : hudForward;
 
         if (currentCmd) {
           warn(`기존 statusLine 덮어쓰기: ${currentCmd}`);
@@ -960,9 +1282,17 @@ function cmdSetup(options = {}) {
           command: `${nodeRef} ${hudRef}`,
         };
 
-        writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+        writeFileSync(
+          settingsPath,
+          JSON.stringify(settings, null, 2) + "\n",
+          "utf8",
+        );
         ok("statusLine 설정 완료 — 세션 재시작 후 HUD 표시");
-        summary.push({ item: "HUD statusLine", status: "✅", detail: "설정 완료" });
+        summary.push({
+          item: "HUD statusLine",
+          status: "✅",
+          detail: "설정 완료",
+        });
       }
     } catch (e) {
       throw createCliError(`settings.json 처리 실패: ${e.message}`, {
@@ -974,7 +1304,11 @@ function cmdSetup(options = {}) {
     }
   } else {
     warn("HUD 파일 없음 — 먼저 파일 동기화 필요");
-    summary.push({ item: "HUD statusLine", status: "⚠️", detail: "HUD 파일 없음" });
+    summary.push({
+      item: "HUD statusLine",
+      status: "⚠️",
+      detail: "HUD 파일 없음",
+    });
   }
 
   // CLI 존재 확인
@@ -986,27 +1320,41 @@ function cmdSetup(options = {}) {
     if (which(name)) {
       summary.push({ item: `${name} CLI`, status: "✅", detail: "설치됨" });
     } else {
-      summary.push({ item: `${name} CLI`, status: "⏭️", detail: `미설치 (${install})` });
+      summary.push({
+        item: `${name} CLI`,
+        status: "⏭️",
+        detail: `미설치 (${install})`,
+      });
     }
   }
 
   // Star request (버전 게이팅 + 인터랙티브 [y/n])
-  const showStar = STAR_PROMPT_VERSIONS.length === 0 || STAR_PROMPT_VERSIONS.includes(PKG.version);
+  const showStar =
+    STAR_PROMPT_VERSIONS.length === 0 ||
+    STAR_PROMPT_VERSIONS.includes(PKG.version);
   if (showStar) {
     let ghOk = false;
     try {
-      execFileSync("gh", ["auth", "status"], { timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+      execFileSync("gh", ["auth", "status"], {
+        timeout: 5000,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
       ghOk = true;
     } catch {}
 
     if (!ghOk) {
       // gh 미설치/미인증 — URL만 표시
       console.log();
-      info(`${AMBER}⭐${RESET} 하나가 큰 차이를 만듭니다. ${CYAN}https://github.com/tellang/triflux${RESET}`);
+      info(
+        `${AMBER}⭐${RESET} 하나가 큰 차이를 만듭니다. ${CYAN}https://github.com/tellang/triflux${RESET}`,
+      );
     } else {
       let alreadyStarred = false;
       try {
-        execFileSync("gh", ["api", "user/starred/tellang/triflux"], { timeout: 5000, stdio: ["pipe", "pipe", "pipe"] });
+        execFileSync("gh", ["api", "user/starred/tellang/triflux"], {
+          timeout: 5000,
+          stdio: ["pipe", "pipe", "pipe"],
+        });
         alreadyStarred = true;
       } catch {}
 
@@ -1016,7 +1364,9 @@ function cmdSetup(options = {}) {
       } else {
         // 인터랙티브 confirm
         console.log();
-        process.stdout.write(`    ${AMBER}⭐${RESET} 하나가 큰 차이를 만듭니다. Star? ${DIM}[y/N]${RESET} `);
+        process.stdout.write(
+          `    ${AMBER}⭐${RESET} 하나가 큰 차이를 만듭니다. Star? ${DIM}[y/N]${RESET} `,
+        );
         let answer = "";
         try {
           const buf = Buffer.alloc(128);
@@ -1027,9 +1377,14 @@ function cmdSetup(options = {}) {
         }
         if (answer.startsWith("y")) {
           try {
-            execFileSync("gh", ["api", "-X", "PUT", "/user/starred/tellang/triflux"], {
-              timeout: 5000, stdio: ["pipe", "pipe", "pipe"],
-            });
+            execFileSync(
+              "gh",
+              ["api", "-X", "PUT", "/user/starred/tellang/triflux"],
+              {
+                timeout: 5000,
+                stdio: ["pipe", "pipe", "pipe"],
+              },
+            );
             ok(`함께해 주셔서 감사합니다. ${AMBER}⭐${RESET}`);
           } catch {
             info(`${CYAN}https://github.com/tellang/triflux${RESET}`);
@@ -1072,30 +1427,42 @@ function computeHookCoverage(settings, managedHooks) {
     duplicates: [],
   };
 
-  const hooksByEvent = settings?.hooks && typeof settings.hooks === "object" ? settings.hooks : {};
+  const hooksByEvent =
+    settings?.hooks && typeof settings.hooks === "object" ? settings.hooks : {};
 
   // 이벤트별 orchestrator 존재 여부를 캐시
   const orchestratorByEvent = {};
   for (const [event, entries] of Object.entries(hooksByEvent)) {
-    orchestratorByEvent[event] = Array.isArray(entries) && entries.some((entry) =>
-      Array.isArray(entry?.hooks) &&
-      entry.hooks.some((hook) =>
-        typeof hook?.command === "string" && hook.command.includes("hook-orchestrator"),
-      ),
-    );
+    orchestratorByEvent[event] =
+      Array.isArray(entries) &&
+      entries.some(
+        (entry) =>
+          Array.isArray(entry?.hooks) &&
+          entry.hooks.some(
+            (hook) =>
+              typeof hook?.command === "string" &&
+              hook.command.includes("hook-orchestrator"),
+          ),
+      );
   }
 
   for (const spec of managedHooks) {
-    const eventEntries = Array.isArray(hooksByEvent[spec.event]) ? hooksByEvent[spec.event] : [];
+    const eventEntries = Array.isArray(hooksByEvent[spec.event])
+      ? hooksByEvent[spec.event]
+      : [];
 
     // orchestrator가 있으면 registry 훅을 체이닝하므로 "registered"로 간주
     if (orchestratorByEvent[spec.event]) {
       coverage.registered++;
 
       // 동시에 개별 훅도 직접 등록되어 있으면 → 이중 실행 (duplicate)
-      const directlyRegistered = eventEntries.some((entry) =>
-        Array.isArray(entry?.hooks) &&
-        entry.hooks.some((hook) => extractManagedHookFilename(hook?.command) === spec.fileName),
+      const directlyRegistered = eventEntries.some(
+        (entry) =>
+          Array.isArray(entry?.hooks) &&
+          entry.hooks.some(
+            (hook) =>
+              extractManagedHookFilename(hook?.command) === spec.fileName,
+          ),
       );
       if (directlyRegistered) {
         coverage.duplicates.push(toHookCoverageName(spec.fileName, spec.id));
@@ -1104,9 +1471,12 @@ function computeHookCoverage(settings, managedHooks) {
     }
 
     // orchestrator 없으면 기존 방식: 개별 훅 직접 등록 확인
-    const found = eventEntries.some((entry) =>
-      Array.isArray(entry?.hooks) &&
-      entry.hooks.some((hook) => extractManagedHookFilename(hook?.command) === spec.fileName),
+    const found = eventEntries.some(
+      (entry) =>
+        Array.isArray(entry?.hooks) &&
+        entry.hooks.some(
+          (hook) => extractManagedHookFilename(hook?.command) === spec.fileName,
+        ),
     );
     if (found) {
       coverage.registered++;
@@ -1121,13 +1491,17 @@ function computeHookCoverage(settings, managedHooks) {
 function formatPathForDisplay(filePath) {
   const value = String(filePath || "").replace(/\\/g, "/");
   const homePath = homedir().replace(/\\/g, "/");
-  return value.startsWith(homePath) ? `~${value.slice(homePath.length)}` : value;
+  return value.startsWith(homePath)
+    ? `~${value.slice(homePath.length)}`
+    : value;
 }
 
 function renderTable(headers, rows) {
   if (!rows.length) return;
   const widths = headers.map((header, index) => {
-    const cellWidths = rows.map((row) => stripAnsi(String(row[index] ?? "")).length);
+    const cellWidths = rows.map(
+      (row) => stripAnsi(String(row[index] ?? "")).length,
+    );
     return Math.max(stripAnsi(header).length, ...cellWidths);
   });
 
@@ -1135,7 +1509,8 @@ function renderTable(headers, rows) {
     const text = String(cell ?? "");
     return text + " ".repeat(Math.max(0, width - stripAnsi(text).length));
   };
-  const formatRow = (row) => row.map((cell, index) => padCell(cell, widths[index])).join("  ");
+  const formatRow = (row) =>
+    row.map((cell, index) => padCell(cell, widths[index])).join("  ");
   console.log(`    ${formatRow(headers)}`);
   console.log(`    ${widths.map((width) => "─".repeat(width)).join("  ")}`);
   for (const row of rows) {
@@ -1175,12 +1550,15 @@ function inspectSerenaMcpConfig(configContent) {
     };
   }
 
-  const hasProjectBinding = section.includes("--project-from-cwd")
-    || /--project(?:\s|=|")/.test(section);
-  const hasContextCodex = /--context(?:\s|",\s*")?codex/i.test(section) || /"codex"/i.test(section);
+  const hasProjectBinding =
+    section.includes("--project-from-cwd") ||
+    /--project(?:\s|=|")/.test(section);
+  const hasContextCodex =
+    /--context(?:\s|",\s*")?codex/i.test(section) || /"codex"/i.test(section);
   const timeoutMatch = section.match(/startup_timeout_sec\s*=\s*([0-9.]+)/i);
   const startupTimeoutSec = timeoutMatch ? Number(timeoutMatch[1]) : null;
-  const timeoutRecommended = startupTimeoutSec !== null && startupTimeoutSec >= 30;
+  const timeoutRecommended =
+    startupTimeoutSec !== null && startupTimeoutSec >= 30;
 
   return {
     present: true,
@@ -1220,10 +1598,17 @@ function buildMcpStatusRows(statusInfo) {
       if (row.status === "present") detail = row.actualUrl || row.expectedUrl;
       else if (row.status === "missing") detail = "registry only";
       else if (row.status === "missing-file") detail = "config missing";
-      else if (row.status === "mismatch") detail = `expected ${row.expectedUrl}`;
+      else if (row.status === "mismatch")
+        detail = `expected ${row.expectedUrl}`;
       else if (row.status === "invalid-config") detail = "parse error";
       else if (row.status === "stdio") detail = "configured as stdio";
-      return [row.name, row.label, statusBadge(row.status), formatPathForDisplay(row.filePath), detail];
+      return [
+        row.name,
+        row.label,
+        statusBadge(row.status),
+        formatPathForDisplay(row.filePath),
+        detail,
+      ];
     });
 
   const stdioRows = statusInfo.rows
@@ -1246,11 +1631,14 @@ function ensureValidRegistryState() {
     registryState = inspectRegistry();
   }
   if (!registryState.valid) {
-    throw createCliError(`MCP registry invalid: ${registryState.errors.join("; ")}`, {
-      exitCode: EXIT_CONFIG_ERROR,
-      reason: "configError",
-      fix: `${registryState.path}의 JSON 구조를 수정하세요.`,
-    });
+    throw createCliError(
+      `MCP registry invalid: ${registryState.errors.join("; ")}`,
+      {
+        exitCode: EXIT_CONFIG_ERROR,
+        reason: "configError",
+        fix: `${registryState.path}의 JSON 구조를 수정하세요.`,
+      },
+    );
   }
   return registryState;
 }
@@ -1267,8 +1655,14 @@ async function cmdDoctor(options = {}) {
   };
 
   return await withConsoleSilenced(json, async () => {
-    const modeLabel = reset ? ` ${RED}--reset${RESET}` : fix ? ` ${YELLOW}--fix${RESET}` : "";
-    console.log(`\n  ${AMBER}${BOLD}⬡ triflux doctor${RESET} ${VER}${modeLabel}\n`);
+    const modeLabel = reset
+      ? ` ${RED}--reset${RESET}`
+      : fix
+        ? ` ${YELLOW}--fix${RESET}`
+        : "";
+    console.log(
+      `\n  ${AMBER}${BOLD}⬡ triflux doctor${RESET} ${VER}${modeLabel}\n`,
+    );
     console.log(`  ${LINE}`);
 
     // ── reset 모드: 캐시 전체 초기화 ──
@@ -1298,7 +1692,12 @@ async function cmdDoctor(options = {}) {
             report.actions.push({ type: "delete", path: fp, status: "ok" });
             ok(`삭제됨: ${name}`);
           } catch (e) {
-            report.actions.push({ type: "delete", path: fp, status: "failed", message: e.message });
+            report.actions.push({
+              type: "delete",
+              path: fp,
+              status: "failed",
+              message: e.message,
+            });
             fail(`삭제 실패: ${name} — ${e.message}`);
           }
         }
@@ -1314,38 +1713,86 @@ async function cmdDoctor(options = {}) {
       const mcpCheck = join(PKG_ROOT, "scripts", "mcp-check.mjs");
       if (existsSync(mcpCheck)) {
         try {
-          execFileSync(process.execPath, [mcpCheck], { timeout: 15000, stdio: "ignore", windowsHide: true });
-          report.actions.push({ type: "rebuild", name: "mcp-inventory", status: "ok" });
+          execFileSync(process.execPath, [mcpCheck], {
+            timeout: 15000,
+            stdio: "ignore",
+            windowsHide: true,
+          });
+          report.actions.push({
+            type: "rebuild",
+            name: "mcp-inventory",
+            status: "ok",
+          });
           ok("MCP 인벤토리 재생성됨");
         } catch {
-          report.actions.push({ type: "rebuild", name: "mcp-inventory", status: "failed" });
+          report.actions.push({
+            type: "rebuild",
+            name: "mcp-inventory",
+            status: "failed",
+          });
           warn("MCP 인벤토리 재생성 실패 — 다음 세션에서 자동 재시도");
         }
       }
       const hudScript = join(CLAUDE_DIR, "hud", "hud-qos-status.mjs");
       if (existsSync(hudScript)) {
         try {
-          execFileSync(process.execPath, [hudScript, "--refresh-claude-usage"], { timeout: 20000, stdio: "ignore", windowsHide: true });
-          report.actions.push({ type: "rebuild", name: "claude-usage-cache", status: "ok" });
+          execFileSync(
+            process.execPath,
+            [hudScript, "--refresh-claude-usage"],
+            { timeout: 20000, stdio: "ignore", windowsHide: true },
+          );
+          report.actions.push({
+            type: "rebuild",
+            name: "claude-usage-cache",
+            status: "ok",
+          });
           ok("Claude 사용량 캐시 재생성됨");
         } catch {
-          report.actions.push({ type: "rebuild", name: "claude-usage-cache", status: "failed" });
+          report.actions.push({
+            type: "rebuild",
+            name: "claude-usage-cache",
+            status: "failed",
+          });
           warn("Claude 사용량 캐시 재생성 실패 — 다음 API 호출 시 자동 생성");
         }
         try {
-          execFileSync(process.execPath, [hudScript, "--refresh-codex-rate-limits"], { timeout: 15000, stdio: "ignore", windowsHide: true });
-          report.actions.push({ type: "rebuild", name: "codex-rate-limits-cache", status: "ok" });
+          execFileSync(
+            process.execPath,
+            [hudScript, "--refresh-codex-rate-limits"],
+            { timeout: 15000, stdio: "ignore", windowsHide: true },
+          );
+          report.actions.push({
+            type: "rebuild",
+            name: "codex-rate-limits-cache",
+            status: "ok",
+          });
           ok("Codex 레이트 리밋 캐시 재생성됨");
         } catch {
-          report.actions.push({ type: "rebuild", name: "codex-rate-limits-cache", status: "failed" });
+          report.actions.push({
+            type: "rebuild",
+            name: "codex-rate-limits-cache",
+            status: "failed",
+          });
           warn("Codex 레이트 리밋 캐시 재생성 실패");
         }
         try {
-          execFileSync(process.execPath, [hudScript, "--refresh-gemini-quota"], { timeout: 15000, stdio: "ignore", windowsHide: true });
-          report.actions.push({ type: "rebuild", name: "gemini-quota-cache", status: "ok" });
+          execFileSync(
+            process.execPath,
+            [hudScript, "--refresh-gemini-quota"],
+            { timeout: 15000, stdio: "ignore", windowsHide: true },
+          );
+          report.actions.push({
+            type: "rebuild",
+            name: "gemini-quota-cache",
+            status: "ok",
+          });
           ok("Gemini 쿼터 캐시 재생성됨");
         } catch {
-          report.actions.push({ type: "rebuild", name: "gemini-quota-cache", status: "failed" });
+          report.actions.push({
+            type: "rebuild",
+            name: "gemini-quota-cache",
+            status: "failed",
+          });
           warn("Gemini 쿼터 캐시 재생성 실패");
         }
       }
@@ -1353,114 +1800,178 @@ async function cmdDoctor(options = {}) {
         const { buildAll } = await import("../scripts/cache-warmup.mjs");
         const warmupSummary = buildAll({ cwd: process.cwd(), force: true });
         if (warmupSummary.ok) {
-          report.actions.push({ type: "rebuild", name: "warmup-caches", status: "ok", built: warmupSummary.built });
+          report.actions.push({
+            type: "rebuild",
+            name: "warmup-caches",
+            status: "ok",
+            built: warmupSummary.built,
+          });
           ok("Phase 1 웜업 캐시 재생성됨");
         } else {
-          report.actions.push({ type: "rebuild", name: "warmup-caches", status: "failed" });
+          report.actions.push({
+            type: "rebuild",
+            name: "warmup-caches",
+            status: "failed",
+          });
           warn("Phase 1 웜업 캐시 재생성 실패");
         }
       } catch {
-        report.actions.push({ type: "rebuild", name: "warmup-caches", status: "failed" });
+        report.actions.push({
+          type: "rebuild",
+          name: "warmup-caches",
+          status: "failed",
+        });
         warn("Phase 1 웜업 캐시 재생성 실패");
       }
       console.log(`\n  ${LINE}`);
-      console.log(`  ${GREEN_BRIGHT}${BOLD}✓ 캐시 초기화 + 재생성 완료${RESET}\n`);
-      report.status = report.actions.some((action) => action.status === "failed") ? "issues" : "ok";
-      report.issue_count = report.actions.filter((action) => action.status === "failed").length;
+      console.log(
+        `  ${GREEN_BRIGHT}${BOLD}✓ 캐시 초기화 + 재생성 완료${RESET}\n`,
+      );
+      report.status = report.actions.some(
+        (action) => action.status === "failed",
+      )
+        ? "issues"
+        : "ok";
+      report.issue_count = report.actions.filter(
+        (action) => action.status === "failed",
+      ).length;
       if (json) printJson(report);
       return report;
     }
 
     // ── fix 모드: 파일 동기화 + 캐시 정리 후 진단 ──
     if (fix) {
-    section("Auto Fix");
-    for (const target of SYNC_MAP) {
-      syncFile(target.src, target.dst, target.label);
-    }
-    {
-      const claudeGuide = ensureGlobalClaudeRoutingSection(CLAUDE_DIR);
-      if (claudeGuide.skipped) warn(`CLAUDE.md 라우팅 섹션 확인 실패: ${claudeGuide.reason}`);
-      else if (claudeGuide.action === "created" || claudeGuide.action === "updated") ok("CLAUDE.md: 전역 triflux 라우팅 요약 갱신");
-    }
-    // 스킬 동기화
-    const fSkillsSrc = join(PKG_ROOT, "skills");
-    const fSkillsDst = join(CLAUDE_DIR, "skills");
-    if (existsSync(fSkillsSrc)) {
-      let sc = 0, st = 0;
-      for (const name of readdirSync(fSkillsSrc)) {
-        const src = join(fSkillsSrc, name, "SKILL.md");
-        const dst = join(fSkillsDst, name, "SKILL.md");
-        if (!existsSync(src)) continue;
-        st++;
-        const dstDir = dirname(dst);
-        if (!existsSync(dstDir)) mkdirSync(dstDir, { recursive: true });
-        if (!existsSync(dst)) { copyFileSync(src, dst); sc++; }
-        else if (readFileSync(src, "utf8") !== readFileSync(dst, "utf8")) { copyFileSync(src, dst); sc++; }
-      }
-      if (sc > 0) ok(`스킬: ${sc}/${st}개 업데이트됨`);
-      else ok(`스킬: ${st}개 최신 상태`);
-    }
-    const profileFix = ensureCodexProfiles();
-    if (!profileFix.ok) {
-      warn(`Codex Profiles 자동 복구 실패: ${renderErrorMessage(profileFix.message)}`);
-    } else if (profileFix.changed > 0) {
-      ok(`Codex Profiles: ${profileFix.changed}개 반영됨`);
-    } else {
-      info("Codex Profiles: 이미 최신 상태");
-    }
-    // 에러/스테일 캐시 정리
-    const fCacheDir = join(CLAUDE_DIR, "cache");
-    const staleNames = ["claude-usage-cache.json", ".claude-refresh-lock", "codex-rate-limits-cache.json"];
-    let cleaned = 0;
-    for (const name of staleNames) {
-      const fp = join(fCacheDir, name);
-      if (!existsSync(fp)) continue;
-      try {
-        const parsed = JSON.parse(readFileSync(fp, "utf8"));
-        if (parsed.error || name.startsWith(".")) { unlinkSync(fp); cleaned++; ok(`에러 캐시 정리: ${name}`); }
-      } catch { try { unlinkSync(fp); cleaned++; ok(`손상된 캐시 정리: ${name}`); } catch {} }
-    }
-    if (cleaned === 0) info("에러 캐시 없음");
-    try {
-      const { fixCaches } = await import("../scripts/cache-doctor.mjs");
-      const cacheRepair = await fixCaches({ cwd: process.cwd() });
-      if (cacheRepair.fixed.length > 0 && cacheRepair.ok) {
-        ok(`웜업 캐시 자동 복구: ${cacheRepair.fixed.join(", ")}`);
-      } else if (cacheRepair.fixed.length > 0) {
-        warn(`웜업 캐시 자동 복구 실패: ${cacheRepair.fixed.join(", ")}`);
+      section("Auto Fix");
+      for (const target of SYNC_MAP) {
+        syncFile(target.src, target.dst, target.label);
+      }
+      {
+        const claudeGuide = ensureGlobalClaudeRoutingSection(CLAUDE_DIR);
+        if (claudeGuide.skipped)
+          warn(`CLAUDE.md 라우팅 섹션 확인 실패: ${claudeGuide.reason}`);
+        else if (
+          claudeGuide.action === "created" ||
+          claudeGuide.action === "updated"
+        )
+          ok("CLAUDE.md: 전역 triflux 라우팅 요약 갱신");
+      }
+      // 스킬 동기화
+      const fSkillsSrc = join(PKG_ROOT, "skills");
+      const fSkillsDst = join(CLAUDE_DIR, "skills");
+      if (existsSync(fSkillsSrc)) {
+        let sc = 0,
+          st = 0;
+        for (const name of readdirSync(fSkillsSrc)) {
+          const src = join(fSkillsSrc, name, "SKILL.md");
+          const dst = join(fSkillsDst, name, "SKILL.md");
+          if (!existsSync(src)) continue;
+          st++;
+          const dstDir = dirname(dst);
+          if (!existsSync(dstDir)) mkdirSync(dstDir, { recursive: true });
+          if (!existsSync(dst)) {
+            copyFileSync(src, dst);
+            sc++;
+          } else if (readFileSync(src, "utf8") !== readFileSync(dst, "utf8")) {
+            copyFileSync(src, dst);
+            sc++;
+          }
+        }
+        if (sc > 0) ok(`스킬: ${sc}/${st}개 업데이트됨`);
+        else ok(`스킬: ${st}개 최신 상태`);
+      }
+      const profileFix = ensureCodexProfiles();
+      if (!profileFix.ok) {
+        warn(
+          `Codex Profiles 자동 복구 실패: ${renderErrorMessage(profileFix.message)}`,
+        );
+      } else if (profileFix.changed > 0) {
+        ok(`Codex Profiles: ${profileFix.changed}개 반영됨`);
       } else {
-        info("웜업 캐시: 이미 정상 상태");
+        info("Codex Profiles: 이미 최신 상태");
       }
-    } catch {
-      warn("웜업 캐시 자동 복구 실패");
-    }
-    const registryStateForFix = inspectRegistry();
-    if (registryStateForFix.valid) {
+      // 에러/스테일 캐시 정리
+      const fCacheDir = join(CLAUDE_DIR, "cache");
+      const staleNames = [
+        "claude-usage-cache.json",
+        ".claude-refresh-lock",
+        "codex-rate-limits-cache.json",
+      ];
+      let cleaned = 0;
+      for (const name of staleNames) {
+        const fp = join(fCacheDir, name);
+        if (!existsSync(fp)) continue;
+        try {
+          const parsed = JSON.parse(readFileSync(fp, "utf8"));
+          if (parsed.error || name.startsWith(".")) {
+            unlinkSync(fp);
+            cleaned++;
+            ok(`에러 캐시 정리: ${name}`);
+          }
+        } catch {
+          try {
+            unlinkSync(fp);
+            cleaned++;
+            ok(`손상된 캐시 정리: ${name}`);
+          } catch {}
+        }
+      }
+      if (cleaned === 0) info("에러 캐시 없음");
       try {
-        const mcpSync = syncRegistryTargets({ registry: registryStateForFix.registry });
-        const updatedCount = mcpSync.actions.filter((action) => action.status === "updated").length;
-        const invalidCount = mcpSync.actions.filter((action) => action.status === "invalid-config").length;
-        report.actions.push({ type: "mcp-sync", status: invalidCount > 0 ? "issues" : "ok", actions: mcpSync.actions });
-        if (updatedCount > 0) ok(`MCP registry 동기화: ${updatedCount}개 설정 반영됨`);
-        else info("MCP registry: 이미 최신 상태");
-        if (invalidCount > 0) warn(`MCP registry 동기화 건너뜀: parse error ${invalidCount}개`);
-      } catch (error) {
-        report.actions.push({ type: "mcp-sync", status: "failed", message: error.message });
-        warn(`MCP registry 자동 동기화 실패: ${error.message}`);
-      }
-    } else if (registryStateForFix.exists) {
-      saveRegistry(createDefaultRegistry());
-      report.actions.push({ type: "mcp-registry-reset", status: "ok" });
-      ok("MCP registry 손상 → 기본값으로 재생성됨");
-    } else {
-      saveRegistry(createDefaultRegistry());
-      report.actions.push({ type: "mcp-registry-create", status: "ok" });
-      ok("MCP registry 없음 → 기본값으로 자동 생성됨");
+        const { fixCaches } = await import("../scripts/cache-doctor.mjs");
+        const cacheRepair = await fixCaches({ cwd: process.cwd() });
+        if (cacheRepair.fixed.length > 0 && cacheRepair.ok) {
+          ok(`웜업 캐시 자동 복구: ${cacheRepair.fixed.join(", ")}`);
+        } else if (cacheRepair.fixed.length > 0) {
+          warn(`웜업 캐시 자동 복구 실패: ${cacheRepair.fixed.join(", ")}`);
+        } else {
+          info("웜업 캐시: 이미 정상 상태");
+        }
+      } catch {
+        warn("웜업 캐시 자동 복구 실패");
+      }
+      const registryStateForFix = inspectRegistry();
+      if (registryStateForFix.valid) {
+        try {
+          const mcpSync = syncRegistryTargets({
+            registry: registryStateForFix.registry,
+          });
+          const updatedCount = mcpSync.actions.filter(
+            (action) => action.status === "updated",
+          ).length;
+          const invalidCount = mcpSync.actions.filter(
+            (action) => action.status === "invalid-config",
+          ).length;
+          report.actions.push({
+            type: "mcp-sync",
+            status: invalidCount > 0 ? "issues" : "ok",
+            actions: mcpSync.actions,
+          });
+          if (updatedCount > 0)
+            ok(`MCP registry 동기화: ${updatedCount}개 설정 반영됨`);
+          else info("MCP registry: 이미 최신 상태");
+          if (invalidCount > 0)
+            warn(`MCP registry 동기화 건너뜀: parse error ${invalidCount}개`);
+        } catch (error) {
+          report.actions.push({
+            type: "mcp-sync",
+            status: "failed",
+            message: error.message,
+          });
+          warn(`MCP registry 자동 동기화 실패: ${error.message}`);
+        }
+      } else if (registryStateForFix.exists) {
+        saveRegistry(createDefaultRegistry());
+        report.actions.push({ type: "mcp-registry-reset", status: "ok" });
+        ok("MCP registry 손상 → 기본값으로 재생성됨");
+      } else {
+        saveRegistry(createDefaultRegistry());
+        report.actions.push({ type: "mcp-registry-create", status: "ok" });
+        ok("MCP registry 없음 → 기본값으로 자동 생성됨");
+      }
+      console.log(`\n  ${LINE}`);
+      info("수정 완료 — 아래 진단 결과를 확인하세요");
+      console.log("");
     }
-    console.log(`\n  ${LINE}`);
-    info("수정 완료 — 아래 진단 결과를 확인하세요");
-    console.log("");
-  }
 
     let issues = 0;
 
@@ -1469,10 +1980,20 @@ async function cmdDoctor(options = {}) {
     const routeSh = join(CLAUDE_DIR, "scripts", "tfx-route.sh");
     if (existsSync(routeSh)) {
       const ver = getVersion(routeSh);
-      addDoctorCheck(report, { name: "tfx-route.sh", status: "ok", path: routeSh, version: ver });
+      addDoctorCheck(report, {
+        name: "tfx-route.sh",
+        status: "ok",
+        path: routeSh,
+        version: ver,
+      });
       ok(`설치됨 ${ver ? `${DIM}v${ver}${RESET}` : ""}`);
     } else {
-      addDoctorCheck(report, { name: "tfx-route.sh", status: "missing", path: routeSh, fix: "tfx setup" });
+      addDoctorCheck(report, {
+        name: "tfx-route.sh",
+        status: "missing",
+        path: routeSh,
+        fix: "tfx setup",
+      });
       fail("미설치 — tfx setup 실행 필요");
       issues++;
     }
@@ -1481,16 +2002,29 @@ async function cmdDoctor(options = {}) {
     section("HUD");
     const hud = join(CLAUDE_DIR, "hud", "hud-qos-status.mjs");
     if (existsSync(hud)) {
-      addDoctorCheck(report, { name: "hud-qos-status.mjs", status: "ok", path: hud });
+      addDoctorCheck(report, {
+        name: "hud-qos-status.mjs",
+        status: "ok",
+        path: hud,
+      });
       ok("설치됨");
     } else {
-      addDoctorCheck(report, { name: "hud-qos-status.mjs", status: "missing", path: hud, optional: true, fix: "tfx setup" });
+      addDoctorCheck(report, {
+        name: "hud-qos-status.mjs",
+        status: "missing",
+        path: hud,
+        optional: true,
+        fix: "tfx setup",
+      });
       warn(`미설치 ${GRAY}(선택사항)${RESET}`);
     }
 
     // 3. Codex CLI
     section(`Codex CLI ${WHITE_BRIGHT}●${RESET}`);
-    const codexCli = checkCliCrossShell("codex", "npm install -g @openai/codex");
+    const codexCli = checkCliCrossShell(
+      "codex",
+      "npm install -g @openai/codex",
+    );
     issues += codexCli.issues;
     addDoctorCheck(report, {
       name: "codex",
@@ -1507,9 +2041,13 @@ async function cmdDoctor(options = {}) {
       const missingProfiles = [];
       for (const profile of REQUIRED_CODEX_PROFILES) {
         if (hasProfileSection(codexConfig, profile.name)) {
-          ok(`${profile.name}: 정상${profile.proOnly ? ` ${DIM}(Pro 전용)${RESET}` : ""}`);
+          ok(
+            `${profile.name}: 정상${profile.proOnly ? ` ${DIM}(Pro 전용)${RESET}` : ""}`,
+          );
         } else if (profile.proOnly) {
-          info(`${profile.name}: 미설정 ${DIM}(Pro 전용 — Plus/기본에서는 불필요)${RESET}`);
+          info(
+            `${profile.name}: 미설정 ${DIM}(Pro 전용 — Plus/기본에서는 불필요)${RESET}`,
+          );
         } else {
           missingProfiles.push(profile.name);
           warn(`${profile.name}: 미설정`);
@@ -1524,7 +2062,12 @@ async function cmdDoctor(options = {}) {
         ...(missingProfiles.length > 0 ? { fix: "tfx setup" } : {}),
       });
     } else {
-      addDoctorCheck(report, { name: "codex-profiles", status: "missing", path: CODEX_CONFIG_PATH, fix: "tfx setup" });
+      addDoctorCheck(report, {
+        name: "codex-profiles",
+        status: "missing",
+        path: CODEX_CONFIG_PATH,
+        fix: "tfx setup",
+      });
       warn("config.toml 미존재");
       issues++;
     }
@@ -1532,11 +2075,18 @@ async function cmdDoctor(options = {}) {
     // Codex 구형 모델 감지
     if (existsSync(CODEX_CONFIG_PATH)) {
       const codexContent = readFileSync(CODEX_CONFIG_PATH, "utf8");
-      const legacyFound = LEGACY_CODEX_MODELS.filter(m => codexContent.includes(`"${m}"`));
+      const legacyFound = LEGACY_CODEX_MODELS.filter((m) =>
+        codexContent.includes(`"${m}"`),
+      );
       if (legacyFound.length > 0) {
         warn(`구형 모델 감지: ${legacyFound.join(", ")}`);
         info("최신 프로필로 마이그레이션: tfx setup 또는 tfx profile");
-        addDoctorCheck(report, { name: "codex-legacy-models", status: "issues", models: legacyFound, fix: "tfx setup" });
+        addDoctorCheck(report, {
+          name: "codex-legacy-models",
+          status: "issues",
+          models: legacyFound,
+          fix: "tfx setup",
+        });
         issues++;
       }
     }
@@ -1548,7 +2098,9 @@ async function cmdDoctor(options = {}) {
       const serenaConfig = inspectSerenaMcpConfig(codexConfig);
       if (!serenaConfig.present) {
         warn("serena MCP 설정 없음");
-        info("권장: [mcp_servers.serena]에 --project-from-cwd, --context codex, startup_timeout_sec=30+ 설정");
+        info(
+          "권장: [mcp_servers.serena]에 --project-from-cwd, --context codex, startup_timeout_sec=30+ 설정",
+        );
         addDoctorCheck(report, {
           name: "serena-mcp",
           status: "missing",
@@ -1557,7 +2109,8 @@ async function cmdDoctor(options = {}) {
         });
         issues++;
       } else {
-        const hasSerenaIssues = !serenaConfig.hasProjectBinding || !serenaConfig.timeoutRecommended;
+        const hasSerenaIssues =
+          !serenaConfig.hasProjectBinding || !serenaConfig.timeoutRecommended;
 
         if (serenaConfig.hasProjectBinding) ok("project binding: 정상");
         else {
@@ -1589,7 +2142,9 @@ async function cmdDoctor(options = {}) {
           context_codex: serenaConfig.hasContextCodex,
           startup_timeout_sec: serenaConfig.startupTimeoutSec,
           ...(hasSerenaIssues
-            ? { fix: "Serena MCP에 --project-from-cwd 와 startup_timeout_sec=30+ 를 설정하세요." }
+            ? {
+                fix: "Serena MCP에 --project-from-cwd 와 startup_timeout_sec=30+ 를 설정하세요.",
+              }
             : {}),
         });
       }
@@ -1606,7 +2161,10 @@ async function cmdDoctor(options = {}) {
 
     // 5. Gemini CLI
     section(`Gemini CLI ${BLUE}●${RESET}`);
-    const geminiCli = checkCliCrossShell("gemini", "npm install -g @google/gemini-cli");
+    const geminiCli = checkCliCrossShell(
+      "gemini",
+      "npm install -g @google/gemini-cli",
+    );
     issues += geminiCli.issues;
     addDoctorCheck(report, {
       name: "gemini",
@@ -1617,16 +2175,32 @@ async function cmdDoctor(options = {}) {
     // API 키 검사 제거 — bash exec 기반이므로 API 키 불필요
 
     // Gemini 구형 모델 감지
-    const geminiProfilesPath = join(homedir(), ".gemini", "triflux-profiles.json");
-    const LEGACY_GEMINI_MODELS = ["gemini-2.0-flash", "gemini-1.5-pro", "gemini-1.5-flash", "gemini-2.5-pro-preview"];
+    const geminiProfilesPath = join(
+      homedir(),
+      ".gemini",
+      "triflux-profiles.json",
+    );
+    const LEGACY_GEMINI_MODELS = [
+      "gemini-2.0-flash",
+      "gemini-1.5-pro",
+      "gemini-1.5-flash",
+      "gemini-2.5-pro-preview",
+    ];
     if (existsSync(geminiProfilesPath)) {
       try {
         const geminiContent = readFileSync(geminiProfilesPath, "utf8");
-        const geminiLegacy = LEGACY_GEMINI_MODELS.filter(m => geminiContent.includes(m));
+        const geminiLegacy = LEGACY_GEMINI_MODELS.filter((m) =>
+          geminiContent.includes(m),
+        );
         if (geminiLegacy.length > 0) {
           warn(`구형 모델 감지: ${geminiLegacy.join(", ")}`);
           info("최신 프로필로 마이그레이션: tfx setup 또는 tfx profile");
-          addDoctorCheck(report, { name: "gemini-legacy-models", status: "issues", models: geminiLegacy, fix: "tfx setup" });
+          addDoctorCheck(report, {
+            name: "gemini-legacy-models",
+            status: "issues",
+            models: geminiLegacy,
+            fix: "tfx setup",
+          });
           issues++;
         }
       } catch {}
@@ -1636,10 +2210,18 @@ async function cmdDoctor(options = {}) {
     section(`Claude Code ${AMBER}●${RESET}`);
     const claudePath = which("claude");
     if (claudePath) {
-      addDoctorCheck(report, { name: "claude", status: "ok", path: claudePath });
+      addDoctorCheck(report, {
+        name: "claude",
+        status: "ok",
+        path: claudePath,
+      });
       ok("설치됨");
     } else {
-      addDoctorCheck(report, { name: "claude", status: "missing", fix: "Claude Code를 설치한 뒤 `tfx doctor`를 다시 실행하세요." });
+      addDoctorCheck(report, {
+        name: "claude",
+        status: "missing",
+        fix: "Claude Code를 설치한 뒤 `tfx doctor`를 다시 실행하세요.",
+      });
       fail("미설치 (필수)");
       issues++;
     }
@@ -1650,7 +2232,9 @@ async function cmdDoctor(options = {}) {
       const psmuxPath = which("psmux");
       if (psmuxPath) {
         ok("설치됨");
-        const psmuxSupport = probePsmuxSupport({ execFileSyncFn: execFileSync });
+        const psmuxSupport = probePsmuxSupport({
+          execFileSyncFn: execFileSync,
+        });
         const supportOk = psmuxSupport.ok;
         info(`버전: ${psmuxSupport.version || "unknown"}`);
         if (!supportOk) {
@@ -1666,17 +2250,24 @@ async function cmdDoctor(options = {}) {
           });
           issues++;
         } else if (!psmuxSupport.recommended) {
-          warn(`권장 버전 미만: v${psmuxSupport.version || "unknown"} (권장: v${psmuxSupport.recommendedVersion}+)`);
+          warn(
+            `권장 버전 미만: v${psmuxSupport.version || "unknown"} (권장: v${psmuxSupport.recommendedVersion}+)`,
+          );
           info(`업데이트 권장:\n${formatPsmuxUpdateGuidance("  ")}`);
         }
         if (psmuxSupport.missingOptionalCommands?.length > 0) {
-          info(`선택 capability 미지원: ${psmuxSupport.missingOptionalCommands.join(", ")} (detach-first hardening 경로에서만 사용)`);
+          info(
+            `선택 capability 미지원: ${psmuxSupport.missingOptionalCommands.join(", ")} (detach-first hardening 경로에서만 사용)`,
+          );
         }
 
         // 기본 셸 확인: psmux 세션의 기본 셸이 PowerShell인지 cmd.exe인지
         let shellOk = false;
         try {
-          const defaultShell = execSync("psmux show-options -g default-shell 2>NUL", { encoding: "utf8", timeout: 3000 }).trim();
+          const defaultShell = execSync(
+            "psmux show-options -g default-shell 2>NUL",
+            { encoding: "utf8", timeout: 3000 },
+          ).trim();
           shellOk = /powershell|pwsh/i.test(defaultShell);
         } catch {
           // show-options 실패 시 pwsh/powershell 존재 여부로 판단
@@ -1684,65 +2275,116 @@ async function cmdDoctor(options = {}) {
         }
         if (supportOk && shellOk) {
           ok("기본 셸: PowerShell");
-          addDoctorCheck(report, { name: "psmux", status: "ok", path: psmuxPath, shell: "powershell" });
+          addDoctorCheck(report, {
+            name: "psmux",
+            status: "ok",
+            path: psmuxPath,
+            shell: "powershell",
+          });
         } else {
           if (fix) {
             // --fix: PowerShell로 자동 변경
             const pwshBin = which("pwsh") ? "pwsh" : "powershell.exe";
             try {
-              execSync(`psmux set-option -g default-shell "${pwshBin}"`, { timeout: 3000, stdio: "pipe" });
+              execSync(`psmux set-option -g default-shell "${pwshBin}"`, {
+                timeout: 3000,
+                stdio: "pipe",
+              });
               ok(`기본 셸 → ${pwshBin} 으로 변경 완료`);
-              addDoctorCheck(report, { name: "psmux", status: "ok", path: psmuxPath, shell: pwshBin, fixed: true });
+              addDoctorCheck(report, {
+                name: "psmux",
+                status: "ok",
+                path: psmuxPath,
+                shell: pwshBin,
+                fixed: true,
+              });
               report.actions.push("psmux default-shell → " + pwshBin);
             } catch (e) {
               fail(`기본 셸 변경 실패: ${e.message}`);
-              addDoctorCheck(report, { name: "psmux", status: "issues", path: psmuxPath, shell: "cmd", fix: `psmux set-option -g default-shell "${pwshBin}"` });
+              addDoctorCheck(report, {
+                name: "psmux",
+                status: "issues",
+                path: psmuxPath,
+                shell: "cmd",
+                fix: `psmux set-option -g default-shell "${pwshBin}"`,
+              });
               issues++;
             }
           } else {
             warn("기본 셸이 cmd.exe — headless 명령 실패 가능");
-            info(`수정: tfx doctor --fix 또는 psmux set-option -g default-shell "powershell.exe"`);
-            addDoctorCheck(report, { name: "psmux", status: "issues", path: psmuxPath, shell: "cmd", fix: "tfx doctor --fix" });
+            info(
+              `수정: tfx doctor --fix 또는 psmux set-option -g default-shell "powershell.exe"`,
+            );
+            addDoctorCheck(report, {
+              name: "psmux",
+              status: "issues",
+              path: psmuxPath,
+              shell: "cmd",
+              fix: "tfx doctor --fix",
+            });
             issues++;
           }
         }
       } else {
         info(`미설치 ${GRAY}(선택 — 멀티모델 병렬 실행에 필요)${RESET}`);
         info(`설치 방법:\n${formatPsmuxInstallGuidance("  ")}`);
-        addDoctorCheck(report, { name: "psmux", status: "skipped", detail: "미설치 (선택)", fix: "winget install marlocarlo.psmux" });
+        addDoctorCheck(report, {
+          name: "psmux",
+          status: "skipped",
+          detail: "미설치 (선택)",
+          fix: "winget install marlocarlo.psmux",
+        });
       }
     }
 
-  // 8. 스킬 설치 상태
-  section("Skills");
-  const skillsSrc = join(PKG_ROOT, "skills");
-  const skillsDst = join(CLAUDE_DIR, "skills");
-  if (existsSync(skillsSrc)) {
-    let installed = 0;
-    let total = 0;
-    const missing = [];
-    for (const name of readdirSync(skillsSrc)) {
-      if (!existsSync(join(skillsSrc, name, "SKILL.md"))) continue;
-      total++;
-      if (existsSync(join(skillsDst, name, "SKILL.md"))) {
-        installed++;
-      } else {
-        missing.push(name);
+    // 8. 스킬 설치 상태
+    section("Skills");
+    const skillsSrc = join(PKG_ROOT, "skills");
+    const skillsDst = join(CLAUDE_DIR, "skills");
+    if (existsSync(skillsSrc)) {
+      let installed = 0;
+      let total = 0;
+      const missing = [];
+      for (const name of readdirSync(skillsSrc)) {
+        if (!existsSync(join(skillsSrc, name, "SKILL.md"))) continue;
+        total++;
+        if (existsSync(join(skillsDst, name, "SKILL.md"))) {
+          installed++;
+        } else {
+          missing.push(name);
+        }
       }
-    }
       if (installed === total) {
-        addDoctorCheck(report, { name: "skills", status: "ok", installed, total });
+        addDoctorCheck(report, {
+          name: "skills",
+          status: "ok",
+          installed,
+          total,
+        });
         ok(`${installed}/${total}개 설치됨`);
       } else {
-        addDoctorCheck(report, { name: "skills", status: "missing", installed, total, missing, fix: "tfx setup" });
+        addDoctorCheck(report, {
+          name: "skills",
+          status: "missing",
+          installed,
+          total,
+          missing,
+          fix: "tfx setup",
+        });
         warn(`${installed}/${total}개 설치됨 — 미설치: ${missing.join(", ")}`);
         info("triflux setup으로 동기화 가능");
         issues++;
       }
     } else {
-      addDoctorCheck(report, { name: "skills", status: "missing", installed: 0, total: 0, fix: "패키지 skills 디렉토리를 확인하세요." });
-    }
-
+      addDoctorCheck(report, {
+        name: "skills",
+        status: "missing",
+        installed: 0,
+        total: 0,
+        fix: "패키지 skills 디렉토리를 확인하세요.",
+      });
+    }
+
     // Stale 스킬 체크
     const staleSkills = [];
     const userSkillsDir = join(CLAUDE_DIR, "skills");
@@ -1762,7 +2404,12 @@ async function cmdDoctor(options = {}) {
     if (staleSkills.length > 0) {
       warn(`구형 스킬 ${staleSkills.length}개 감지: ${staleSkills.join(", ")}`);
       info("제거: tfx setup 또는 tfx update");
-      addDoctorCheck(report, { name: "stale-skills", status: "issues", skills: staleSkills, fix: "tfx setup" });
+      addDoctorCheck(report, {
+        name: "stale-skills",
+        status: "issues",
+        skills: staleSkills,
+        fix: "tfx setup",
+      });
       issues++;
     } else {
       addDoctorCheck(report, { name: "stale-skills", status: "ok" });
@@ -1774,776 +2421,1041 @@ async function cmdDoctor(options = {}) {
     if (existsSync(pluginsFile)) {
       const content = readFileSync(pluginsFile, "utf8");
       if (content.includes("triflux")) {
-        addDoctorCheck(report, { name: "plugin", status: "ok", path: pluginsFile });
+        addDoctorCheck(report, {
+          name: "plugin",
+          status: "ok",
+          path: pluginsFile,
+        });
         ok("triflux 플러그인 등록됨");
       } else {
-        addDoctorCheck(report, { name: "plugin", status: "missing", path: pluginsFile, optional: true, fix: "/plugin marketplace add <repo-url>" });
+        addDoctorCheck(report, {
+          name: "plugin",
+          status: "missing",
+          path: pluginsFile,
+          optional: true,
+          fix: "/plugin marketplace add <repo-url>",
+        });
         warn("triflux 플러그인 미등록 — npm 단독 사용 중");
         info("플러그인 등록: /plugin marketplace add <repo-url>");
       }
     } else {
-      addDoctorCheck(report, { name: "plugin", status: "unavailable", optional: true });
+      addDoctorCheck(report, {
+        name: "plugin",
+        status: "unavailable",
+        optional: true,
+      });
       info("플러그인 시스템 감지 안 됨 — npm 단독 사용");
     }
 
-  // 10. MCP 인벤토리
-  section("MCP Inventory");
-  const mcpCache = join(CLAUDE_DIR, "cache", "mcp-inventory.json");
-  if (existsSync(mcpCache)) {
-    try {
-      const inv = JSON.parse(readFileSync(mcpCache, "utf8"));
+    // 10. MCP 인벤토리
+    section("MCP Inventory");
+    const mcpCache = join(CLAUDE_DIR, "cache", "mcp-inventory.json");
+    if (existsSync(mcpCache)) {
+      try {
+        const inv = JSON.parse(readFileSync(mcpCache, "utf8"));
+        addDoctorCheck(report, {
+          name: "mcp-inventory",
+          status: "ok",
+          path: mcpCache,
+          codex_servers: inv.codex?.servers?.length || 0,
+          gemini_servers: inv.gemini?.servers?.length || 0,
+        });
+        ok(`캐시 존재 (${inv.timestamp})`);
+        if (inv.codex?.servers?.length) {
+          const names = inv.codex.servers.map((s) => s.name).join(", ");
+          info(`Codex: ${inv.codex.servers.length}개 서버 (${names})`);
+        }
+        if (inv.gemini?.servers?.length) {
+          const names = inv.gemini.servers.map((s) => s.name).join(", ");
+          info(`Gemini: ${inv.gemini.servers.length}개 서버 (${names})`);
+        }
+      } catch {
+        addDoctorCheck(report, {
+          name: "mcp-inventory",
+          status: "invalid",
+          path: mcpCache,
+          fix: `node ${join(PKG_ROOT, "scripts", "mcp-check.mjs")}`,
+        });
+        warn("캐시 파일 파싱 실패");
+      }
+    } else {
       addDoctorCheck(report, {
         name: "mcp-inventory",
-        status: "ok",
+        status: "missing",
         path: mcpCache,
-        codex_servers: inv.codex?.servers?.length || 0,
-        gemini_servers: inv.gemini?.servers?.length || 0,
+        fix: `node ${join(PKG_ROOT, "scripts", "mcp-check.mjs")}`,
       });
-      ok(`캐시 존재 (${inv.timestamp})`);
-      if (inv.codex?.servers?.length) {
-        const names = inv.codex.servers.map(s => s.name).join(", ");
-        info(`Codex: ${inv.codex.servers.length}개 서버 (${names})`);
-      }
-      if (inv.gemini?.servers?.length) {
-        const names = inv.gemini.servers.map(s => s.name).join(", ");
-        info(`Gemini: ${inv.gemini.servers.length}개 서버 (${names})`);
-      }
-    } catch {
-      addDoctorCheck(report, { name: "mcp-inventory", status: "invalid", path: mcpCache, fix: `node ${join(PKG_ROOT, "scripts", "mcp-check.mjs")}` });
-      warn("캐시 파일 파싱 실패");
+      warn("캐시 없음 — 다음 세션 시작 시 자동 생성");
+      info(`수동: node ${join(PKG_ROOT, "scripts", "mcp-check.mjs")}`);
     }
-  } else {
-    addDoctorCheck(report, { name: "mcp-inventory", status: "missing", path: mcpCache, fix: `node ${join(PKG_ROOT, "scripts", "mcp-check.mjs")}` });
-    warn("캐시 없음 — 다음 세션 시작 시 자동 생성");
-    info(`수동: node ${join(PKG_ROOT, "scripts", "mcp-check.mjs")}`);
-  }
 
-  // 9.5. Phase 1 웜업 캐시
-  section("Warmup Cache");
-  try {
-    const { verifyCaches } = await import("../scripts/cache-doctor.mjs");
-    const cacheVerification = verifyCaches({ cwd: process.cwd() });
-    const brokenCaches = cacheVerification.results.filter((result) => result.status !== "ok");
+    // 9.5. Phase 1 웜업 캐시
+    section("Warmup Cache");
+    try {
+      const { verifyCaches } = await import("../scripts/cache-doctor.mjs");
+      const cacheVerification = verifyCaches({ cwd: process.cwd() });
+      const brokenCaches = cacheVerification.results.filter(
+        (result) => result.status !== "ok",
+      );
 
-    addDoctorCheck(report, {
-      name: "warmup-cache",
-      status: cacheVerification.ok ? "ok" : "issues",
-      files: cacheVerification.results.map((result) => ({
-        target: result.target,
-        status: result.status,
-        path: result.file,
-      })),
-      ...(cacheVerification.ok ? {} : { fix: "tfx doctor --fix" }),
-    });
+      addDoctorCheck(report, {
+        name: "warmup-cache",
+        status: cacheVerification.ok ? "ok" : "issues",
+        files: cacheVerification.results.map((result) => ({
+          target: result.target,
+          status: result.status,
+          path: result.file,
+        })),
+        ...(cacheVerification.ok ? {} : { fix: "tfx doctor --fix" }),
+      });
 
-    if (brokenCaches.length === 0) {
-      ok("4개 웜업 캐시 정상");
-    } else {
-      warn(`${brokenCaches.length}개 웜업 캐시 이슈 발견`);
-      for (const entry of brokenCaches) {
-        info(`${entry.target}: ${entry.status}`);
+      if (brokenCaches.length === 0) {
+        ok("4개 웜업 캐시 정상");
+      } else {
+        warn(`${brokenCaches.length}개 웜업 캐시 이슈 발견`);
+        for (const entry of brokenCaches) {
+          info(`${entry.target}: ${entry.status}`);
+        }
+        if (!fix) issues += brokenCaches.length;
       }
-      if (!fix) issues += brokenCaches.length;
+    } catch (error) {
+      addDoctorCheck(report, {
+        name: "warmup-cache",
+        status: "invalid",
+        fix: "node scripts/cache-doctor.mjs --fix",
+      });
+      warn(`웜업 캐시 검사 실패: ${error.message}`);
+      issues++;
     }
-  } catch (error) {
-    addDoctorCheck(report, {
-      name: "warmup-cache",
-      status: "invalid",
-      fix: "node scripts/cache-doctor.mjs --fix",
-    });
-    warn(`웜업 캐시 검사 실패: ${error.message}`);
-    issues++;
-  }
 
-  // 11. CLI 이슈 트래커
-  section("CLI Issues");
-  const issuesFile = join(CLAUDE_DIR, "cache", "cli-issues.jsonl");
-  if (existsSync(issuesFile)) {
-    try {
-      const lines = readFileSync(issuesFile, "utf8").trim().split("\n").filter(Boolean);
-      const entries = lines.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
-      const unresolved = entries.filter(e => !e.resolved);
+    // 11. CLI 이슈 트래커
+    section("CLI Issues");
+    const issuesFile = join(CLAUDE_DIR, "cache", "cli-issues.jsonl");
+    if (existsSync(issuesFile)) {
+      try {
+        const lines = readFileSync(issuesFile, "utf8")
+          .trim()
+          .split("\n")
+          .filter(Boolean);
+        const entries = lines
+          .map((l) => {
+            try {
+              return JSON.parse(l);
+            } catch {
+              return null;
+            }
+          })
+          .filter(Boolean);
+        const unresolved = entries.filter((e) => !e.resolved);
 
-      if (unresolved.length === 0) {
-        addDoctorCheck(report, { name: "cli-issues", status: "ok", path: issuesFile, unresolved: 0 });
-        ok("미해결 이슈 없음");
-      } else {
-        // 패턴별 그룹핑
-        const groups = {};
-        for (const e of unresolved) {
-          const key = `${e.cli}:${e.pattern}`;
-          if (!groups[key]) groups[key] = { ...e, count: 0 };
-          groups[key].count++;
-          if (e.ts > groups[key].ts) { groups[key].ts = e.ts; groups[key].snippet = e.snippet; }
-        }
-
-        // semver 비교 (lexicographic 비교 버그 방지)
-        function semverGte(a, b) {
-          const pa = a.split('.').map(Number);
-          const pb = b.split('.').map(Number);
-          for (let i = 0; i < 3; i++) {
-            if ((pa[i] || 0) > (pb[i] || 0)) return true;
-            if ((pa[i] || 0) < (pb[i] || 0)) return false;
+        if (unresolved.length === 0) {
+          addDoctorCheck(report, {
+            name: "cli-issues",
+            status: "ok",
+            path: issuesFile,
+            unresolved: 0,
+          });
+          ok("미해결 이슈 없음");
+        } else {
+          // 패턴별 그룹핑
+          const groups = {};
+          for (const e of unresolved) {
+            const key = `${e.cli}:${e.pattern}`;
+            if (!groups[key]) groups[key] = { ...e, count: 0 };
+            groups[key].count++;
+            if (e.ts > groups[key].ts) {
+              groups[key].ts = e.ts;
+              groups[key].snippet = e.snippet;
+            }
           }
-          return true;
-        }
 
-        // 알려진 해결 버전 (패턴별 수정된 triflux 버전)
-        const KNOWN_FIXES = {
-          "gemini:deprecated_flag": "1.8.9",  // -p → --prompt
-        };
+          // semver 비교 (lexicographic 비교 버그 방지)
+          function semverGte(a, b) {
+            const pa = a.split(".").map(Number);
+            const pb = b.split(".").map(Number);
+            for (let i = 0; i < 3; i++) {
+              if ((pa[i] || 0) > (pb[i] || 0)) return true;
+              if ((pa[i] || 0) < (pb[i] || 0)) return false;
+            }
+            return true;
+          }
 
-        const currentVer = JSON.parse(readFileSync(join(PKG_ROOT, "package.json"), "utf8")).version;
-        let cleaned = 0;
+          // 알려진 해결 버전 (패턴별 수정된 triflux 버전)
+          const KNOWN_FIXES = {
+            "gemini:deprecated_flag": "1.8.9", // -p → --prompt
+          };
 
-        for (const [key, g] of Object.entries(groups)) {
-          const fixVer = KNOWN_FIXES[key];
-          if (fixVer && semverGte(currentVer, fixVer)) {
-            // 해결된 이슈 — 자동 정리
-            cleaned += g.count;
-            continue;
-          }
-          const age = Date.now() - g.ts;
-          const ago = age < 3600000 ? `${Math.round(age / 60000)}분 전` :
-            age < 86400000 ? `${Math.round(age / 3600000)}시간 전` :
-            `${Math.round(age / 86400000)}일 전`;
-          const sev = g.severity === "error" ? `${RED}ERROR${RESET}` : `${YELLOW}WARN${RESET}`;
-          warn(`[${sev}] ${g.cli}/${g.pattern} x${g.count} (최근: ${ago})`);
-          if (g.snippet) info(`  ${g.snippet.substring(0, 120)}`);
-          if (fixVer) info(`  해결: triflux >= v${fixVer} (npm update -g triflux)`);
-          issues++;
-        }
+          const currentVer = JSON.parse(
+            readFileSync(join(PKG_ROOT, "package.json"), "utf8"),
+          ).version;
+          let cleaned = 0;
 
-        // 해결된 이슈 자동 정리
-        if (cleaned > 0) {
-          const remaining = entries.filter(e => {
-            const key = `${e.cli}:${e.pattern}`;
+          for (const [key, g] of Object.entries(groups)) {
             const fixVer = KNOWN_FIXES[key];
-            return !(fixVer && semverGte(currentVer, fixVer));
+            if (fixVer && semverGte(currentVer, fixVer)) {
+              // 해결된 이슈 — 자동 정리
+              cleaned += g.count;
+              continue;
+            }
+            const age = Date.now() - g.ts;
+            const ago =
+              age < 3600000
+                ? `${Math.round(age / 60000)}분 전`
+                : age < 86400000
+                  ? `${Math.round(age / 3600000)}시간 전`
+                  : `${Math.round(age / 86400000)}일 전`;
+            const sev =
+              g.severity === "error"
+                ? `${RED}ERROR${RESET}`
+                : `${YELLOW}WARN${RESET}`;
+            warn(`[${sev}] ${g.cli}/${g.pattern} x${g.count} (최근: ${ago})`);
+            if (g.snippet) info(`  ${g.snippet.substring(0, 120)}`);
+            if (fixVer)
+              info(`  해결: triflux >= v${fixVer} (npm update -g triflux)`);
+            issues++;
+          }
+
+          // 해결된 이슈 자동 정리
+          if (cleaned > 0) {
+            const remaining = entries.filter((e) => {
+              const key = `${e.cli}:${e.pattern}`;
+              const fixVer = KNOWN_FIXES[key];
+              return !(fixVer && semverGte(currentVer, fixVer));
+            });
+            writeFileSync(
+              issuesFile,
+              remaining.map((e) => JSON.stringify(e)).join("\n") +
+                (remaining.length ? "\n" : ""),
+            );
+            ok(`${cleaned}개 해결된 이슈 자동 정리됨`);
+          }
+          addDoctorCheck(report, {
+            name: "cli-issues",
+            status: unresolved.length === 0 ? "ok" : "issues",
+            path: issuesFile,
+            unresolved: unresolved.length,
           });
-          writeFileSync(issuesFile, remaining.map(e => JSON.stringify(e)).join("\n") + (remaining.length ? "\n" : ""));
-          ok(`${cleaned}개 해결된 이슈 자동 정리됨`);
         }
-        addDoctorCheck(report, { name: "cli-issues", status: unresolved.length === 0 ? "ok" : "issues", path: issuesFile, unresolved: unresolved.length });
+      } catch (e) {
+        addDoctorCheck(report, {
+          name: "cli-issues",
+          status: "invalid",
+          path: issuesFile,
+          fix: "cli-issues.jsonl 형식을 확인하세요.",
+        });
+        warn(`이슈 파일 읽기 실패: ${e.message}`);
       }
-    } catch (e) {
-      addDoctorCheck(report, { name: "cli-issues", status: "invalid", path: issuesFile, fix: "cli-issues.jsonl 형식을 확인하세요." });
-      warn(`이슈 파일 읽기 실패: ${e.message}`);
+    } else {
+      addDoctorCheck(report, {
+        name: "cli-issues",
+        status: "ok",
+        path: issuesFile,
+        unresolved: 0,
+      });
+      ok("이슈 로그 없음 (정상)");
     }
-  } else {
-    addDoctorCheck(report, { name: "cli-issues", status: "ok", path: issuesFile, unresolved: 0 });
-    ok("이슈 로그 없음 (정상)");
-  }
-
-  // 12. Team Sessions
-  section("Team Sessions");
-  const teamSessionReport = inspectTeamSessions();
-  if (!teamSessionReport.mux) {
-    addDoctorCheck(report, { name: "team-sessions", status: "skipped", detail: "tmux/psmux unavailable" });
-    info("tmux/psmux 미감지 — 팀 세션 검사 건너뜀");
-  } else if (teamSessionReport.sessions.length === 0) {
-    addDoctorCheck(report, { name: "team-sessions", status: "ok", multiplexer: teamSessionReport.mux, sessions: 0 });
-    ok(`활성 팀 세션 없음 ${DIM}(${teamSessionReport.mux})${RESET}`);
-  } else {
-    addDoctorCheck(report, {
-      name: "team-sessions",
-      status: teamSessionReport.sessions.some((session) => session.stale) ? "issues" : "ok",
-      multiplexer: teamSessionReport.mux,
-      sessions: teamSessionReport.sessions.map((session) => ({
-        name: session.sessionName,
-        attached: session.attachedCount,
-        age_sec: session.ageSec,
-        stale: session.stale,
-      })),
-    });
-    info(`multiplexer: ${teamSessionReport.mux}`);
 
-    for (const session of teamSessionReport.sessions) {
-      const attachedLabel = session.attachedCount == null ? "?" : `${session.attachedCount}`;
-      const ageLabel = formatElapsedAge(session.ageSec);
+    // 12. Team Sessions
+    section("Team Sessions");
+    const teamSessionReport = inspectTeamSessions();
+    if (!teamSessionReport.mux) {
+      addDoctorCheck(report, {
+        name: "team-sessions",
+        status: "skipped",
+        detail: "tmux/psmux unavailable",
+      });
+      info("tmux/psmux 미감지 — 팀 세션 검사 건너뜀");
+    } else if (teamSessionReport.sessions.length === 0) {
+      addDoctorCheck(report, {
+        name: "team-sessions",
+        status: "ok",
+        multiplexer: teamSessionReport.mux,
+        sessions: 0,
+      });
+      ok(`활성 팀 세션 없음 ${DIM}(${teamSessionReport.mux})${RESET}`);
+    } else {
+      addDoctorCheck(report, {
+        name: "team-sessions",
+        status: teamSessionReport.sessions.some((session) => session.stale)
+          ? "issues"
+          : "ok",
+        multiplexer: teamSessionReport.mux,
+        sessions: teamSessionReport.sessions.map((session) => ({
+          name: session.sessionName,
+          attached: session.attachedCount,
+          age_sec: session.ageSec,
+          stale: session.stale,
+        })),
+      });
+      info(`multiplexer: ${teamSessionReport.mux}`);
 
-      if (session.stale) {
-        warn(`${session.sessionName}: stale 추정 (attach=${attachedLabel}, 경과=${ageLabel})`);
-      } else {
-        ok(`${session.sessionName}: 정상 (attach=${attachedLabel}, 경과=${ageLabel})`);
-      }
+      for (const session of teamSessionReport.sessions) {
+        const attachedLabel =
+          session.attachedCount == null ? "?" : `${session.attachedCount}`;
+        const ageLabel = formatElapsedAge(session.ageSec);
 
-      if (session.createdAt == null) {
-        info(`${session.sessionName}: session_created 파싱 실패${session.createdRaw ? ` (${session.createdRaw})` : ""}`);
+        if (session.stale) {
+          warn(
+            `${session.sessionName}: stale 추정 (attach=${attachedLabel}, 경과=${ageLabel})`,
+          );
+        } else {
+          ok(
+            `${session.sessionName}: 정상 (attach=${attachedLabel}, 경과=${ageLabel})`,
+          );
+        }
+
+        if (session.createdAt == null) {
+          info(
+            `${session.sessionName}: session_created 파싱 실패${session.createdRaw ? ` (${session.createdRaw})` : ""}`,
+          );
+        }
       }
-    }
 
-    const staleSessions = teamSessionReport.sessions.filter((session) => session.stale);
-    if (staleSessions.length > 0) {
-      if (fix) {
-        const cleanupResult = await cleanupStaleTeamSessions(staleSessions);
-        issues += cleanupResult.failed;
-      } else {
-        info("정리: tfx doctor --fix");
-        issues += staleSessions.length;
+      const staleSessions = teamSessionReport.sessions.filter(
+        (session) => session.stale,
+      );
+      if (staleSessions.length > 0) {
+        if (fix) {
+          const cleanupResult = await cleanupStaleTeamSessions(staleSessions);
+          issues += cleanupResult.failed;
+        } else {
+          info("정리: tfx doctor --fix");
+          issues += staleSessions.length;
+        }
       }
     }
-  }
-
-  // 13. OMC stale team 상태
-  section("OMC Stale Teams");
-  const omcTeamReport = inspectStaleOmcTeams({
-    startDir: process.cwd(),
-    maxAgeMs: STALE_TEAM_MAX_AGE_SEC * 1000,
-    liveSessionNames: teamSessionReport.sessions.map((session) => session.sessionName),
-  });
-  if (!omcTeamReport.stateRoot && !omcTeamReport.teamsRoot) {
-    addDoctorCheck(report, { name: "omc-stale-teams", status: "skipped" });
-    info(".omc/state 및 ~/.claude/teams 없음 — 검사 건너뜀");
-  } else if (omcTeamReport.entries.length === 0) {
-    addDoctorCheck(report, { name: "omc-stale-teams", status: "ok", entries: 0 });
-    const roots = [omcTeamReport.stateRoot, omcTeamReport.teamsRoot].filter(Boolean).join(", ");
-    ok(`stale team 없음 ${DIM}(${roots})${RESET}`);
-  } else {
-    addDoctorCheck(report, { name: "omc-stale-teams", status: "issues", entries: omcTeamReport.entries.length, fix: "tfx doctor --fix" });
-    warn(`${omcTeamReport.entries.length}개 stale team 발견`);
 
-    for (const entry of omcTeamReport.entries) {
-      const ageLabel = formatElapsedAge(entry.ageSec);
-      const scopeLabel = entry.scope === "root"
-        ? "root-state"
-        : entry.scope === "claude_team"
-          ? `claude-team:${entry.teamName || entry.sessionId}`
-          : entry.sessionId;
-      warn(`${scopeLabel}: stale team (경과=${ageLabel}, 프로세스 없음)`);
-      if (entry.teamName) info(`팀: ${entry.teamName}`);
-      info(`파일: ${entry.stateFile || entry.cleanupPath}`);
-    }
+    // 13. OMC stale team 상태
+    section("OMC Stale Teams");
+    const omcTeamReport = inspectStaleOmcTeams({
+      startDir: process.cwd(),
+      maxAgeMs: STALE_TEAM_MAX_AGE_SEC * 1000,
+      liveSessionNames: teamSessionReport.sessions.map(
+        (session) => session.sessionName,
+      ),
+    });
+    if (!omcTeamReport.stateRoot && !omcTeamReport.teamsRoot) {
+      addDoctorCheck(report, { name: "omc-stale-teams", status: "skipped" });
+      info(".omc/state 및 ~/.claude/teams 없음 — 검사 건너뜀");
+    } else if (omcTeamReport.entries.length === 0) {
+      addDoctorCheck(report, {
+        name: "omc-stale-teams",
+        status: "ok",
+        entries: 0,
+      });
+      const roots = [omcTeamReport.stateRoot, omcTeamReport.teamsRoot]
+        .filter(Boolean)
+        .join(", ");
+      ok(`stale team 없음 ${DIM}(${roots})${RESET}`);
+    } else {
+      addDoctorCheck(report, {
+        name: "omc-stale-teams",
+        status: "issues",
+        entries: omcTeamReport.entries.length,
+        fix: "tfx doctor --fix",
+      });
+      warn(`${omcTeamReport.entries.length}개 stale team 발견`);
 
-    if (fix) {
-      const cleanupResult = await cleanupStaleOmcTeams(omcTeamReport.entries);
-      for (const result of cleanupResult.results) {
-        if (result.ok) {
-          const label = result.entry.scope === "root"
+      for (const entry of omcTeamReport.entries) {
+        const ageLabel = formatElapsedAge(entry.ageSec);
+        const scopeLabel =
+          entry.scope === "root"
             ? "root-state"
-            : result.entry.scope === "claude_team"
-              ? (result.entry.teamName || result.entry.sessionId)
-              : result.entry.sessionId;
-          ok(`stale team 정리: ${label}`);
-        } else {
-          const label = result.entry.scope === "root"
-            ? "root-state"
-            : result.entry.scope === "claude_team"
-              ? (result.entry.teamName || result.entry.sessionId)
-              : result.entry.sessionId;
-          fail(`stale team 정리 실패: ${label} — ${result.error.message}`);
-        }
+            : entry.scope === "claude_team"
+              ? `claude-team:${entry.teamName || entry.sessionId}`
+              : entry.sessionId;
+        warn(`${scopeLabel}: stale team (경과=${ageLabel}, 프로세스 없음)`);
+        if (entry.teamName) info(`팀: ${entry.teamName}`);
+        info(`파일: ${entry.stateFile || entry.cleanupPath}`);
       }
-      issues += cleanupResult.failed;
-    } else {
-      info("정리: tfx doctor --fix");
-      issues += omcTeamReport.entries.length;
-    }
-  }
 
-  // 12.5. 고아 node.exe 프로세스 정리 (Windows)
-  section("Orphan Processes");
-  if (process.platform === "win32") {
-    try {
-      const { cleanupOrphanNodeProcesses } = await import("../hub/lib/process-utils.mjs");
       if (fix) {
-        const { killed, remaining } = cleanupOrphanNodeProcesses();
-        if (killed > 0) {
-          warn(`고아 node.exe ${killed}개 정리 완료 (남은 프로세스: ${remaining})`);
-        } else {
-          ok(`고아 node.exe 없음 (활성: ${remaining})`);
+        const cleanupResult = await cleanupStaleOmcTeams(omcTeamReport.entries);
+        for (const result of cleanupResult.results) {
+          if (result.ok) {
+            const label =
+              result.entry.scope === "root"
+                ? "root-state"
+                : result.entry.scope === "claude_team"
+                  ? result.entry.teamName || result.entry.sessionId
+                  : result.entry.sessionId;
+            ok(`stale team 정리: ${label}`);
+          } else {
+            const label =
+              result.entry.scope === "root"
+                ? "root-state"
+                : result.entry.scope === "claude_team"
+                  ? result.entry.teamName || result.entry.sessionId
+                  : result.entry.sessionId;
+            fail(`stale team 정리 실패: ${label} — ${result.error.message}`);
+          }
         }
+        issues += cleanupResult.failed;
       } else {
-        // --fix 없이는 개수만 보고
-        const { execSync: execSyncDoctor } = await import("node:child_process");
-        const countStr = execSyncDoctor(
-          `powershell -NoProfile -WindowStyle Hidden -Command "(Get-Process node -ErrorAction SilentlyContinue).Count"`,
-          { encoding: "utf8", timeout: 5000 },
-        ).trim();
-        const count = Number.parseInt(countStr, 10) || 0;
-        if (count > 20) {
-          warn(`node.exe ${count}개 실행 중 (고아 포함 가능). 정리: tfx doctor --fix`);
-          issues++;
+        info("정리: tfx doctor --fix");
+        issues += omcTeamReport.entries.length;
+      }
+    }
+
+    // 12.5. 고아 node.exe 프로세스 정리 (Windows)
+    section("Orphan Processes");
+    if (process.platform === "win32") {
+      try {
+        const { cleanupOrphanNodeProcesses } = await import(
+          "../hub/lib/process-utils.mjs"
+        );
+        if (fix) {
+          const { killed, remaining } = cleanupOrphanNodeProcesses();
+          if (killed > 0) {
+            warn(
+              `고아 node.exe ${killed}개 정리 완료 (남은 프로세스: ${remaining})`,
+            );
+          } else {
+            ok(`고아 node.exe 없음 (활성: ${remaining})`);
+          }
         } else {
-          ok(`node.exe ${count}개 (정상 범위)`);
+          // --fix 없이는 개수만 보고
+          const { execSync: execSyncDoctor } = await import(
+            "node:child_process"
+          );
+          const countStr = execSyncDoctor(
+            `powershell -NoProfile -WindowStyle Hidden -Command "(Get-Process node -ErrorAction SilentlyContinue).Count"`,
+            { encoding: "utf8", timeout: 5000 },
+          ).trim();
+          const count = Number.parseInt(countStr, 10) || 0;
+          if (count > 20) {
+            warn(
+              `node.exe ${count}개 실행 중 (고아 포함 가능). 정리: tfx doctor --fix`,
+            );
+            issues++;
+          } else {
+            ok(`node.exe ${count}개 (정상 범위)`);
+          }
         }
+      } catch (e) {
+        info(`고아 프로세스 검사 실패: ${e.message}`);
       }
-    } catch (e) {
-      info(`고아 프로세스 검사 실패: ${e.message}`);
+    } else {
+      ok("Windows 전용 검사 — 건너뜀");
     }
-  } else {
-    ok("Windows 전용 검사 — 건너뜀");
-  }
 
-  // 14. Stale Teams (Claude teams/ + tasks/ 자동 감지)
-  section("Stale Teams");
-  const teamsDir = join(CLAUDE_DIR, "teams");
-  const _tasksDir = join(CLAUDE_DIR, "tasks");
-  if (existsSync(teamsDir)) {
-    try {
-      const teamDirs = readdirSync(teamsDir).filter(d => {
-        try { return statSync(join(teamsDir, d)).isDirectory(); } catch { return false; }
-      });
-      if (teamDirs.length === 0) {
-        addDoctorCheck(report, { name: "stale-teams", status: "ok", entries: 0 });
-        ok("잔존 팀 없음");
-      } else {
-        const nowMs = Date.now();
-        const staleMaxAgeMs = STALE_TEAM_MAX_AGE_SEC * 1000;
-        const staleTeams = [];
-        const activeTeams = [];
-
-        for (const d of teamDirs) {
-          const teamPath = join(teamsDir, d);
-          const configPath = join(teamPath, "config.json");
-          let teamConfig = null;
-          let configMtimeMs = null;
-          let missingConfig = false;
-
-          // config.json 읽기 — createdAt 또는 mtime으로 나이 판정
+    // 14. Stale Teams (Claude teams/ + tasks/ 자동 감지)
+    section("Stale Teams");
+    const teamsDir = join(CLAUDE_DIR, "teams");
+    const _tasksDir = join(CLAUDE_DIR, "tasks");
+    if (existsSync(teamsDir)) {
+      try {
+        const teamDirs = readdirSync(teamsDir).filter((d) => {
           try {
-            const configStat = statSync(configPath);
-            configMtimeMs = configStat.mtimeMs;
-            teamConfig = JSON.parse(readFileSync(configPath, "utf8"));
+            return statSync(join(teamsDir, d)).isDirectory();
           } catch {
-            missingConfig = true;
-            // config.json 없으면 표시용 경과 시간만 디렉토리 기준으로 계산
-            try { configMtimeMs = statSync(teamPath).mtimeMs; } catch {}
+            return false;
           }
-
-          const createdAtMs = teamConfig?.createdAt ?? configMtimeMs;
-          const ageMs = createdAtMs != null ? Math.max(0, nowMs - createdAtMs) : null;
-          const ageSec = ageMs != null ? Math.floor(ageMs / 1000) : null;
-          const aged = ageMs != null && ageMs >= staleMaxAgeMs;
-
-          // 활성 멤버 확인 — leadSessionId 또는 멤버 agentId로 프로세스 검색
-          let hasActiveMember = false;
-          if (teamConfig?.members?.length > 0) {
-            const searchTokens = [];
-            if (teamConfig.leadSessionId) searchTokens.push(teamConfig.leadSessionId.toLowerCase());
-            if (teamConfig.name) searchTokens.push(teamConfig.name.toLowerCase());
-            for (const member of teamConfig.members) {
-              if (member.agentId) searchTokens.push(member.agentId.split("@")[0].toLowerCase());
+        });
+        if (teamDirs.length === 0) {
+          addDoctorCheck(report, {
+            name: "stale-teams",
+            status: "ok",
+            entries: 0,
+          });
+          ok("잔존 팀 없음");
+        } else {
+          const nowMs = Date.now();
+          const staleMaxAgeMs = STALE_TEAM_MAX_AGE_SEC * 1000;
+          const staleTeams = [];
+          const activeTeams = [];
+
+          for (const d of teamDirs) {
+            const teamPath = join(teamsDir, d);
+            const configPath = join(teamPath, "config.json");
+            let teamConfig = null;
+            let configMtimeMs = null;
+            let missingConfig = false;
+
+            // config.json 읽기 — createdAt 또는 mtime으로 나이 판정
+            try {
+              const configStat = statSync(configPath);
+              configMtimeMs = configStat.mtimeMs;
+              teamConfig = JSON.parse(readFileSync(configPath, "utf8"));
+            } catch {
+              missingConfig = true;
+              // config.json 없으면 표시용 경과 시간만 디렉토리 기준으로 계산
+              try {
+                configMtimeMs = statSync(teamPath).mtimeMs;
+              } catch {}
             }
 
-            // tmux 세션 이름과 매칭
-            const liveSessionNames = teamSessionReport.sessions.map(s => s.sessionName.toLowerCase());
-            hasActiveMember = searchTokens.some(token =>
-              liveSessionNames.some(name => name.includes(token))
-            );
+            const createdAtMs = teamConfig?.createdAt ?? configMtimeMs;
+            const ageMs =
+              createdAtMs != null ? Math.max(0, nowMs - createdAtMs) : null;
+            const ageSec = ageMs != null ? Math.floor(ageMs / 1000) : null;
+            const aged = ageMs != null && ageMs >= staleMaxAgeMs;
+
+            // 활성 멤버 확인 — leadSessionId 또는 멤버 agentId로 프로세스 검색
+            let hasActiveMember = false;
+            if (teamConfig?.members?.length > 0) {
+              const searchTokens = [];
+              if (teamConfig.leadSessionId)
+                searchTokens.push(teamConfig.leadSessionId.toLowerCase());
+              if (teamConfig.name)
+                searchTokens.push(teamConfig.name.toLowerCase());
+              for (const member of teamConfig.members) {
+                if (member.agentId)
+                  searchTokens.push(member.agentId.split("@")[0].toLowerCase());
+              }
 
-            // 프로세스 명령줄에서 세션 ID 매칭 (tmux 없는 in-process 팀 지원)
-            if (!hasActiveMember && teamConfig.leadSessionId) {
-              try {
-                const _sessionToken = teamConfig.leadSessionId.toLowerCase();
-                const safeToken = teamConfig.leadSessionId.slice(0, 8).replace(/[^a-zA-Z0-9-]/g, '');
-                // Claude Code 프로세스에서 세션 ID 검색
-                if (process.platform === "win32") {
-                  const psOut = execSync(
-                    `powershell -NoProfile -WindowStyle Hidden -Command "$ErrorActionPreference='SilentlyContinue'; Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -match '${safeToken}' } | Select-Object ProcessId | ConvertTo-Json -Compress"`,
-                    { encoding: "utf8", timeout: 8000, stdio: ["ignore", "pipe", "ignore"], windowsHide: true },
-                  ).trim();
-                  if (psOut && psOut !== "null") {
-                    const parsed = JSON.parse(psOut);
-                    const procs = Array.isArray(parsed) ? parsed : [parsed];
-                    hasActiveMember = procs.some(p => p.ProcessId > 0);
+              // tmux 세션 이름과 매칭
+              const liveSessionNames = teamSessionReport.sessions.map((s) =>
+                s.sessionName.toLowerCase(),
+              );
+              hasActiveMember = searchTokens.some((token) =>
+                liveSessionNames.some((name) => name.includes(token)),
+              );
+
+              // 프로세스 명령줄에서 세션 ID 매칭 (tmux 없는 in-process 팀 지원)
+              if (!hasActiveMember && teamConfig.leadSessionId) {
+                try {
+                  const _sessionToken = teamConfig.leadSessionId.toLowerCase();
+                  const safeToken = teamConfig.leadSessionId
+                    .slice(0, 8)
+                    .replace(/[^a-zA-Z0-9-]/g, "");
+                  // Claude Code 프로세스에서 세션 ID 검색
+                  if (process.platform === "win32") {
+                    const psOut = execSync(
+                      `powershell -NoProfile -WindowStyle Hidden -Command "$ErrorActionPreference='SilentlyContinue'; Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -match '${safeToken}' } | Select-Object ProcessId | ConvertTo-Json -Compress"`,
+                      {
+                        encoding: "utf8",
+                        timeout: 8000,
+                        stdio: ["ignore", "pipe", "ignore"],
+                        windowsHide: true,
+                      },
+                    ).trim();
+                    if (psOut && psOut !== "null") {
+                      const parsed = JSON.parse(psOut);
+                      const procs = Array.isArray(parsed) ? parsed : [parsed];
+                      hasActiveMember = procs.some((p) => p.ProcessId > 0);
+                    }
+                  } else {
+                    const psOut = execSync(
+                      `ps -ax -o pid=,command= | grep -i '${safeToken}' | grep -v grep`,
+                      {
+                        encoding: "utf8",
+                        timeout: 5000,
+                        stdio: ["ignore", "pipe", "ignore"],
+                        windowsHide: true,
+                      },
+                    ).trim();
+                    hasActiveMember = psOut.length > 0;
                   }
-                } else {
-                  const psOut = execSync(
-                    `ps -ax -o pid=,command= | grep -i '${safeToken}' | grep -v grep`,
-                    { encoding: "utf8", timeout: 5000, stdio: ["ignore", "pipe", "ignore"], windowsHide: true },
-                  ).trim();
-                  hasActiveMember = psOut.length > 0;
+                } catch {
+                  // 프로세스 검색 실패 — stale로 간주하지 않음 (보수적)
                 }
-              } catch {
-                // 프로세스 검색 실패 — stale로 간주하지 않음 (보수적)
               }
             }
-          }
-
-          const stale = missingConfig || (aged && !hasActiveMember);
-          const teamEntry = {
-            name: d,
-            teamName: teamConfig?.name || d,
-            description: teamConfig?.description || null,
-            memberCount: teamConfig?.members?.length || 0,
-            ageSec,
-            stale,
-            hasActiveMember,
-            missingConfig,
-          };
 
-          if (stale) {
-            staleTeams.push(teamEntry);
-          } else {
-            activeTeams.push(teamEntry);
+            const stale = missingConfig || (aged && !hasActiveMember);
+            const teamEntry = {
+              name: d,
+              teamName: teamConfig?.name || d,
+              description: teamConfig?.description || null,
+              memberCount: teamConfig?.members?.length || 0,
+              ageSec,
+              stale,
+              hasActiveMember,
+              missingConfig,
+            };
+
+            if (stale) {
+              staleTeams.push(teamEntry);
+            } else {
+              activeTeams.push(teamEntry);
+            }
           }
-        }
 
-        // 활성 팀 표시
-        for (const t of activeTeams) {
-          const ageLabel = formatElapsedAge(t.ageSec);
-          const memberLabel = `${t.memberCount}명`;
-          ok(`${t.name}: 활성 (경과=${ageLabel}, 멤버=${memberLabel})`);
-        }
-
-        // stale 팀 표시 및 정리
-        if (staleTeams.length === 0 && activeTeams.length > 0) {
-          addDoctorCheck(report, { name: "stale-teams", status: "ok", active: activeTeams.length, stale: 0 });
-          ok("stale 팀 없음");
-        } else if (staleTeams.length > 0) {
-          addDoctorCheck(report, { name: "stale-teams", status: "issues", active: activeTeams.length, stale: staleTeams.length, fix: "tfx doctor --fix" });
-          warn(`${staleTeams.length}개 stale 팀 발견`);
-          for (const t of staleTeams) {
+          // 활성 팀 표시
+          for (const t of activeTeams) {
             const ageLabel = formatElapsedAge(t.ageSec);
-            const reasonLabel = t.missingConfig ? "config.json 없음" : "활성 프로세스 없음";
-            warn(`${t.name}: stale (경과=${ageLabel}, 멤버=${t.memberCount}명, ${reasonLabel})`);
-            if (t.description) info(`설명: ${t.description}`);
+            const memberLabel = `${t.memberCount}명`;
+            ok(`${t.name}: 활성 (경과=${ageLabel}, 멤버=${memberLabel})`);
           }
 
-          if (fix) {
-            let cleaned = 0;
+          // stale 팀 표시 및 정리
+          if (staleTeams.length === 0 && activeTeams.length > 0) {
+            addDoctorCheck(report, {
+              name: "stale-teams",
+              status: "ok",
+              active: activeTeams.length,
+              stale: 0,
+            });
+            ok("stale 팀 없음");
+          } else if (staleTeams.length > 0) {
+            addDoctorCheck(report, {
+              name: "stale-teams",
+              status: "issues",
+              active: activeTeams.length,
+              stale: staleTeams.length,
+              fix: "tfx doctor --fix",
+            });
+            warn(`${staleTeams.length}개 stale 팀 발견`);
             for (const t of staleTeams) {
-              try {
-                await forceCleanupTeam(t.name);
-                cleaned++;
-                ok(`stale 팀 정리: ${t.name}`);
-              } catch (e) {
-                fail(`팀 정리 실패: ${t.name} — ${e.message}`);
+              const ageLabel = formatElapsedAge(t.ageSec);
+              const reasonLabel = t.missingConfig
+                ? "config.json 없음"
+                : "활성 프로세스 없음";
+              warn(
+                `${t.name}: stale (경과=${ageLabel}, 멤버=${t.memberCount}명, ${reasonLabel})`,
+              );
+              if (t.description) info(`설명: ${t.description}`);
+            }
+
+            if (fix) {
+              let cleaned = 0;
+              for (const t of staleTeams) {
+                try {
+                  await forceCleanupTeam(t.name);
+                  cleaned++;
+                  ok(`stale 팀 정리: ${t.name}`);
+                } catch (e) {
+                  fail(`팀 정리 실패: ${t.name} — ${e.message}`);
+                }
               }
+              info(`${cleaned}/${staleTeams.length}개 stale 팀 정리 완료`);
+            } else {
+              info("정리: tfx doctor --fix");
+              issues += staleTeams.length;
             }
-            info(`${cleaned}/${staleTeams.length}개 stale 팀 정리 완료`);
-          } else {
-            info("정리: tfx doctor --fix");
-            issues += staleTeams.length;
           }
         }
+      } catch (e) {
+        addDoctorCheck(report, {
+          name: "stale-teams",
+          status: "invalid",
+          fix: "teams 디렉토리 구조를 확인하세요.",
+        });
+        warn(`teams 디렉토리 읽기 실패: ${e.message}`);
       }
-    } catch (e) {
-      addDoctorCheck(report, { name: "stale-teams", status: "invalid", fix: "teams 디렉토리 구조를 확인하세요." });
-      warn(`teams 디렉토리 읽기 실패: ${e.message}`);
+    } else {
+      addDoctorCheck(report, { name: "stale-teams", status: "ok", entries: 0 });
+      ok("잔존 팀 없음");
     }
-  } else {
-    addDoctorCheck(report, { name: "stale-teams", status: "ok", entries: 0 });
-    ok("잔존 팀 없음");
-  }
 
-  // ── Docs 동기화 상태 ──
-  section("Docs Sync");
-  {
-    const docsDirs = ["docs/design", "docs/research"];
-    const missingDocs = [];
-    for (const dir of docsDirs) {
-      const src = join(PKG_ROOT, dir);
-      const dest = join(CLAUDE_DIR, dir);
-      if (existsSync(src)) {
-        const srcFiles = readdirSync(src).filter(f => f.endsWith(".md"));
-        if (!existsSync(dest)) {
-          missingDocs.push({ dir, missing: srcFiles.length, detail: "디렉토리 없음" });
-        } else {
-          const destFiles = readdirSync(dest).filter(f => f.endsWith(".md"));
-          const missing = srcFiles.filter(f => !destFiles.includes(f));
-          if (missing.length > 0) missingDocs.push({ dir, missing: missing.length, detail: missing.join(", ") });
+    // ── Docs 동기화 상태 ──
+    section("Docs Sync");
+    {
+      const docsDirs = ["docs/design", "docs/research"];
+      const missingDocs = [];
+      for (const dir of docsDirs) {
+        const src = join(PKG_ROOT, dir);
+        const dest = join(CLAUDE_DIR, dir);
+        if (existsSync(src)) {
+          const srcFiles = readdirSync(src).filter((f) => f.endsWith(".md"));
+          if (!existsSync(dest)) {
+            missingDocs.push({
+              dir,
+              missing: srcFiles.length,
+              detail: "디렉토리 없음",
+            });
+          } else {
+            const destFiles = readdirSync(dest).filter((f) =>
+              f.endsWith(".md"),
+            );
+            const missing = srcFiles.filter((f) => !destFiles.includes(f));
+            if (missing.length > 0)
+              missingDocs.push({
+                dir,
+                missing: missing.length,
+                detail: missing.join(", "),
+              });
+          }
         }
       }
-    }
-    if (missingDocs.length === 0) {
-      addDoctorCheck(report, { name: "docs-sync", status: "ok" });
-      ok("레퍼런스 문서 동기화 정상");
-    } else {
-      addDoctorCheck(report, { name: "docs-sync", status: "issues", missingDocs, fix: "tfx setup" });
-      warn(`${missingDocs.reduce((s, d) => s + d.missing, 0)}개 레퍼런스 미동기화`);
-      for (const d of missingDocs) info(`${d.dir}: ${d.detail}`);
-      if (fix) {
-        for (const dir of docsDirs) {
-          const src = join(PKG_ROOT, dir);
-          const dest = join(CLAUDE_DIR, dir);
-          if (existsSync(src)) {
-            mkdirSync(dest, { recursive: true });
-            for (const f of readdirSync(src).filter(f => f.endsWith(".md"))) {
-              copyFileSync(join(src, f), join(dest, f));
+      if (missingDocs.length === 0) {
+        addDoctorCheck(report, { name: "docs-sync", status: "ok" });
+        ok("레퍼런스 문서 동기화 정상");
+      } else {
+        addDoctorCheck(report, {
+          name: "docs-sync",
+          status: "issues",
+          missingDocs,
+          fix: "tfx setup",
+        });
+        warn(
+          `${missingDocs.reduce((s, d) => s + d.missing, 0)}개 레퍼런스 미동기화`,
+        );
+        for (const d of missingDocs) info(`${d.dir}: ${d.detail}`);
+        if (fix) {
+          for (const dir of docsDirs) {
+            const src = join(PKG_ROOT, dir);
+            const dest = join(CLAUDE_DIR, dir);
+            if (existsSync(src)) {
+              mkdirSync(dest, { recursive: true });
+              for (const f of readdirSync(src).filter((f) =>
+                f.endsWith(".md"),
+              )) {
+                copyFileSync(join(src, f), join(dest, f));
+              }
             }
           }
+          ok("레퍼런스 동기화 완료");
+        } else {
+          issues += missingDocs.length;
         }
-        ok("레퍼런스 동기화 완료");
-      } else {
-        issues += missingDocs.length;
       }
     }
-  }
 
-  // ── MCP 중앙 레지스트리 ──
-  section("MCP Registry");
-  {
-    let registryState = inspectRegistry();
-    if (!registryState.exists) {
-      saveRegistry(createDefaultRegistry());
-      registryState = inspectRegistry();
-      addDoctorCheck(report, {
-        name: "mcp-registry",
-        status: "fixed",
-        path: registryState.path,
-        action: "기본값으로 자동 생성됨",
-      });
-      ok("mcp-registry.json 없음 → 기본값으로 자동 생성됨");
-    } else if (!registryState.valid) {
-      saveRegistry(createDefaultRegistry());
-      registryState = inspectRegistry();
-      addDoctorCheck(report, {
-        name: "mcp-registry",
-        status: "fixed",
-        path: registryState.path,
-        action: "손상 감지 → 기본값으로 재생성됨",
-      });
-      warn("mcp-registry.json 손상 → 기본값으로 재생성됨");
-    } else {
-      const statusInfo = inspectRegistryStatus(registryState.registry);
-      const invalidConfigs = statusInfo.configs.filter((config) => config.parseError);
-      const mismatchRows = statusInfo.rows.filter((row) => row.type === "registry" && row.status === "mismatch");
-      const missingRows = statusInfo.rows.filter((row) => row.type === "registry" && row.status === "missing");
-      const missingFileRows = statusInfo.rows.filter((row) => row.type === "registry" && row.status === "missing-file");
-      const stdioRows = statusInfo.rows.filter((row) => row.type === "stdio");
-      const hasHardIssues = invalidConfigs.length > 0 || mismatchRows.length > 0;
-      const status = hasHardIssues
-        ? "issues"
-        : stdioRows.length > 0
-          ? "warning"
-          : "ok";
-
-      addDoctorCheck(report, {
-        name: "mcp-registry",
-        status,
-        path: registryState.path,
-        server_count: Object.keys(registryState.registry.servers || {}).length,
-        rows: statusInfo.rows,
-        invalid_configs: invalidConfigs.map((config) => ({
-          file: config.filePath,
-          error: config.parseError?.message || "parse error",
-        })),
-        ...(stdioRows.length > 0 ? { fix: "tfx doctor --fix 또는 tfx mcp sync" } : {}),
-      });
+    // ── MCP 중앙 레지스트리 ──
+    section("MCP Registry");
+    {
+      let registryState = inspectRegistry();
+      if (!registryState.exists) {
+        saveRegistry(createDefaultRegistry());
+        registryState = inspectRegistry();
+        addDoctorCheck(report, {
+          name: "mcp-registry",
+          status: "fixed",
+          path: registryState.path,
+          action: "기본값으로 자동 생성됨",
+        });
+        ok("mcp-registry.json 없음 → 기본값으로 자동 생성됨");
+      } else if (!registryState.valid) {
+        saveRegistry(createDefaultRegistry());
+        registryState = inspectRegistry();
+        addDoctorCheck(report, {
+          name: "mcp-registry",
+          status: "fixed",
+          path: registryState.path,
+          action: "손상 감지 → 기본값으로 재생성됨",
+        });
+        warn("mcp-registry.json 손상 → 기본값으로 재생성됨");
+      } else {
+        const statusInfo = inspectRegistryStatus(registryState.registry);
+        const invalidConfigs = statusInfo.configs.filter(
+          (config) => config.parseError,
+        );
+        const mismatchRows = statusInfo.rows.filter(
+          (row) => row.type === "registry" && row.status === "mismatch",
+        );
+        const missingRows = statusInfo.rows.filter(
+          (row) => row.type === "registry" && row.status === "missing",
+        );
+        const missingFileRows = statusInfo.rows.filter(
+          (row) => row.type === "registry" && row.status === "missing-file",
+        );
+        const stdioRows = statusInfo.rows.filter((row) => row.type === "stdio");
+        const hasHardIssues =
+          invalidConfigs.length > 0 || mismatchRows.length > 0;
+        const status = hasHardIssues
+          ? "issues"
+          : stdioRows.length > 0
+            ? "warning"
+            : "ok";
 
-      ok(`registry 정상 (${Object.keys(registryState.registry.servers || {}).length}개 server)`);
+        addDoctorCheck(report, {
+          name: "mcp-registry",
+          status,
+          path: registryState.path,
+          server_count: Object.keys(registryState.registry.servers || {})
+            .length,
+          rows: statusInfo.rows,
+          invalid_configs: invalidConfigs.map((config) => ({
+            file: config.filePath,
+            error: config.parseError?.message || "parse error",
+          })),
+          ...(stdioRows.length > 0
+            ? { fix: "tfx doctor --fix 또는 tfx mcp sync" }
+            : {}),
+        });
 
-      if (statusInfo.rows.length > 0) {
-        renderTable(
-          ["server", "target", "status", "config", "detail"],
-          buildMcpStatusRows(statusInfo),
+        ok(
+          `registry 정상 (${Object.keys(registryState.registry.servers || {}).length}개 server)`,
         );
-      } else {
-        info("등록된 MCP server 없음");
-      }
 
-      for (const config of invalidConfigs) {
-        fail(`${config.label}: 설정 파싱 실패`);
-        info(`${formatPathForDisplay(config.filePath)} — ${config.parseError.message}`);
-      }
-
-      for (const row of mismatchRows) {
-        warn(`${row.label}: ${row.name} URL 불일치`);
-        info(`expected ${row.expectedUrl}`);
-        if (row.actualUrl) info(`actual   ${row.actualUrl}`);
-      }
+        if (statusInfo.rows.length > 0) {
+          renderTable(
+            ["server", "target", "status", "config", "detail"],
+            buildMcpStatusRows(statusInfo),
+          );
+        } else {
+          info("등록된 MCP server 없음");
+        }
 
-      for (const row of missingFileRows) {
-        info(`${row.label}: ${row.name} 미배치 (${formatPathForDisplay(row.filePath)})`);
-      }
+        for (const config of invalidConfigs) {
+          fail(`${config.label}: 설정 파싱 실패`);
+          info(
+            `${formatPathForDisplay(config.filePath)} — ${config.parseError.message}`,
+          );
+        }
 
-      for (const row of missingRows) {
-        info(`${row.label}: ${row.name} 누락`);
-      }
+        for (const row of mismatchRows) {
+          warn(`${row.label}: ${row.name} URL 불일치`);
+          info(`expected ${row.expectedUrl}`);
+          if (row.actualUrl) info(`actual   ${row.actualUrl}`);
+        }
 
-      if (stdioRows.length === 0) {
-        ok("미등록 stdio MCP 없음");
-      } else {
-        warn(`${stdioRows.length}개 미등록 stdio MCP 감지`);
-        for (const row of stdioRows) {
-          info(`${row.label}: ${row.name}${row.command ? ` (${row.command})` : ""}`);
+        for (const row of missingFileRows) {
+          info(
+            `${row.label}: ${row.name} 미배치 (${formatPathForDisplay(row.filePath)})`,
+          );
         }
-      }
 
-      issues += invalidConfigs.length;
-      issues += mismatchRows.length;
-      issues += stdioRows.length;
-    }
-  }
+        for (const row of missingRows) {
+          info(`${row.label}: ${row.name} 누락`);
+        }
 
-  // ── Route Script 정합성 ──
-  section("Route Script Sync");
-  {
-    const srcRoute = join(PKG_ROOT, "scripts", "tfx-route.sh");
-    const destRoute = join(CLAUDE_DIR, "scripts", "tfx-route.sh");
-    if (existsSync(srcRoute) && existsSync(destRoute)) {
-      const srcHash = readFileSync(srcRoute, "utf8").length;
-      const destHash = readFileSync(destRoute, "utf8").length;
-      const srcContent = readFileSync(srcRoute, "utf8");
-      const destContent = readFileSync(destRoute, "utf8");
-      if (srcContent === destContent) {
-        addDoctorCheck(report, { name: "route-sync", status: "ok" });
-        ok("프로젝트 소스와 설치본 일치");
-      } else {
-        addDoctorCheck(report, { name: "route-sync", status: "issues", fix: "tfx setup" });
-        warn("tfx-route.sh 프로젝트 소스와 설치본 불일치");
-        info(`소스: ${srcRoute} (${srcHash}B) / 설치: ${destRoute} (${destHash}B)`);
-        if (fix) {
-          copyFileSync(srcRoute, destRoute);
-          ok("tfx-route.sh 동기화 완료");
+        if (stdioRows.length === 0) {
+          ok("미등록 stdio MCP 없음");
         } else {
-          issues++;
+          warn(`${stdioRows.length}개 미등록 stdio MCP 감지`);
+          for (const row of stdioRows) {
+            info(
+              `${row.label}: ${row.name}${row.command ? ` (${row.command})` : ""}`,
+            );
+          }
         }
+
+        issues += invalidConfigs.length;
+        issues += mismatchRows.length;
+        issues += stdioRows.length;
       }
-    } else if (existsSync(srcRoute) && !existsSync(destRoute)) {
-      addDoctorCheck(report, { name: "route-sync", status: "missing", fix: "tfx setup" });
-      fail("설치본 없음");
-      issues++;
-    } else {
-      addDoctorCheck(report, { name: "route-sync", status: "ok" });
-      ok("소스 없음 (npm 패키지 모드)");
     }
-  }
-
-  // ── Hook Coverage (hook-registry vs settings.json) ──
-  section("Hook Coverage");
-  {
-    const registryPath = join(PKG_ROOT, "hooks", "hook-registry.json");
-    const settingsPath = join(CLAUDE_DIR, "settings.json");
-    const managedHooks = getManagedRegistryHooks(registryPath);
 
-    if (managedHooks.length === 0) {
-      addDoctorCheck(report, {
-        name: "hook-coverage",
-        status: "invalid",
-        total: 0,
-        registered: 0,
-        missing: [],
-        fix: "hook-registry.json을 확인하세요.",
-      });
-      warn("hook-registry.json에서 관리 대상 훅을 찾지 못했습니다.");
-      issues++;
-    } else {
-      let settings = {};
-      if (existsSync(settingsPath)) {
-        try {
-          settings = JSON.parse(readFileSync(settingsPath, "utf8"));
-        } catch (error) {
-          const unreadableCoverage = {
-            total: managedHooks.length,
-            registered: 0,
-            missing: managedHooks.map((spec) => toHookCoverageName(spec.fileName, spec.id)),
-          };
-          report.hook_coverage = unreadableCoverage;
+    // ── Route Script 정합성 ──
+    section("Route Script Sync");
+    {
+      const srcRoute = join(PKG_ROOT, "scripts", "tfx-route.sh");
+      const destRoute = join(CLAUDE_DIR, "scripts", "tfx-route.sh");
+      if (existsSync(srcRoute) && existsSync(destRoute)) {
+        const srcHash = readFileSync(srcRoute, "utf8").length;
+        const destHash = readFileSync(destRoute, "utf8").length;
+        const srcContent = readFileSync(srcRoute, "utf8");
+        const destContent = readFileSync(destRoute, "utf8");
+        if (srcContent === destContent) {
+          addDoctorCheck(report, { name: "route-sync", status: "ok" });
+          ok("프로젝트 소스와 설치본 일치");
+        } else {
           addDoctorCheck(report, {
-            name: "hook-coverage",
-            status: "invalid",
-            total: unreadableCoverage.total,
-            registered: unreadableCoverage.registered,
-            missing: unreadableCoverage.missing,
-            fix: "settings.json 문법을 수정하거나 tfx setup을 다시 실행하세요.",
+            name: "route-sync",
+            status: "issues",
+            fix: "tfx setup",
           });
-          fail(`settings.json 파싱 실패: ${error.message}`);
-          issues++;
-          settings = null;
+          warn("tfx-route.sh 프로젝트 소스와 설치본 불일치");
+          info(
+            `소스: ${srcRoute} (${srcHash}B) / 설치: ${destRoute} (${destHash}B)`,
+          );
+          if (fix) {
+            copyFileSync(srcRoute, destRoute);
+            ok("tfx-route.sh 동기화 완료");
+          } else {
+            issues++;
+          }
         }
+      } else if (existsSync(srcRoute) && !existsSync(destRoute)) {
+        addDoctorCheck(report, {
+          name: "route-sync",
+          status: "missing",
+          fix: "tfx setup",
+        });
+        fail("설치본 없음");
+        issues++;
+      } else {
+        addDoctorCheck(report, { name: "route-sync", status: "ok" });
+        ok("소스 없음 (npm 패키지 모드)");
       }
+    }
 
-      if (settings) {
-        let coverage = computeHookCoverage(settings, managedHooks);
+    // ── Hook Coverage (hook-registry vs settings.json) ──
+    section("Hook Coverage");
+    {
+      const registryPath = join(PKG_ROOT, "hooks", "hook-registry.json");
+      const settingsPath = join(CLAUDE_DIR, "settings.json");
+      const managedHooks = getManagedRegistryHooks(registryPath);
 
-        if (coverage.missing.length > 0 && fix) {
-          const hookFixResult = ensureHooksInSettings({ settingsPath, registryPath });
-          if (hookFixResult.ok) {
-            if (hookFixResult.changed) {
-              ok(`누락 훅 ${hookFixResult.added.length}개 자동 등록됨`);
-            } else {
-              info("누락 훅 자동 등록: 변경 사항 없음");
-            }
-            try {
-              const fixedSettings = JSON.parse(readFileSync(settingsPath, "utf8"));
-              coverage = computeHookCoverage(fixedSettings, managedHooks);
-            } catch (error) {
-              warn(`자동 등록 후 settings.json 재검증 실패: ${error.message}`);
-            }
-          } else {
-            warn(`누락 훅 자동 등록 실패: ${hookFixResult.reason || "unknown_error"}`);
+      if (managedHooks.length === 0) {
+        addDoctorCheck(report, {
+          name: "hook-coverage",
+          status: "invalid",
+          total: 0,
+          registered: 0,
+          missing: [],
+          fix: "hook-registry.json을 확인하세요.",
+        });
+        warn("hook-registry.json에서 관리 대상 훅을 찾지 못했습니다.");
+        issues++;
+      } else {
+        let settings = {};
+        if (existsSync(settingsPath)) {
+          try {
+            settings = JSON.parse(readFileSync(settingsPath, "utf8"));
+          } catch (error) {
+            const unreadableCoverage = {
+              total: managedHooks.length,
+              registered: 0,
+              missing: managedHooks.map((spec) =>
+                toHookCoverageName(spec.fileName, spec.id),
+              ),
+            };
+            report.hook_coverage = unreadableCoverage;
+            addDoctorCheck(report, {
+              name: "hook-coverage",
+              status: "invalid",
+              total: unreadableCoverage.total,
+              registered: unreadableCoverage.registered,
+              missing: unreadableCoverage.missing,
+              fix: "settings.json 문법을 수정하거나 tfx setup을 다시 실행하세요.",
+            });
+            fail(`settings.json 파싱 실패: ${error.message}`);
+            issues++;
+            settings = null;
           }
         }
 
-        // 중복 훅 감지 + 자동 수정 (orchestrator와 개별 훅이 동시 등록된 경우)
-        if (coverage.duplicates && coverage.duplicates.length > 0) {
-          if (fix) {
-            try {
-              const fixedSettings = JSON.parse(readFileSync(settingsPath, "utf8"));
-              let removed = 0;
-              for (const [event, entries] of Object.entries(fixedSettings.hooks || {})) {
-                if (!Array.isArray(entries)) continue;
-                const hasOrch = entries.some((e) =>
-                  Array.isArray(e?.hooks) &&
-                  e.hooks.some((h) => typeof h?.command === "string" && h.command.includes("hook-orchestrator")),
+        if (settings) {
+          let coverage = computeHookCoverage(settings, managedHooks);
+
+          if (coverage.missing.length > 0 && fix) {
+            const hookFixResult = ensureHooksInSettings({
+              settingsPath,
+              registryPath,
+            });
+            if (hookFixResult.ok) {
+              if (hookFixResult.changed) {
+                ok(`누락 훅 ${hookFixResult.added.length}개 자동 등록됨`);
+              } else {
+                info("누락 훅 자동 등록: 변경 사항 없음");
+              }
+              try {
+                const fixedSettings = JSON.parse(
+                  readFileSync(settingsPath, "utf8"),
                 );
-                if (!hasOrch) continue;
-                // 패턴 A: orchestrator 없는 별도 엔트리 제거
-                const before = entries.length;
-                fixedSettings.hooks[event] = entries.filter((e) =>
-                  Array.isArray(e?.hooks) &&
-                  e.hooks.some((h) => typeof h?.command === "string" && h.command.includes("hook-orchestrator")),
+                coverage = computeHookCoverage(fixedSettings, managedHooks);
+              } catch (error) {
+                warn(
+                  `자동 등록 후 settings.json 재검증 실패: ${error.message}`,
                 );
-                removed += before - fixedSettings.hooks[event].length;
-                // 패턴 B: orchestrator 엔트리 내부의 개별 훅 제거
-                for (const entry of fixedSettings.hooks[event]) {
-                  if (!Array.isArray(entry.hooks) || entry.hooks.length <= 1) continue;
-                  const beforeInner = entry.hooks.length;
-                  entry.hooks = entry.hooks.filter(
-                    (h) => typeof h?.command === "string" && h.command.includes("hook-orchestrator"),
+              }
+            } else {
+              warn(
+                `누락 훅 자동 등록 실패: ${hookFixResult.reason || "unknown_error"}`,
+              );
+            }
+          }
+
+          // 중복 훅 감지 + 자동 수정 (orchestrator와 개별 훅이 동시 등록된 경우)
+          if (coverage.duplicates && coverage.duplicates.length > 0) {
+            if (fix) {
+              try {
+                const fixedSettings = JSON.parse(
+                  readFileSync(settingsPath, "utf8"),
+                );
+                let removed = 0;
+                for (const [event, entries] of Object.entries(
+                  fixedSettings.hooks || {},
+                )) {
+                  if (!Array.isArray(entries)) continue;
+                  const hasOrch = entries.some(
+                    (e) =>
+                      Array.isArray(e?.hooks) &&
+                      e.hooks.some(
+                        (h) =>
+                          typeof h?.command === "string" &&
+                          h.command.includes("hook-orchestrator"),
+                      ),
                   );
-                  removed += beforeInner - entry.hooks.length;
+                  if (!hasOrch) continue;
+                  // 패턴 A: orchestrator 없는 별도 엔트리 제거
+                  const before = entries.length;
+                  fixedSettings.hooks[event] = entries.filter(
+                    (e) =>
+                      Array.isArray(e?.hooks) &&
+                      e.hooks.some(
+                        (h) =>
+                          typeof h?.command === "string" &&
+                          h.command.includes("hook-orchestrator"),
+                      ),
+                  );
+                  removed += before - fixedSettings.hooks[event].length;
+                  // 패턴 B: orchestrator 엔트리 내부의 개별 훅 제거
+                  for (const entry of fixedSettings.hooks[event]) {
+                    if (!Array.isArray(entry.hooks) || entry.hooks.length <= 1)
+                      continue;
+                    const beforeInner = entry.hooks.length;
+                    entry.hooks = entry.hooks.filter(
+                      (h) =>
+                        typeof h?.command === "string" &&
+                        h.command.includes("hook-orchestrator"),
+                    );
+                    removed += beforeInner - entry.hooks.length;
+                  }
                 }
+                if (removed > 0) {
+                  writeFileSync(
+                    settingsPath,
+                    JSON.stringify(fixedSettings, null, 2) + "\n",
+                    "utf8",
+                  );
+                  ok(
+                    `중복 훅 ${removed}개 엔트리 제거됨 (orchestrator가 체이닝)`,
+                  );
+                  const rechecked = JSON.parse(
+                    readFileSync(settingsPath, "utf8"),
+                  );
+                  coverage = computeHookCoverage(rechecked, managedHooks);
+                }
+              } catch (error) {
+                warn(`중복 훅 자동 제거 실패: ${error.message}`);
               }
-              if (removed > 0) {
-                writeFileSync(settingsPath, JSON.stringify(fixedSettings, null, 2) + "\n", "utf8");
-                ok(`중복 훅 ${removed}개 엔트리 제거됨 (orchestrator가 체이닝)`);
-                const rechecked = JSON.parse(readFileSync(settingsPath, "utf8"));
-                coverage = computeHookCoverage(rechecked, managedHooks);
-              }
-            } catch (error) {
-              warn(`중복 훅 자동 제거 실패: ${error.message}`);
+            } else {
+              warn(
+                `중복 훅 ${coverage.duplicates.length}개 감지 (이중 실행됨): ${coverage.duplicates.join(", ")}`,
+              );
+              warn("tfx doctor --fix 로 자동 제거하세요.");
+              issues += coverage.duplicates.length;
             }
-          } else {
-            warn(`중복 훅 ${coverage.duplicates.length}개 감지 (이중 실행됨): ${coverage.duplicates.join(", ")}`);
-            warn("tfx doctor --fix 로 자동 제거하세요.");
-            issues += coverage.duplicates.length;
           }
-        }
 
-        report.hook_coverage = coverage;
-        const coverageStatus = coverage.missing.length === 0 && (!coverage.duplicates || coverage.duplicates.length === 0) ? "ok" : "issues";
-        addDoctorCheck(report, {
-          name: "hook-coverage",
-          status: coverageStatus,
-          total: coverage.total,
-          registered: coverage.registered,
-          missing: coverage.missing,
-          duplicates: coverage.duplicates || [],
-          ...(coverage.missing.length > 0 ? { fix: "tfx doctor --fix 또는 tfx setup" } : {}),
-          ...(coverage.duplicates?.length > 0 ? { fix: "tfx doctor --fix 로 중복 훅 제거" } : {}),
-        });
+          report.hook_coverage = coverage;
+          const coverageStatus =
+            coverage.missing.length === 0 &&
+            (!coverage.duplicates || coverage.duplicates.length === 0)
+              ? "ok"
+              : "issues";
+          addDoctorCheck(report, {
+            name: "hook-coverage",
+            status: coverageStatus,
+            total: coverage.total,
+            registered: coverage.registered,
+            missing: coverage.missing,
+            duplicates: coverage.duplicates || [],
+            ...(coverage.missing.length > 0
+              ? { fix: "tfx doctor --fix 또는 tfx setup" }
+              : {}),
+            ...(coverage.duplicates?.length > 0
+              ? { fix: "tfx doctor --fix 로 중복 훅 제거" }
+              : {}),
+          });
 
-        if (coverage.missing.length === 0 && (!coverage.duplicates || coverage.duplicates.length === 0)) {
-          ok(`Hook Coverage: ${coverage.registered}/${coverage.total} registered`);
-        } else if (coverage.missing.length > 0) {
-          fail(`Missing hooks: ${coverage.missing.join(", ")}`);
-          issues += coverage.missing.length;
+          if (
+            coverage.missing.length === 0 &&
+            (!coverage.duplicates || coverage.duplicates.length === 0)
+          ) {
+            ok(
+              `Hook Coverage: ${coverage.registered}/${coverage.total} registered`,
+            );
+          } else if (coverage.missing.length > 0) {
+            fail(`Missing hooks: ${coverage.missing.join(", ")}`);
+            issues += coverage.missing.length;
+          }
         }
       }
     }
-  }
 
-  // 결과
-  console.log(`\n  ${LINE}`);
-  if (issues === 0) {
-    console.log(`  ${GREEN_BRIGHT}${BOLD}✓ 모든 검사 통과${RESET}\n`);
-  } else {
-    console.log(`  ${YELLOW}${BOLD}⚠ ${issues}개 항목 확인 필요${RESET}\n`);
-  }
+    // 결과
+    console.log(`\n  ${LINE}`);
+    if (issues === 0) {
+      console.log(`  ${GREEN_BRIGHT}${BOLD}✓ 모든 검사 통과${RESET}\n`);
+    } else {
+      console.log(`  ${YELLOW}${BOLD}⚠ ${issues}개 항목 확인 필요${RESET}\n`);
+    }
     report.issue_count = issues;
     report.status = issues === 0 ? "ok" : "issues";
     if (json) printJson(report);
@@ -2588,7 +3500,7 @@ function resolveGitUpdateUrl(repoDir) {
 }
 
 function resolveUpdateTargets({ installMode, pluginPath }) {
-  const repoDir = installMode === "plugin" ? (pluginPath || PKG_ROOT) : PKG_ROOT;
+  const repoDir = installMode === "plugin" ? pluginPath || PKG_ROOT : PKG_ROOT;
   const gitUrl = resolveGitUpdateUrl(repoDir);
 
   if (installMode === "npm-global" || installMode === "npm-local") {
@@ -2625,7 +3537,10 @@ async function cmdUpdate() {
   }
 
   // PKG_ROOT가 플러그인 캐시 내에 있으면 플러그인 모드
-  if (installMode === "unknown" && PKG_ROOT.includes(join(".claude", "plugins"))) {
+  if (
+    installMode === "unknown" &&
+    PKG_ROOT.includes(join(".claude", "plugins"))
+  ) {
     installMode = "plugin";
     pluginPath = PKG_ROOT;
   }
@@ -2654,7 +3569,9 @@ async function cmdUpdate() {
     installMode = "git-local";
   }
 
-  info(`검색: ${installMode === "plugin" ? "플러그인" : installMode === "npm-global" ? "npm global" : installMode === "npm-local" ? "npm local" : installMode === "git-local" ? "git 로컬 저장소" : "알 수 없음"} 설치 감지`);
+  info(
+    `검색: ${installMode === "plugin" ? "플러그인" : installMode === "npm-global" ? "npm global" : installMode === "npm-local" ? "npm local" : installMode === "git-local" ? "git 로컬 저장소" : "알 수 없음"} 설치 감지`,
+  );
 
   const networkTargets = resolveUpdateTargets({ installMode, pluginPath });
   if (networkTargets.length > 0) {
@@ -2701,7 +3618,9 @@ async function cmdUpdate() {
         if (stoppedHubInfo?.pid) {
           info(`실행 중 hub 정지 (PID ${stoppedHubInfo.pid})`);
         }
-        const npmCmd = isDev ? "npm install -g triflux@dev" : "npm install -g triflux@latest";
+        const npmCmd = isDev
+          ? "npm install -g triflux@dev"
+          : "npm install -g triflux@latest";
         let result;
         try {
           result = execSync(npmCmd, {
@@ -2709,7 +3628,9 @@ async function cmdUpdate() {
             timeout: 90000,
             stdio: ["pipe", "pipe", "pipe"],
             windowsHide: true,
-          }).trim().split(/\r?\n/)[0];
+          })
+            .trim()
+            .split(/\r?\n/)[0];
         } catch {
           // Windows: 자기 자신의 파일 잠금으로 첫 시도 실패 가능 → --force 재시도
           info("첫 시도 실패, --force 재시도 중...");
@@ -2718,22 +3639,30 @@ async function cmdUpdate() {
             timeout: 90000,
             stdio: ["pipe", "pipe", "pipe"],
             windowsHide: true,
-          }).trim().split(/\r?\n/)[0];
+          })
+            .trim()
+            .split(/\r?\n/)[0];
         }
         ok(`${npmCmd} — ${result || "완료"}`);
         updated = true;
         break;
       }
       case "npm-local": {
-        const npmLocalCmd = isDev ? "npm install triflux@dev" : "npm update triflux";
+        const npmLocalCmd = isDev
+          ? "npm install triflux@dev"
+          : "npm update triflux";
         const result = execSync(npmLocalCmd, {
           encoding: "utf8",
           timeout: 60000,
           cwd: process.cwd(),
           stdio: ["pipe", "pipe", "ignore"],
           windowsHide: true,
-        }).trim().split(/\r?\n/)[0];
-        ok(`${isDev ? "npm install triflux@dev" : "npm update triflux"} — ${result || "완료"}`);
+        })
+          .trim()
+          .split(/\r?\n/)[0];
+        ok(
+          `${isDev ? "npm install triflux@dev" : "npm update triflux"} — ${result || "완료"}`,
+        );
         updated = true;
         break;
       }
@@ -2758,7 +3687,9 @@ async function cmdUpdate() {
       info("업데이트 실패 후 hub 재기동 시도");
     }
     const stderr = e.stderr?.toString().trim();
-    fail(`업데이트 실패: ${e.message}${stderr ? `\n  ${stderr.split(/\r?\n/)[0]}` : ""}`);
+    fail(
+      `업데이트 실패: ${e.message}${stderr ? `\n  ${stderr.split(/\r?\n/)[0]}` : ""}`,
+    );
     return;
   }
 
@@ -2768,7 +3699,9 @@ async function cmdUpdate() {
     // 업데이트 후 새 버전 읽기
     let newVer = oldVer;
     try {
-      const newPkg = JSON.parse(readFileSync(join(PKG_ROOT, "package.json"), "utf8"));
+      const newPkg = JSON.parse(
+        readFileSync(join(PKG_ROOT, "package.json"), "utf8"),
+      );
       newVer = newPkg.version;
     } catch {}
 
@@ -2785,22 +3718,37 @@ async function cmdUpdate() {
       // stale 캐시 삭제
       for (const name of ["tfx-preflight.json", "mcp-inventory.json"]) {
         const p = join(cacheDir, name);
-        if (existsSync(p)) { try { unlinkSync(p); } catch {} }
+        if (existsSync(p)) {
+          try {
+            unlinkSync(p);
+          } catch {}
+        }
       }
       // tmpdir 상태 파일 정리
       for (const name of ["tfx-multi-state.json"]) {
         const p = join(tmpdir(), name);
-        if (existsSync(p)) { try { unlinkSync(p); } catch {} }
+        if (existsSync(p)) {
+          try {
+            unlinkSync(p);
+          } catch {}
+        }
       }
 
       // preflight 캐시 재생성
       const preflightScript = join(PKG_ROOT, "scripts", "preflight-cache.mjs");
       if (existsSync(preflightScript)) {
         try {
-          execSync(`node "${preflightScript}"`, { encoding: "utf8", timeout: 15000, windowsHide: true, stdio: "pipe" });
+          execSync(`node "${preflightScript}"`, {
+            encoding: "utf8",
+            timeout: 15000,
+            windowsHide: true,
+            stdio: "pipe",
+          });
           ok("preflight 캐시 재생성 완료");
         } catch (e) {
-          warn(`preflight 캐시 재생성 실패: ${e.message?.split(/\r?\n/)[0] || "unknown"}`);
+          warn(
+            `preflight 캐시 재생성 실패: ${e.message?.split(/\r?\n/)[0] || "unknown"}`,
+          );
         }
       }
 
@@ -2808,10 +3756,17 @@ async function cmdUpdate() {
       const mcpCheckScript = join(PKG_ROOT, "scripts", "mcp-check.mjs");
       if (existsSync(mcpCheckScript)) {
         try {
-          execSync(`node "${mcpCheckScript}"`, { encoding: "utf8", timeout: 10000, windowsHide: true, stdio: "pipe" });
+          execSync(`node "${mcpCheckScript}"`, {
+            encoding: "utf8",
+            timeout: 10000,
+            windowsHide: true,
+            stdio: "pipe",
+          });
           ok("MCP 인벤토리 캐시 재생성 완료");
         } catch (e) {
-          warn(`MCP 인벤토리 재생성 실패: ${e.message?.split(/\r?\n/)[0] || "unknown"}`);
+          warn(
+            `MCP 인벤토리 재생성 실패: ${e.message?.split(/\r?\n/)[0] || "unknown"}`,
+          );
         }
       }
     }
@@ -2820,10 +3775,22 @@ async function cmdUpdate() {
     console.log(`\n${CYAN}── 무결성 검증 ──${RESET}`);
     {
       const criticalFiles = [
-        { path: join(PKG_ROOT, "hooks", "hook-orchestrator.mjs"), label: "hook-orchestrator" },
-        { path: join(PKG_ROOT, "hooks", "hook-registry.json"), label: "hook-registry" },
-        { path: join(PKG_ROOT, "hooks", "safety-guard.mjs"), label: "safety-guard" },
-        { path: join(PKG_ROOT, "scripts", "keyword-detector.mjs"), label: "keyword-detector" },
+        {
+          path: join(PKG_ROOT, "hooks", "hook-orchestrator.mjs"),
+          label: "hook-orchestrator",
+        },
+        {
+          path: join(PKG_ROOT, "hooks", "hook-registry.json"),
+          label: "hook-registry",
+        },
+        {
+          path: join(PKG_ROOT, "hooks", "safety-guard.mjs"),
+          label: "safety-guard",
+        },
+        {
+          path: join(PKG_ROOT, "scripts", "keyword-detector.mjs"),
+          label: "keyword-detector",
+        },
         { path: join(PKG_ROOT, "scripts", "setup.mjs"), label: "setup" },
         { path: join(PKG_ROOT, "bin", "triflux.mjs"), label: "triflux CLI" },
       ];
@@ -2835,7 +3802,9 @@ async function cmdUpdate() {
         }
       }
       if (missing > 0) {
-        fail(`핵심 파일 ${missing}개 누락 — npm install -g triflux@latest 재설치 필요`);
+        fail(
+          `핵심 파일 ${missing}개 누락 — npm install -g triflux@latest 재설치 필요`,
+        );
       } else {
         ok(`핵심 파일 ${criticalFiles.length}개 확인 완료`);
       }
@@ -2845,7 +3814,8 @@ async function cmdUpdate() {
     console.log(`\n${CYAN}── CLAUDE.md 라우팅 동기화 ──${RESET}`);
     {
       const claudeRoutingResults = syncClaudeRoutingSectionsForCli();
-      const claudeRoutingSummary = getClaudeRoutingSyncSummary(claudeRoutingResults);
+      const claudeRoutingSummary =
+        getClaudeRoutingSyncSummary(claudeRoutingResults);
       if (claudeRoutingSummary.changed > 0) {
         ok(`CLAUDE.md 라우팅 ${claudeRoutingSummary.changed}개 파일 반영`);
       } else if (claudeRoutingSummary.skipped > 0) {
@@ -2857,7 +3827,11 @@ async function cmdUpdate() {
 
     // ── Post-update: 설정 동기화 ──
     console.log(`\n${CYAN}── 설정 동기화 ──${RESET}`);
-    cmdSetup({ fromUpdate: true, overrideVersion: newVer, skipClaudeMdSync: true });
+    cmdSetup({
+      fromUpdate: true,
+      overrideVersion: newVer,
+      skipClaudeMdSync: true,
+    });
 
     // ── Post-update: 훅 오케스트레이터 적용 ──
     {
@@ -2871,10 +3845,14 @@ async function cmdUpdate() {
           }).trim();
           const parsed = JSON.parse(result);
           if (parsed?.status === "applied") {
-            ok(`훅 오케스트레이터 적용 (${parsed.events?.length || 0}개 이벤트)`);
+            ok(
+              `훅 오케스트레이터 적용 (${parsed.events?.length || 0}개 이벤트)`,
+            );
           }
         } catch (e) {
-          warn(`훅 오케스트레이터 적용 실패: ${e.message?.split(/\r?\n/)[0] || "unknown"}`);
+          warn(
+            `훅 오케스트레이터 적용 실패: ${e.message?.split(/\r?\n/)[0] || "unknown"}`,
+          );
           warn("tfx hooks apply 로 수동 적용하세요.");
         }
       } else {
@@ -2914,7 +3892,9 @@ function cmdList(options = {}) {
     skillAliases.push({ alias, source, installed: existsSync(dst) });
   }
 
-  const pkgNames = new Set(existsSync(pluginSkills) ? readdirSync(pluginSkills) : []);
+  const pkgNames = new Set(
+    existsSync(pluginSkills) ? readdirSync(pluginSkills) : [],
+  );
   if (existsSync(installedSkills)) {
     for (const name of readdirSync(installedSkills).sort()) {
       if (pkgNames.has(name) || aliasNames.has(name)) continue;
@@ -2942,7 +3922,9 @@ function cmdList(options = {}) {
     if (skill.installed) {
       console.log(`    ${GREEN_BRIGHT}✓${RESET} ${BOLD}${skill.name}${RESET}`);
     } else {
-      console.log(`    ${RED_BRIGHT}✗${RESET} ${DIM}${skill.name}${RESET} ${GRAY}(미설치)${RESET}`);
+      console.log(
+        `    ${RED_BRIGHT}✗${RESET} ${DIM}${skill.name}${RESET} ${GRAY}(미설치)${RESET}`,
+      );
     }
   }
 
@@ -2955,9 +3937,13 @@ function cmdList(options = {}) {
   if (skillAliases.length > 0) {
     section("호환 alias");
     for (const entry of skillAliases) {
-      const icon = entry.installed ? `${GREEN_BRIGHT}↳${RESET}` : `${RED_BRIGHT}↳${RESET}`;
+      const icon = entry.installed
+        ? `${GREEN_BRIGHT}↳${RESET}`
+        : `${RED_BRIGHT}↳${RESET}`;
       const status = entry.installed ? "" : ` ${GRAY}(미설치)${RESET}`;
-      console.log(`    ${icon} ${BOLD}${entry.alias}${RESET} ${GRAY}→ ${entry.source}${RESET}${status}`);
+      console.log(
+        `    ${icon} ${BOLD}${entry.alias}${RESET} ${GRAY}→ ${entry.source}${RESET}${status}`,
+      );
     }
   }
 
@@ -2978,7 +3964,9 @@ function cmdVersion(options = {}) {
     });
     return;
   }
-  console.log(`\n  ${AMBER}${BOLD}⬡ triflux${RESET} ${WHITE_BRIGHT}v${PKG.version}${RESET}`);
+  console.log(
+    `\n  ${AMBER}${BOLD}⬡ triflux${RESET} ${WHITE_BRIGHT}v${PKG.version}${RESET}`,
+  );
   if (routeVer) console.log(`  ${GRAY}tfx-route${RESET}  v${routeVer}`);
   if (hudVer) console.log(`  ${GRAY}hud${RESET}        v${hudVer}`);
   console.log("");
@@ -3023,7 +4011,7 @@ function cmdHandoff(args = [], options = {}) {
         throw createCliError("--decision 값이 필요합니다", {
           exitCode: EXIT_ARG_ERROR,
           reason: "argError",
-          fix: "tfx handoff --decision \"결정사항\"",
+          fix: 'tfx handoff --decision "결정사항"',
         });
       }
       parsed.decisions.push(next);
@@ -3118,7 +4106,11 @@ function cmdSchema(args = []) {
       $schema: bundle.$schema,
       title: "Triflux CLI Schema Bundle",
       global_options: [
-        { name: "--json", type: "boolean", description: "지원 커맨드의 출력을 JSON으로 전환" },
+        {
+          name: "--json",
+          type: "boolean",
+          description: "지원 커맨드의 출력을 JSON으로 전환",
+        },
       ],
       commands: CLI_COMMAND_SCHEMAS,
       hub_tools: bundle,
@@ -3154,7 +4146,9 @@ function cmdSchema(args = []) {
 
 function cmdMcp(args = [], options = {}) {
   const { json = false } = options;
-  const sub = String(args[0] || "list").trim().toLowerCase();
+  const sub = String(args[0] || "list")
+    .trim()
+    .toLowerCase();
 
   if (sub === "help" || sub === "--help" || sub === "-h") {
     console.log(`
@@ -3175,7 +4169,8 @@ function cmdMcp(args = [], options = {}) {
       if (json) {
         printJson({
           registry_path: registryState.path,
-          server_count: Object.keys(registryState.registry.servers || {}).length,
+          server_count: Object.keys(registryState.registry.servers || {})
+            .length,
           rows: statusInfo.rows,
           configs: statusInfo.configs.map((config) => ({
             file: config.filePath,
@@ -3191,7 +4186,9 @@ function cmdMcp(args = [], options = {}) {
       console.log(`  ${LINE}`);
       section("Registry");
       info(formatPathForDisplay(registryState.path));
-      ok(`${Object.keys(registryState.registry.servers || {}).length}개 server 등록됨`);
+      ok(
+        `${Object.keys(registryState.registry.servers || {}).length}개 server 등록됨`,
+      );
       if (statusInfo.rows.length === 0) {
         info("표시할 MCP 상태 없음");
       } else {
@@ -3222,7 +4219,8 @@ function cmdMcp(args = [], options = {}) {
         const label = `${action.label} ${DIM}(${formatPathForDisplay(action.filePath)})${RESET}`;
         if (action.status === "updated") ok(`${label} → updated`);
         else if (action.status === "warning") warn(`${label} → warning`);
-        else if (action.status === "invalid-config") fail(`${label} → invalid-config`);
+        else if (action.status === "invalid-config")
+          fail(`${label} → invalid-config`);
         else info(`${stripAnsi(label)} → ${action.status}`);
       }
       console.log("");
@@ -3248,7 +4246,9 @@ function cmdMcp(args = [], options = {}) {
       }
 
       const normalizedUrl = (() => {
-        try { return new URL(url).toString(); } catch {
+        try {
+          return new URL(url).toString();
+        } catch {
           throw createCliError(`Invalid MCP URL: ${url}`, {
             exitCode: EXIT_ARG_ERROR,
             reason: "argError",
@@ -3259,7 +4259,9 @@ function cmdMcp(args = [], options = {}) {
 
       const server = addRegistryServer(name, normalizedUrl);
       const registryState = ensureValidRegistryState();
-      const syncResult = syncRegistryTargets({ registry: registryState.registry });
+      const syncResult = syncRegistryTargets({
+        registry: registryState.registry,
+      });
       if (json) {
         printJson({
           name,
@@ -3273,7 +4275,9 @@ function cmdMcp(args = [], options = {}) {
       console.log(`  ${LINE}`);
       ok(`${name} 등록됨`);
       info(normalizedUrl);
-      const updated = syncResult.actions.filter((action) => action.status === "updated").length;
+      const updated = syncResult.actions.filter(
+        (action) => action.status === "updated",
+      ).length;
       info(`동기화 반영: ${updated}개`);
       console.log("");
       return;
@@ -3291,7 +4295,9 @@ function cmdMcp(args = [], options = {}) {
 
       ensureValidRegistryState();
       const removed = removeRegistryServer(name);
-      const cleanup = removeServerFromTargets(name, { targets: removed?.targets });
+      const cleanup = removeServerFromTargets(name, {
+        targets: removed?.targets,
+      });
       if (json) {
         printJson({
           name,
@@ -3306,7 +4312,9 @@ function cmdMcp(args = [], options = {}) {
       console.log(`  ${LINE}`);
       if (removed) ok(`${name} registry에서 제거됨`);
       else warn(`${name} registry entry 없음`);
-      const changed = cleanup.actions.filter((action) => action.status === "removed").length;
+      const changed = cleanup.actions.filter(
+        (action) => action.status === "removed",
+      ).length;
       info(`설정 제거 반영: ${changed}개`);
       console.log("");
       return;
@@ -3345,7 +4353,10 @@ function checkForUpdate() {
     }).trim();
 
     if (!existsSync(cacheDir)) mkdirSync(cacheDir, { recursive: true });
-    writeFileSync(cacheFile, JSON.stringify({ latest: result, timestamp: Date.now() }));
+    writeFileSync(
+      cacheFile,
+      JSON.stringify({ latest: result, timestamp: Date.now() }),
+    );
 
     return result !== PKG.version ? result : null;
   } catch {
@@ -3404,8 +4415,21 @@ ${updateNotice}
 async function cmdCodexTeam(args = []) {
   const sub = String(args[0] || "").toLowerCase();
   const passthrough = new Set([
-    "status", "attach", "stop", "kill", "send", "list", "help", "--help", "-h",
-    "tasks", "task", "focus", "interrupt", "control", "debug",
+    "status",
+    "attach",
+    "stop",
+    "kill",
+    "send",
+    "list",
+    "help",
+    "--help",
+    "-h",
+    "tasks",
+    "task",
+    "focus",
+    "interrupt",
+    "control",
+    "debug",
   ]);
 
   if (sub === "help" || sub === "--help" || sub === "-h") {
@@ -3428,7 +4452,8 @@ async function cmdCodexTeam(args = []) {
   const hasLead = args.includes("--lead");
   const hasLayout = args.includes("--layout");
   const isControl = passthrough.has(sub);
-  const normalizedArgs = isControl && args.length ? [sub, ...args.slice(1)] : args;
+  const normalizedArgs =
+    isControl && args.length ? [sub, ...args.slice(1)] : args;
   const inject = [];
   if (!isControl && !hasLead) inject.push("--lead", "codex");
   if (!isControl && !hasAgents) inject.push("--agents", "codex,codex");
@@ -3439,13 +4464,16 @@ async function cmdCodexTeam(args = []) {
   const prevProfile = process.env.TFX_TEAM_PROFILE;
   process.env.TFX_TEAM_PROFILE = "codex-team";
   const { pathToFileURL } = await import("node:url");
-  const { cmdTeam } = await import(pathToFileURL(join(PKG_ROOT, "hub", "team", "cli", "index.mjs")).href);
+  const { cmdTeam } = await import(
+    pathToFileURL(join(PKG_ROOT, "hub", "team", "cli", "index.mjs")).href
+  );
   process.argv = [prevArgv[0], prevArgv[1], "team", ...forwarded];
   try {
     await cmdTeam();
   } finally {
     process.argv = prevArgv;
-    if (typeof prevProfile === "string") process.env.TFX_TEAM_PROFILE = prevProfile;
+    if (typeof prevProfile === "string")
+      process.env.TFX_TEAM_PROFILE = prevProfile;
     else delete process.env.TFX_TEAM_PROFILE;
   }
 }
@@ -3457,7 +4485,8 @@ async function checkHubRunning() {
   try {
     const cacheFile = join(homedir(), ".claude", "cache", "tfx-preflight.json");
     const cached = JSON.parse(readFileSync(cacheFile, "utf8"));
-    if (Date.now() - cached.timestamp < 3_600_000 && cached.hub?.ok) return true;
+    if (Date.now() - cached.timestamp < 3_600_000 && cached.hub?.ok)
+      return true;
   } catch {}
   const port = Number(process.env.TFX_HUB_PORT || "27888");
   try {
@@ -3468,7 +4497,9 @@ async function checkHubRunning() {
   } catch {}
   console.log("");
   warn(`${AMBER}tfx-hub${RESET}가 실행되고 있지 않습니다.`);
-  info(`Hub 없이 실행하면 Claude 네이티브 에이전트로 폴백되어 토큰이 소비됩니다.`);
+  info(
+    `Hub 없이 실행하면 Claude 네이티브 에이전트로 폴백되어 토큰이 소비됩니다.`,
+  );
   info(`Codex(무료) 위임을 활용하려면 먼저 Hub를 시작하세요:\n`);
   console.log(`    ${WHITE_BRIGHT}tfx hub start${RESET}\n`);
   return false;
@@ -3490,7 +4521,9 @@ function stopHubForUpdate() {
     info = JSON.parse(readFileSync(HUB_PID_FILE, "utf8"));
     process.kill(info.pid, 0);
   } catch {
-    try { unlinkSync(HUB_PID_FILE); } catch {}
+    try {
+      unlinkSync(HUB_PID_FILE);
+    } catch {}
     return null;
   }
 
@@ -3505,15 +4538,28 @@ function stopHubForUpdate() {
       process.kill(info.pid, "SIGTERM");
     }
   } catch {
-    try { process.kill(info.pid, "SIGKILL"); } catch {}
+    try {
+      process.kill(info.pid, "SIGKILL");
+    } catch {}
   }
 
   // Windows에서 better-sqlite3.node 파일 핸들 해제 대기
   // taskkill 후 프로세스 종료 + 파일 핸들 해제까지 최대 5초
-  const sqliteNode = join(PKG_ROOT, "node_modules", "better-sqlite3", "build", "Release", "better_sqlite3.node");
+  const sqliteNode = join(
+    PKG_ROOT,
+    "node_modules",
+    "better-sqlite3",
+    "build",
+    "Release",
+    "better_sqlite3.node",
+  );
   for (let i = 0; i < 10; i++) {
     sleepMs(500);
-    try { process.kill(info.pid, 0); } catch { break; }
+    try {
+      process.kill(info.pid, 0);
+    } catch {
+      break;
+    }
   }
   // 파일 잠금 해제 확인 (Windows EBUSY 방지)
   if (existsSync(sqliteNode)) {
@@ -3527,7 +4573,9 @@ function stopHubForUpdate() {
       }
     }
   }
-  try { unlinkSync(HUB_PID_FILE); } catch {}
+  try {
+    unlinkSync(HUB_PID_FILE);
+  } catch {}
   return info;
 }
 
@@ -3535,7 +4583,10 @@ function startHubAfterUpdate(info) {
   if (!info) return false;
   const serverPath = join(PKG_ROOT, "hub", "server.mjs");
   if (!existsSync(serverPath)) return false;
-  const port = Number(info?.port) > 0 ? String(info.port) : String(process.env.TFX_HUB_PORT || "27888");
+  const port =
+    Number(info?.port) > 0
+      ? String(info.port)
+      : String(process.env.TFX_HUB_PORT || "27888");
 
   try {
     const child = spawn(process.execPath, [serverPath], {
@@ -3558,14 +4609,24 @@ function autoRegisterMcp(mcpUrl, { codexEnabled = false } = {}) {
   // Codex — config.json에 기본 disabled 엔트리로 등록
   if (which("codex")) {
     try {
-      const result = ensureCodexHubServerConfig({ mcpUrl, createIfMissing: true, enabled: codexEnabled });
+      const result = ensureCodexHubServerConfig({
+        mcpUrl,
+        createIfMissing: true,
+        enabled: codexEnabled,
+      });
       if (!result.ok) throw new Error(result.reason || "unknown");
       if (result.changed) {
-        ok(`Codex: config.json에 등록 완료 (${codexEnabled ? "enabled" : "기본 disabled"})`);
+        ok(
+          `Codex: config.json에 등록 완료 (${codexEnabled ? "enabled" : "기본 disabled"})`,
+        );
       } else {
-        ok(`Codex: 이미 등록됨 (${codexEnabled ? "enabled" : "기본 disabled"})`);
+        ok(
+          `Codex: 이미 등록됨 (${codexEnabled ? "enabled" : "기본 disabled"})`,
+        );
       }
-    } catch (e) { warn(`Codex 등록 실패: ${e.message}`); }
+    } catch (e) {
+      warn(`Codex 등록 실패: ${e.message}`);
+    }
   } else {
     info("Codex: 미설치 (건너뜀)");
   }
@@ -3576,7 +4637,8 @@ function autoRegisterMcp(mcpUrl, { codexEnabled = false } = {}) {
       const geminiDir = join(homedir(), ".gemini");
       const settingsFile = join(geminiDir, "settings.json");
       let settings = {};
-      if (existsSync(settingsFile)) settings = JSON.parse(readFileSync(settingsFile, "utf8"));
+      if (existsSync(settingsFile))
+        settings = JSON.parse(readFileSync(settingsFile, "utf8"));
       if (!settings.mcpServers) settings.mcpServers = {};
       if (!settings.mcpServers["tfx-hub"]) {
         settings.mcpServers["tfx-hub"] = { url: mcpUrl };
@@ -3586,7 +4648,9 @@ function autoRegisterMcp(mcpUrl, { codexEnabled = false } = {}) {
       } else {
         ok("Gemini: 이미 등록됨");
       }
-    } catch (e) { warn(`Gemini 등록 실패: ${e.message}`); }
+    } catch (e) {
+      warn(`Gemini 등록 실패: ${e.message}`);
+    }
   } else {
     info("Gemini: 미설치 (건너뜀)");
   }
@@ -3597,7 +4661,8 @@ function autoRegisterMcp(mcpUrl, { codexEnabled = false } = {}) {
     if (!existsSync(claudeDir)) mkdirSync(claudeDir, { recursive: true });
     const mcpJsonPath = join(claudeDir, "mcp.json");
     let mcpJson = {};
-    if (existsSync(mcpJsonPath)) mcpJson = JSON.parse(readFileSync(mcpJsonPath, "utf8"));
+    if (existsSync(mcpJsonPath))
+      mcpJson = JSON.parse(readFileSync(mcpJsonPath, "utf8"));
     if (!mcpJson.mcpServers) mcpJson.mcpServers = {};
     if (!mcpJson.mcpServers["tfx-hub"]) {
       mcpJson.mcpServers["tfx-hub"] = { type: "url", url: mcpUrl };
@@ -3606,20 +4671,32 @@ function autoRegisterMcp(mcpUrl, { codexEnabled = false } = {}) {
     } else {
       ok("Claude: 이미 등록됨");
     }
-  } catch (e) { warn(`Claude 등록 실패: ${e.message}`); }
+  } catch (e) {
+    warn(`Claude 등록 실패: ${e.message}`);
+  }
 }
 
 async function cmdHub(args = [], options = {}) {
   const { json = false } = options;
   const sub = args[0] || "status";
   const defaultPortRaw = Number(process.env.TFX_HUB_PORT || "27888");
-  const probePort = Number.isFinite(defaultPortRaw) && defaultPortRaw > 0 ? defaultPortRaw : 27888;
-  const formatHostForUrl = (host) => host.includes(":") ? `[${host}]` : host;
-  const probeHubStatus = async (host = "127.0.0.1", port = probePort, timeoutMs = 3000) => {
+  const probePort =
+    Number.isFinite(defaultPortRaw) && defaultPortRaw > 0
+      ? defaultPortRaw
+      : 27888;
+  const formatHostForUrl = (host) => (host.includes(":") ? `[${host}]` : host);
+  const probeHubStatus = async (
+    host = "127.0.0.1",
+    port = probePort,
+    timeoutMs = 3000,
+  ) => {
     try {
-      const res = await fetch(`http://${formatHostForUrl(host)}:${port}/status`, {
-        signal: AbortSignal.timeout(timeoutMs),
-      });
+      const res = await fetch(
+        `http://${formatHostForUrl(host)}:${port}/status`,
+        {
+          signal: AbortSignal.timeout(timeoutMs),
+        },
+      );
       if (!res.ok) return null;
       const data = await res.json();
       return data?.hub ? data : null;
@@ -3633,13 +4710,16 @@ async function cmdHub(args = [], options = {}) {
     if (!Number.isFinite(pid) || pid <= 0) return;
     try {
       mkdirSync(HUB_PID_DIR, { recursive: true });
-      writeFileSync(HUB_PID_FILE, JSON.stringify({
-        pid,
-        port,
-        host: defaultHost,
-        url: `http://${formatHostForUrl(defaultHost)}:${port}/mcp`,
-        started: Date.now(),
-      }));
+      writeFileSync(
+        HUB_PID_FILE,
+        JSON.stringify({
+          pid,
+          port,
+          host: defaultHost,
+          url: `http://${formatHostForUrl(defaultHost)}:${port}/mcp`,
+          started: Date.now(),
+        }),
+      );
     } catch {}
   };
   const emitHubStatus = (payload) => {
@@ -3656,11 +4736,15 @@ async function cmdHub(args = [], options = {}) {
           const info = JSON.parse(readFileSync(HUB_PID_FILE, "utf8"));
           process.kill(info.pid, 0); // 프로세스 존재 확인
           autoRegisterMcp(info.url, { codexEnabled: true });
-          console.log(`\n  ${YELLOW}⚠${RESET} hub 이미 실행 중 (PID ${info.pid}, ${info.url})\n`);
+          console.log(
+            `\n  ${YELLOW}⚠${RESET} hub 이미 실행 중 (PID ${info.pid}, ${info.url})\n`,
+          );
           return;
         } catch {
           // PID 파일 있지만 프로세스 없음 — 정리
-          try { unlinkSync(HUB_PID_FILE); } catch {}
+          try {
+            unlinkSync(HUB_PID_FILE);
+          } catch {}
         }
       }
 
@@ -3688,7 +4772,10 @@ async function cmdHub(args = [], options = {}) {
       let started = false;
       const deadline = Date.now() + 3000;
       while (Date.now() < deadline) {
-        if (existsSync(HUB_PID_FILE)) { started = true; break; }
+        if (existsSync(HUB_PID_FILE)) {
+          started = true;
+          break;
+        }
         await new Promise((r) => setTimeout(r, 100));
       }
 
@@ -3697,26 +4784,37 @@ async function cmdHub(args = [], options = {}) {
         console.log(`\n  ${GREEN_BRIGHT}✓${RESET} ${BOLD}tfx-hub 시작${RESET}`);
         console.log(`    URL:  ${AMBER}${hubInfo.url}${RESET}`);
         console.log(`    PID:  ${hubInfo.pid}`);
-        console.log(`    DB:   ${DIM}${getPipelineStateDbPath(PKG_ROOT)}${RESET}`);
+        console.log(
+          `    DB:   ${DIM}${getPipelineStateDbPath(PKG_ROOT)}${RESET}`,
+        );
         console.log("");
         autoRegisterMcp(hubInfo.url, { codexEnabled: true });
         console.log("");
       } else {
         // 직접 포그라운드 모드로 안내
-        console.log(`\n  ${YELLOW}⚠${RESET} 백그라운드 시작 실패 — 포그라운드로 실행:`);
-        console.log(`    ${DIM}TFX_HUB_PORT=${port} node ${serverPath}${RESET}\n`);
+        console.log(
+          `\n  ${YELLOW}⚠${RESET} 백그라운드 시작 실패 — 포그라운드로 실행:`,
+        );
+        console.log(
+          `    ${DIM}TFX_HUB_PORT=${port} node ${serverPath}${RESET}\n`,
+        );
       }
       break;
     }
 
     case "stop": {
       if (!existsSync(HUB_PID_FILE)) {
-        const probed = await probeHubStatus("127.0.0.1", probePort, 1500)
-          || (probePort === 27888 ? null : await probeHubStatus("127.0.0.1", 27888, 1500));
+        const probed =
+          (await probeHubStatus("127.0.0.1", probePort, 1500)) ||
+          (probePort === 27888
+            ? null
+            : await probeHubStatus("127.0.0.1", 27888, 1500));
         if (probed && Number.isFinite(Number(probed.pid))) {
           try {
             process.kill(Number(probed.pid), "SIGTERM");
-            console.log(`\n  ${GREEN_BRIGHT}✓${RESET} hub 종료됨 (PID ${probed.pid})${DIM} (probe)${RESET}\n`);
+            console.log(
+              `\n  ${GREEN_BRIGHT}✓${RESET} hub 종료됨 (PID ${probed.pid})${DIM} (probe)${RESET}\n`,
+            );
             return;
           } catch {}
         }
@@ -3726,10 +4824,16 @@ async function cmdHub(args = [], options = {}) {
       try {
         const info = JSON.parse(readFileSync(HUB_PID_FILE, "utf8"));
         process.kill(info.pid, "SIGTERM");
-        try { unlinkSync(HUB_PID_FILE); } catch {}
-        console.log(`\n  ${GREEN_BRIGHT}✓${RESET} hub 종료됨 (PID ${info.pid})\n`);
+        try {
+          unlinkSync(HUB_PID_FILE);
+        } catch {}
+        console.log(
+          `\n  ${GREEN_BRIGHT}✓${RESET} hub 종료됨 (PID ${info.pid})\n`,
+        );
       } catch (_e) {
-        try { unlinkSync(HUB_PID_FILE); } catch {}
+        try {
+          unlinkSync(HUB_PID_FILE);
+        } catch {}
         console.log(`\n  ${DIM}hub 프로세스 없음 — PID 파일 정리됨${RESET}\n`);
       }
       break;
@@ -3739,43 +4843,76 @@ async function cmdHub(args = [], options = {}) {
       if (!existsSync(HUB_PID_FILE)) {
         const probed = await probeHubStatus();
         if (!probed) {
-          const fallback = probePort === 27888 ? null : await probeHubStatus("127.0.0.1", 27888, 1500);
+          const fallback =
+            probePort === 27888
+              ? null
+              : await probeHubStatus("127.0.0.1", 27888, 1500);
           if (fallback) {
             recoverPidFile(fallback, "127.0.0.1");
-            if (emitHubStatus({
-              status: "online",
-              source: "default-port-probe",
-              url: `http://127.0.0.1:${fallback.port || 27888}/mcp`,
-              pid: fallback.pid,
-              state: fallback.hub?.state || null,
-              sessions: fallback.sessions,
-            })) return;
-            console.log(`\n  ${AMBER}${BOLD}⬡ tfx-hub${RESET} ${GREEN_BRIGHT}online${RESET} ${DIM}(default port probe 성공)${RESET}`);
-            console.log(`    URL:     http://127.0.0.1:${fallback.port || 27888}/mcp`);
-            if (fallback.pid !== undefined) console.log(`    PID:     ${fallback.pid}`);
-            if (fallback.hub?.state) console.log(`    State:   ${fallback.hub.state}`);
-            if (fallback.sessions !== undefined) console.log(`    Sessions: ${fallback.sessions}`);
+            if (
+              emitHubStatus({
+                status: "online",
+                source: "default-port-probe",
+                url: `http://127.0.0.1:${fallback.port || 27888}/mcp`,
+                pid: fallback.pid,
+                state: fallback.hub?.state || null,
+                sessions: fallback.sessions,
+              })
+            )
+              return;
+            console.log(
+              `\n  ${AMBER}${BOLD}⬡ tfx-hub${RESET} ${GREEN_BRIGHT}online${RESET} ${DIM}(default port probe 성공)${RESET}`,
+            );
+            console.log(
+              `    URL:     http://127.0.0.1:${fallback.port || 27888}/mcp`,
+            );
+            if (fallback.pid !== undefined)
+              console.log(`    PID:     ${fallback.pid}`);
+            if (fallback.hub?.state)
+              console.log(`    State:   ${fallback.hub.state}`);
+            if (fallback.sessions !== undefined)
+              console.log(`    Sessions: ${fallback.sessions}`);
             console.log("");
             return;
           }
-          if (emitHubStatus({ status: "offline", source: "probe", url: null, pid: null, state: null, sessions: 0 })) return;
-          console.log(`\n  ${AMBER}${BOLD}⬡ tfx-hub${RESET} ${RED}offline${RESET}\n`);
+          if (
+            emitHubStatus({
+              status: "offline",
+              source: "probe",
+              url: null,
+              pid: null,
+              state: null,
+              sessions: 0,
+            })
+          )
+            return;
+          console.log(
+            `\n  ${AMBER}${BOLD}⬡ tfx-hub${RESET} ${RED}offline${RESET}\n`,
+          );
           return;
         }
         recoverPidFile(probed, "127.0.0.1");
-        if (emitHubStatus({
-          status: "online",
-          source: "probe",
-          url: `http://127.0.0.1:${probed.port || probePort}/mcp`,
-          pid: probed.pid,
-          state: probed.hub?.state || null,
-          sessions: probed.sessions,
-        })) return;
-        console.log(`\n  ${AMBER}${BOLD}⬡ tfx-hub${RESET} ${GREEN_BRIGHT}online${RESET} ${DIM}(pid file 없음 / probe 성공)${RESET}`);
-        console.log(`    URL:     http://127.0.0.1:${probed.port || probePort}/mcp`);
+        if (
+          emitHubStatus({
+            status: "online",
+            source: "probe",
+            url: `http://127.0.0.1:${probed.port || probePort}/mcp`,
+            pid: probed.pid,
+            state: probed.hub?.state || null,
+            sessions: probed.sessions,
+          })
+        )
+          return;
+        console.log(
+          `\n  ${AMBER}${BOLD}⬡ tfx-hub${RESET} ${GREEN_BRIGHT}online${RESET} ${DIM}(pid file 없음 / probe 성공)${RESET}`,
+        );
+        console.log(
+          `    URL:     http://127.0.0.1:${probed.port || probePort}/mcp`,
+        );
         if (probed.pid !== undefined) console.log(`    PID:     ${probed.pid}`);
         if (probed.hub?.state) console.log(`    State:   ${probed.hub.state}`);
-        if (probed.sessions !== undefined) console.log(`    Sessions: ${probed.sessions}`);
+        if (probed.sessions !== undefined)
+          console.log(`    Sessions: ${probed.sessions}`);
         console.log("");
         return;
       }
@@ -3783,9 +4920,12 @@ async function cmdHub(args = [], options = {}) {
         const info = JSON.parse(readFileSync(HUB_PID_FILE, "utf8"));
         process.kill(info.pid, 0); // 생존 확인
         const uptime = Date.now() - info.started;
-        const uptimeStr = uptime < 60000 ? `${Math.round(uptime / 1000)}초`
-          : uptime < 3600000 ? `${Math.round(uptime / 60000)}분`
-          : `${Math.round(uptime / 3600000)}시간`;
+        const uptimeStr =
+          uptime < 60000
+            ? `${Math.round(uptime / 1000)}초`
+            : uptime < 3600000
+              ? `${Math.round(uptime / 60000)}분`
+              : `${Math.round(uptime / 3600000)}시간`;
 
         let data = null;
         try {
@@ -3794,16 +4934,21 @@ async function cmdHub(args = [], options = {}) {
           data = await probeHubStatus(host, port, 3000);
         } catch {}
 
-        if (emitHubStatus({
-          status: "online",
-          source: "pid-file",
-          url: info.url,
-          pid: info.pid,
-          uptime_ms: uptime,
-          state: data?.hub?.state || null,
-          sessions: data?.sessions,
-        })) return;
-        console.log(`\n  ${AMBER}${BOLD}⬡ tfx-hub${RESET} ${GREEN_BRIGHT}online${RESET}`);
+        if (
+          emitHubStatus({
+            status: "online",
+            source: "pid-file",
+            url: info.url,
+            pid: info.pid,
+            uptime_ms: uptime,
+            state: data?.hub?.state || null,
+            sessions: data?.sessions,
+          })
+        )
+          return;
+        console.log(
+          `\n  ${AMBER}${BOLD}⬡ tfx-hub${RESET} ${GREEN_BRIGHT}online${RESET}`,
+        );
         console.log(`    URL:     ${info.url}`);
         console.log(`    PID:     ${info.pid}`);
         console.log(`    Uptime:  ${uptimeStr}`);
@@ -3815,27 +4960,49 @@ async function cmdHub(args = [], options = {}) {
         }
         console.log("");
       } catch {
-        try { unlinkSync(HUB_PID_FILE); } catch {}
+        try {
+          unlinkSync(HUB_PID_FILE);
+        } catch {}
         const probed = await probeHubStatus();
         if (!probed) {
-          if (emitHubStatus({ status: "offline", source: "stale-pid", url: null, pid: null, state: null, sessions: 0 })) break;
-          console.log(`\n  ${AMBER}${BOLD}⬡ tfx-hub${RESET} ${RED}offline${RESET} ${DIM}(stale PID 정리됨)${RESET}\n`);
+          if (
+            emitHubStatus({
+              status: "offline",
+              source: "stale-pid",
+              url: null,
+              pid: null,
+              state: null,
+              sessions: 0,
+            })
+          )
+            break;
+          console.log(
+            `\n  ${AMBER}${BOLD}⬡ tfx-hub${RESET} ${RED}offline${RESET} ${DIM}(stale PID 정리됨)${RESET}\n`,
+          );
           break;
         }
         recoverPidFile(probed, "127.0.0.1");
-        if (emitHubStatus({
-          status: "online",
-          source: "stale-pid-probe",
-          url: `http://127.0.0.1:${probed.port || probePort}/mcp`,
-          pid: probed.pid,
-          state: probed.hub?.state || null,
-          sessions: probed.sessions,
-        })) break;
-        console.log(`\n  ${AMBER}${BOLD}⬡ tfx-hub${RESET} ${GREEN_BRIGHT}online${RESET} ${DIM}(stale PID 정리 후 probe 성공)${RESET}`);
-        console.log(`    URL:     http://127.0.0.1:${probed.port || probePort}/mcp`);
+        if (
+          emitHubStatus({
+            status: "online",
+            source: "stale-pid-probe",
+            url: `http://127.0.0.1:${probed.port || probePort}/mcp`,
+            pid: probed.pid,
+            state: probed.hub?.state || null,
+            sessions: probed.sessions,
+          })
+        )
+          break;
+        console.log(
+          `\n  ${AMBER}${BOLD}⬡ tfx-hub${RESET} ${GREEN_BRIGHT}online${RESET} ${DIM}(stale PID 정리 후 probe 성공)${RESET}`,
+        );
+        console.log(
+          `    URL:     http://127.0.0.1:${probed.port || probePort}/mcp`,
+        );
         if (probed.pid !== undefined) console.log(`    PID:     ${probed.pid}`);
         if (probed.hub?.state) console.log(`    State:   ${probed.hub.state}`);
-        if (probed.sessions !== undefined) console.log(`    Sessions: ${probed.sessions}`);
+        if (probed.sessions !== undefined)
+          console.log(`    Sessions: ${probed.sessions}`);
         console.log("");
       }
       break;
@@ -3845,12 +5012,24 @@ async function cmdHub(args = [], options = {}) {
       // 사일런트 idempotent 보장 — 스킬 환경 프로브용.
       // Hub 살아있으면 즉시 종료, 죽어있으면 자동 시작 + ready 대기.
       const portArg = args.indexOf("--port");
-      const ensurePort = portArg !== -1 ? args[portArg + 1] : (process.env.TFX_HUB_PORT || "27888");
+      const ensurePort =
+        portArg !== -1
+          ? args[portArg + 1]
+          : process.env.TFX_HUB_PORT || "27888";
 
       // 1. 이미 healthy?
-      const ensureProbed = await probeHubStatus("127.0.0.1", Number(ensurePort), 1500);
+      const ensureProbed = await probeHubStatus(
+        "127.0.0.1",
+        Number(ensurePort),
+        1500,
+      );
       if (ensureProbed?.hub?.state === "healthy") {
-        if (json) printJson({ status: "ok", pid: ensureProbed.pid, port: Number(ensurePort) });
+        if (json)
+          printJson({
+            status: "ok",
+            pid: ensureProbed.pid,
+            port: Number(ensurePort),
+          });
         else process.stdout.write("hub: ok\n");
         return;
       }
@@ -3864,15 +5043,26 @@ async function cmdHub(args = [], options = {}) {
           const retryDeadline = Date.now() + 3000;
           while (Date.now() < retryDeadline) {
             await new Promise((r) => setTimeout(r, 250));
-            const retry = await probeHubStatus("127.0.0.1", Number(ensurePort), 1000);
+            const retry = await probeHubStatus(
+              "127.0.0.1",
+              Number(ensurePort),
+              1000,
+            );
             if (retry?.hub?.state === "healthy") {
-              if (json) printJson({ status: "ok", pid: retry.pid, port: Number(ensurePort) });
+              if (json)
+                printJson({
+                  status: "ok",
+                  pid: retry.pid,
+                  port: Number(ensurePort),
+                });
               else process.stdout.write("hub: ok\n");
               return;
             }
           }
         } catch {
-          try { unlinkSync(HUB_PID_FILE); } catch {}
+          try {
+            unlinkSync(HUB_PID_FILE);
+          } catch {}
         }
       }
 
@@ -3886,11 +5076,15 @@ async function cmdHub(args = [], options = {}) {
       }
 
       if (process.platform === "win32") {
-        const child = spawn("cmd.exe", ["/c", "start", "/b", "", process.execPath, serverPath], {
-          env: { ...process.env, TFX_HUB_PORT: String(ensurePort) },
-          stdio: "ignore",
-          windowsHide: true,
-        });
+        const child = spawn(
+          "cmd.exe",
+          ["/c", "start", "/b", "", process.execPath, serverPath],
+          {
+            env: { ...process.env, TFX_HUB_PORT: String(ensurePort) },
+            stdio: "ignore",
+            windowsHide: true,
+          },
+        );
         child.unref();
       } else {
         const child = spawn(process.execPath, [serverPath], {
@@ -3906,9 +5100,19 @@ async function cmdHub(args = [], options = {}) {
       while (Date.now() < readyDeadline) {
         await new Promise((r) => setTimeout(r, 250));
         if (existsSync(HUB_PID_FILE)) {
-          const readyProbe = await probeHubStatus("127.0.0.1", Number(ensurePort), 1000);
+          const readyProbe = await probeHubStatus(
+            "127.0.0.1",
+            Number(ensurePort),
+            1000,
+          );
           if (readyProbe?.hub?.state === "healthy") {
-            if (json) printJson({ status: "ok", pid: readyProbe.pid, port: Number(ensurePort), started: true });
+            if (json)
+              printJson({
+                status: "ok",
+                pid: readyProbe.pid,
+                port: Number(ensurePort),
+                started: true,
+              });
             else process.stdout.write("hub: started\n");
             return;
           }
@@ -3923,11 +5127,21 @@ async function cmdHub(args = [], options = {}) {
 
     default:
       console.log(`\n  ${AMBER}${BOLD}⬡ tfx-hub${RESET}\n`);
-      console.log(`    ${WHITE_BRIGHT}tfx hub start${RESET}    ${GRAY}허브 데몬 시작${RESET}`);
-      console.log(`    ${DIM}  --port N${RESET}       ${GRAY}포트 지정 (기본 27888)${RESET}`);
-      console.log(`    ${WHITE_BRIGHT}tfx hub stop${RESET}     ${GRAY}허브 중지${RESET}`);
-      console.log(`    ${WHITE_BRIGHT}tfx hub status${RESET}   ${GRAY}상태 확인${RESET}`);
-      console.log(`    ${WHITE_BRIGHT}tfx hub ensure${RESET}   ${GRAY}헬스체크 + 자동 시작 (스킬 프로브용)${RESET}\n`);
+      console.log(
+        `    ${WHITE_BRIGHT}tfx hub start${RESET}    ${GRAY}허브 데몬 시작${RESET}`,
+      );
+      console.log(
+        `    ${DIM}  --port N${RESET}       ${GRAY}포트 지정 (기본 27888)${RESET}`,
+      );
+      console.log(
+        `    ${WHITE_BRIGHT}tfx hub stop${RESET}     ${GRAY}허브 중지${RESET}`,
+      );
+      console.log(
+        `    ${WHITE_BRIGHT}tfx hub status${RESET}   ${GRAY}상태 확인${RESET}`,
+      );
+      console.log(
+        `    ${WHITE_BRIGHT}tfx hub ensure${RESET}   ${GRAY}헬스체크 + 자동 시작 (스킬 프로브용)${RESET}\n`,
+      );
   }
 }
 
@@ -3946,6 +5160,33 @@ async function main() {
       cmdSetup({ dryRun: cmdArgs.includes("--dry-run") });
       return;
     case "doctor": {
+      if (cmdArgs.includes("--audit")) {
+        const auditScript = join(PKG_ROOT, "scripts", "config-audit.mjs");
+        const auditArgs = JSON_OUTPUT ? ["--json"] : [];
+        try {
+          const out = execFileSync(process.execPath, [auditScript, ...auditArgs], {
+            timeout: 15000, encoding: "utf8", windowsHide: true,
+          });
+          process.stdout.write(out);
+        } catch (e) {
+          process.stdout.write(e.stdout || "");
+          if (e.stderr) process.stderr.write(e.stderr);
+        }
+        return;
+      }
+      if (cmdArgs.includes("--diagnose")) {
+        const { diagnose } = await import("../scripts/doctor-diagnose.mjs");
+        const result = await diagnose({ json: JSON_OUTPUT });
+        if (!JSON_OUTPUT) {
+          if (result.ok) {
+            console.log(`\n  ${GREEN_BRIGHT}✓${RESET} 진단 번들 생성: ${result.zipPath}`);
+            console.log(`  spawn 이벤트: ${result.traceCount}건, 훅 타이밍: ${result.hookTimingCount}건\n`);
+          } else {
+            console.log(`\n  ${RED}✗${RESET} 진단 실패: ${result.error}\n`);
+          }
+        }
+        return;
+      }
       const fix = cmdArgs.includes("--fix");
       const reset = cmdArgs.includes("--reset");
       await cmdDoctor({ fix, reset, json: JSON_OUTPUT });
@@ -3968,7 +5209,10 @@ async function main() {
       cmdHandoff(cmdArgs, { json: JSON_OUTPUT });
       return;
     case "hub":
-      await cmdHub(cmdArgs, { json: JSON_OUTPUT && ["status", "ensure"].includes(cmdArgs[0] || "status") });
+      await cmdHub(cmdArgs, {
+        json:
+          JSON_OUTPUT && ["status", "ensure"].includes(cmdArgs[0] || "status"),
+      });
       return;
     case "monitor": {
       const { createMonitor } = await import("../tui/monitor.mjs");
@@ -3992,7 +5236,9 @@ async function main() {
         windowsHide: true,
       });
       child.unref();
-      console.log(`\n  ${GREEN_BRIGHT}✓${RESET} tray 시작됨 (PID ${child.pid})\n`);
+      console.log(
+        `\n  ${GREEN_BRIGHT}✓${RESET} tray 시작됨 (PID ${child.pid})\n`,
+      );
       return;
     }
     case "multi": {
@@ -4003,7 +5249,9 @@ async function main() {
         await checkHubRunning();
       }
       const { pathToFileURL } = await import("node:url");
-      const { cmdTeam } = await import(pathToFileURL(join(PKG_ROOT, "hub", "team", "cli", "index.mjs")).href);
+      const { cmdTeam } = await import(
+        pathToFileURL(join(PKG_ROOT, "hub", "team", "cli", "index.mjs")).href
+      );
       const prevArgv = process.argv;
       process.argv = [prevArgv[0], prevArgv[1], "team", ...cmdArgs];
       try {
@@ -4028,7 +5276,11 @@ async function main() {
     case "nr": {
       const scriptPath = join(PKG_ROOT, "scripts", "notion-read.mjs");
       try {
-        execFileSync(process.execPath, [scriptPath, ...cmdArgs], { stdio: "inherit", timeout: 660000, windowsHide: true });
+        execFileSync(process.execPath, [scriptPath, ...cmdArgs], {
+          stdio: "inherit",
+          timeout: 660000,
+          windowsHide: true,
+        });
       } catch (e) {
         throw createCliError(e.message || "notion-read 실행 실패", {
           exitCode: e.status || EXIT_ERROR,
@@ -4041,11 +5293,15 @@ async function main() {
       const hookManagerPath = join(PKG_ROOT, "hooks", "hook-manager.mjs");
       const sub = cmdArgs[0] || "status";
       try {
-        execFileSync(process.execPath, [hookManagerPath, sub, ...cmdArgs.slice(1)], {
-          stdio: "inherit",
-          timeout: 30000,
-          windowsHide: true,
-        });
+        execFileSync(
+          process.execPath,
+          [hookManagerPath, sub, ...cmdArgs.slice(1)],
+          {
+            stdio: "inherit",
+            timeout: 30000,
+            windowsHide: true,
+          },
+        );
       } catch (e) {
         if (e.status) process.exitCode = e.status;
       }