feat: 채번규칙 메뉴 스코프 전환 완료

✅ 주요 변경사항:
- 백엔드: menuService.ts 추가 (형제 메뉴 조회 유틸리티)
- 백엔드: numberingRuleService.getAvailableRulesForMenu() 메뉴 스코프 적용
- 백엔드: tableCategoryValueService 메뉴 스코프 준비 (menuObjid 파라미터 추가)
- 프론트엔드: TextInputConfigPanel에 부모 메뉴 선택 UI 추가
- 프론트엔드: 메뉴별 채번규칙 필터링 (형제 메뉴 공유)

🔧 기술 세부사항:
- getSiblingMenuObjids(): 같은 부모를 가진 형제 메뉴 OBJID 조회
- 채번규칙 우선순위: menu (형제) > table > global
- 사용자 메뉴(menu_type='1') 레벨 2만 부모 메뉴로 선택 가능

📝 다음 단계:
- 카테고리 컴포넌트도 메뉴 스코프로 전환 예정

backend-node/src/controllers/numberingRuleController.ts

@@ -27,12 +27,24 @@ router.get("/available/:menuObjid?", authenticateToken, async (req: Authenticate
   const companyCode = req.user!.companyCode;
   const menuObjid = req.params.menuObjid ? parseInt(req.params.menuObjid) : undefined;
 
+  logger.info("📥 메뉴별 채번 규칙 조회 요청", { companyCode, menuObjid });
+
   try {
     const rules = await numberingRuleService.getAvailableRulesForMenu(companyCode, menuObjid);
+    
+    logger.info("✅ 메뉴별 채번 규칙 조회 성공 (컨트롤러)", { 
+      companyCode, 
+      menuObjid,
+      rulesCount: rules.length 
+    });
+    
     return res.json({ success: true, data: rules });
   } catch (error: any) {
-    logger.error("메뉴별 사용 가능한 규칙 조회 실패", {
+    logger.error("❌ 메뉴별 사용 가능한 규칙 조회 실패 (컨트롤러)", {
       error: error.message,
+      errorCode: error.code,
+      errorStack: error.stack,
+      companyCode,
       menuObjid,
     });
     return res.status(500).json({ success: false, error: error.message });

backend-node/src/controllers/tableCategoryValueController.ts

@@ -32,18 +32,31 @@ export const getCategoryColumns = async (req: AuthenticatedRequest, res: Respons
 
 /**
  * 카테고리 값 목록 조회 (메뉴 스코프 적용)
+ * 
+ * Query Parameters:
+ * - menuObjid: 메뉴 OBJID (선택사항, 제공 시 형제 메뉴의 카테고리 값 포함)
+ * - includeInactive: 비활성 값 포함 여부
  */
 export const getCategoryValues = async (req: AuthenticatedRequest, res: Response) => {
   try {
     const companyCode = req.user!.companyCode;
     const { tableName, columnName } = req.params;
     const includeInactive = req.query.includeInactive === "true";
+    const menuObjid = req.query.menuObjid ? Number(req.query.menuObjid) : undefined;
+
+    logger.info("카테고리 값 조회 요청", {
+      tableName,
+      columnName,
+      menuObjid,
+      companyCode,
+    });
 
     const values = await tableCategoryValueService.getCategoryValues(
       tableName,
       columnName,
       companyCode,
-      includeInactive
+      includeInactive,
+      menuObjid // ← menuObjid 전달
     );
 
     return res.json({
@@ -61,18 +74,37 @@ export const getCategoryValues = async (req: AuthenticatedRequest, res: Response
 };
 
 /**
- * 카테고리 값 추가
+ * 카테고리 값 추가 (메뉴 스코프)
+ * 
+ * Body:
+ * - menuObjid: 메뉴 OBJID (필수)
+ * - 나머지 카테고리 값 정보
  */
 export const addCategoryValue = async (req: AuthenticatedRequest, res: Response) => {
   try {
     const companyCode = req.user!.companyCode;
     const userId = req.user!.userId;
-    const value = req.body;
+    const { menuObjid, ...value } = req.body;
+
+    if (!menuObjid) {
+      return res.status(400).json({
+        success: false,
+        message: "menuObjid는 필수입니다",
+      });
+    }
+
+    logger.info("카테고리 값 추가 요청", {
+      tableName: value.tableName,
+      columnName: value.columnName,
+      menuObjid,
+      companyCode,
+    });
 
     const newValue = await tableCategoryValueService.addCategoryValue(
       value,
       companyCode,
-      userId
+      userId,
+      Number(menuObjid) // ← menuObjid 전달
     );
 
     return res.status(201).json({

backend-node/src/services/menuService.ts

@@ -0,0 +1,159 @@
+import { getPool } from "../database/db";
+import { logger } from "../utils/logger";
+
+/**
+ * 메뉴 관련 유틸리티 서비스
+ * 
+ * 메뉴 스코프 기반 데이터 공유를 위한 형제 메뉴 조회 기능 제공
+ */
+
+/**
+ * 메뉴의 형제 메뉴 OBJID 목록 조회
+ * (같은 부모를 가진 메뉴들)
+ * 
+ * 메뉴 스코프 규칙:
+ * - 같은 부모를 가진 형제 메뉴들은 카테고리/채번규칙을 공유
+ * - 최상위 메뉴(parent_obj_id = 0)는 자기 자신만 반환
+ * - 메뉴를 찾을 수 없으면 안전하게 자기 자신만 반환
+ * 
+ * @param menuObjid 현재 메뉴의 OBJID
+ * @returns 형제 메뉴 OBJID 배열 (자기 자신 포함, 정렬됨)
+ * 
+ * @example
+ * // 영업관리 (200)
+ * // ├── 고객관리 (201)
+ * // ├── 계약관리 (202)
+ * // └── 주문관리 (203)
+ * 
+ * await getSiblingMenuObjids(201);
+ * // 결과: [201, 202, 203] - 모두 같은 부모(200)를 가진 형제
+ */
+export async function getSiblingMenuObjids(menuObjid: number): Promise<number[]> {
+  const pool = getPool();
+
+  try {
+    logger.info("형제 메뉴 조회 시작", { menuObjid });
+
+    // 1. 현재 메뉴의 부모 찾기
+    const parentQuery = `
+      SELECT parent_obj_id FROM menu_info WHERE objid = $1
+    `;
+    const parentResult = await pool.query(parentQuery, [menuObjid]);
+
+    if (parentResult.rows.length === 0) {
+      logger.warn("메뉴를 찾을 수 없음, 자기 자신만 반환", { menuObjid });
+      return [menuObjid]; // 메뉴가 없으면 안전하게 자기 자신만 반환
+    }
+
+    const parentObjId = parentResult.rows[0].parent_obj_id;
+
+    if (!parentObjId || parentObjId === 0) {
+      // 최상위 메뉴인 경우 자기 자신만 반환
+      logger.info("최상위 메뉴 (형제 없음)", { menuObjid, parentObjId });
+      return [menuObjid];
+    }
+
+    // 2. 같은 부모를 가진 형제 메뉴들 조회
+    const siblingsQuery = `
+      SELECT objid FROM menu_info 
+      WHERE parent_obj_id = $1 
+      ORDER BY objid
+    `;
+    const siblingsResult = await pool.query(siblingsQuery, [parentObjId]);
+
+    const siblingObjids = siblingsResult.rows.map((row) => Number(row.objid));
+
+    logger.info("형제 메뉴 조회 완료", {
+      menuObjid,
+      parentObjId,
+      siblingCount: siblingObjids.length,
+      siblings: siblingObjids,
+    });
+
+    return siblingObjids;
+  } catch (error: any) {
+    logger.error("형제 메뉴 조회 실패", { 
+      menuObjid, 
+      error: error.message,
+      stack: error.stack 
+    });
+    // 에러 발생 시 안전하게 자기 자신만 반환
+    return [menuObjid];
+  }
+}
+
+/**
+ * 여러 메뉴의 형제 메뉴 OBJID 합집합 조회
+ * 
+ * 여러 메뉴에 속한 모든 형제 메뉴를 중복 제거하여 반환
+ * 
+ * @param menuObjids 메뉴 OBJID 배열
+ * @returns 모든 형제 메뉴 OBJID 배열 (중복 제거, 정렬됨)
+ * 
+ * @example
+ * // 서로 다른 부모를 가진 메뉴들의 형제를 모두 조회
+ * await getAllSiblingMenuObjids([201, 301]);
+ * // 201의 형제: [201, 202, 203]
+ * // 301의 형제: [301, 302]
+ * // 결과: [201, 202, 203, 301, 302]
+ */
+export async function getAllSiblingMenuObjids(
+  menuObjids: number[]
+): Promise<number[]> {
+  if (!menuObjids || menuObjids.length === 0) {
+    logger.warn("getAllSiblingMenuObjids: 빈 배열 입력");
+    return [];
+  }
+
+  const allSiblings = new Set<number>();
+
+  for (const objid of menuObjids) {
+    const siblings = await getSiblingMenuObjids(objid);
+    siblings.forEach((s) => allSiblings.add(s));
+  }
+
+  const result = Array.from(allSiblings).sort((a, b) => a - b);
+
+  logger.info("여러 메뉴의 형제 조회 완료", {
+    inputMenus: menuObjids,
+    resultCount: result.length,
+    result,
+  });
+
+  return result;
+}
+
+/**
+ * 메뉴 정보 조회
+ * 
+ * @param menuObjid 메뉴 OBJID
+ * @returns 메뉴 정보 (없으면 null)
+ */
+export async function getMenuInfo(menuObjid: number): Promise<any | null> {
+  const pool = getPool();
+
+  try {
+    const query = `
+      SELECT 
+        objid,
+        parent_obj_id AS "parentObjId",
+        menu_name_kor AS "menuNameKor",
+        menu_name_eng AS "menuNameEng",
+        menu_url AS "menuUrl",
+        company_code AS "companyCode"
+      FROM menu_info
+      WHERE objid = $1
+    `;
+    const result = await pool.query(query, [menuObjid]);
+
+    if (result.rows.length === 0) {
+      return null;
+    }
+
+    return result.rows[0];
+  } catch (error: any) {
+    logger.error("메뉴 정보 조회 실패", { menuObjid, error: error.message });
+    return null;
+  }
+}
+

backend-node/src/services/numberingRuleService.ts

@@ -4,6 +4,7 @@
 
 import { getPool } from "../database/db";
 import { logger } from "../utils/logger";
+import { getSiblingMenuObjids } from "./menuService";
 
 interface NumberingRulePart {
   id?: number;
@@ -150,22 +151,33 @@ class NumberingRuleService {
   }
 
   /**
-   * 현재 메뉴에서 사용 가능한 규칙 목록 조회
+   * 현재 메뉴에서 사용 가능한 규칙 목록 조회 (메뉴 스코프)
+   * 
+   * 메뉴 스코프 규칙:
+   * - menuObjid가 제공되면 형제 메뉴의 채번 규칙 포함
+   * - 우선순위: menu (형제 메뉴) > table > global
    */
   async getAvailableRulesForMenu(
     companyCode: string,
     menuObjid?: number
   ): Promise<NumberingRuleConfig[]> {
     try {
-      logger.info("메뉴별 사용 가능한 채번 규칙 조회 시작", {
+      logger.info("메뉴별 사용 가능한 채번 규칙 조회 시작 (메뉴 스코프)", {
         companyCode,
         menuObjid,
       });
 
       const pool = getPool();
 
+      // 1. 형제 메뉴 OBJID 조회
+      let siblingObjids: number[] = [];
+      if (menuObjid) {
+        siblingObjids = await getSiblingMenuObjids(menuObjid);
+        logger.info("형제 메뉴 OBJID 목록", { menuObjid, siblingObjids });
+      }
+
       // menuObjid가 없으면 global 규칙만 반환
-      if (!menuObjid) {
+      if (!menuObjid || siblingObjids.length === 0) {
         let query: string;
         let params: any[];
         
@@ -261,35 +273,13 @@ class NumberingRuleService {
         return result.rows;
       }
 
-      // 현재 메뉴의 상위 계층 조회 (2레벨 메뉴 찾기)
+      // 2. 메뉴 스코프: 형제 메뉴의 채번 규칙 조회
-      const menuHierarchyQuery = `
+      // 우선순위: menu (형제 메뉴) > table > global
-        WITH RECURSIVE menu_path AS (
-          SELECT objid, objid_parent, menu_level
-          FROM menu_info
-          WHERE objid = $1
-          
-          UNION ALL
-          
-          SELECT mi.objid, mi.objid_parent, mi.menu_level
-          FROM menu_info mi
-          INNER JOIN menu_path mp ON mi.objid = mp.objid_parent
-        )
-        SELECT objid, menu_level
-        FROM menu_path
-        WHERE menu_level = 2
-        LIMIT 1
-      `;
-
-      const hierarchyResult = await pool.query(menuHierarchyQuery, [menuObjid]);
-      const level2MenuObjid =
-        hierarchyResult.rowCount > 0 ? hierarchyResult.rows[0].objid : null;
-
-      // 사용 가능한 규칙 조회 (멀티테넌시 적용)
       let query: string;
       let params: any[];
       
       if (companyCode === "*") {
-        // 최고 관리자: 모든 규칙 조회
+        // 최고 관리자: 모든 규칙 조회 (형제 메뉴 포함)
         query = `
           SELECT 
             rule_id AS "ruleId",
@@ -309,12 +299,20 @@ class NumberingRuleService {
           FROM numbering_rules
           WHERE 
             scope_type = 'global'
-            OR (scope_type = 'menu' AND menu_objid = $1)
+            OR scope_type = 'table'
-          ORDER BY scope_type DESC, created_at DESC
+            OR (scope_type = 'menu' AND menu_objid = ANY($1))
+          ORDER BY 
+            CASE scope_type
+              WHEN 'menu' THEN 1
+              WHEN 'table' THEN 2
+              WHEN 'global' THEN 3
+            END,
+            created_at DESC
         `;
-        params = [level2MenuObjid];
+        params = [siblingObjids];
+        logger.info("최고 관리자: 형제 메뉴 포함 채번 규칙 조회", { siblingObjids });
       } else {
-        // 일반 회사: 자신의 규칙만 조회
+        // 일반 회사: 자신의 규칙만 조회 (형제 메뉴 포함)
         query = `
           SELECT 
             rule_id AS "ruleId",
@@ -335,58 +333,91 @@ class NumberingRuleService {
           WHERE company_code = $1
             AND (
               scope_type = 'global'
-              OR (scope_type = 'menu' AND menu_objid = $2)
+              OR scope_type = 'table'
+              OR (scope_type = 'menu' AND menu_objid = ANY($2))
             )
-          ORDER BY scope_type DESC, created_at DESC
+          ORDER BY 
+            CASE scope_type
+              WHEN 'menu' THEN 1
+              WHEN 'table' THEN 2
+              WHEN 'global' THEN 3
+            END,
+            created_at DESC
         `;
-        params = [companyCode, level2MenuObjid];
+        params = [companyCode, siblingObjids];
+        logger.info("회사별: 형제 메뉴 포함 채번 규칙 조회", { companyCode, siblingObjids });
       }
 
+      logger.info("🔍 채번 규칙 쿼리 실행", {
+        queryPreview: query.substring(0, 200),
+        paramsTypes: params.map(p => typeof p),
+        paramsValues: params,
+      });
+
       const result = await pool.query(query, params);
 
+      logger.info("✅ 채번 규칙 쿼리 성공", { rowCount: result.rows.length });
+
       // 파트 정보 추가
       for (const rule of result.rows) {
-        let partsQuery: string;
+        try {
-        let partsParams: any[];
+          let partsQuery: string;
+          let partsParams: any[];
           
-        if (companyCode === "*") {
+          if (companyCode === "*") {
-          partsQuery = `
+            partsQuery = `
-            SELECT 
+              SELECT 
-              id,
+                id,
-              part_order AS "order",
+                part_order AS "order",
-              part_type AS "partType",
+                part_type AS "partType",
-              generation_method AS "generationMethod",
+                generation_method AS "generationMethod",
-              auto_config AS "autoConfig",
+                auto_config AS "autoConfig",
-              manual_config AS "manualConfig"
+                manual_config AS "manualConfig"
-            FROM numbering_rule_parts
+              FROM numbering_rule_parts
-            WHERE rule_id = $1
+              WHERE rule_id = $1
-            ORDER BY part_order
+              ORDER BY part_order
-          `;
+            `;
-          partsParams = [rule.ruleId];
+            partsParams = [rule.ruleId];
-        } else {
+          } else {
-          partsQuery = `
+            partsQuery = `
-            SELECT 
+              SELECT 
-              id,
+                id,
-              part_order AS "order",
+                part_order AS "order",
-              part_type AS "partType",
+                part_type AS "partType",
-              generation_method AS "generationMethod",
+                generation_method AS "generationMethod",
-              auto_config AS "autoConfig",
+                auto_config AS "autoConfig",
-              manual_config AS "manualConfig"
+                manual_config AS "manualConfig"
-            FROM numbering_rule_parts
+              FROM numbering_rule_parts
-            WHERE rule_id = $1 AND company_code = $2
+              WHERE rule_id = $1 AND company_code = $2
-            ORDER BY part_order
+              ORDER BY part_order
-          `;
+            `;
-          partsParams = [rule.ruleId, companyCode];
+            partsParams = [rule.ruleId, companyCode];
+          }
+
+          const partsResult = await pool.query(partsQuery, partsParams);
+          rule.parts = partsResult.rows;
+          
+          logger.info("✅ 규칙 파트 조회 성공", {
+            ruleId: rule.ruleId,
+            ruleName: rule.ruleName,
+            partsCount: partsResult.rows.length,
+          });
+        } catch (partError: any) {
+          logger.error("❌ 규칙 파트 조회 실패", {
+            ruleId: rule.ruleId,
+            ruleName: rule.ruleName,
+            error: partError.message,
+            errorCode: partError.code,
+            errorStack: partError.stack,
+          });
+          throw partError;
         }
-
-        const partsResult = await pool.query(partsQuery, partsParams);
-        rule.parts = partsResult.rows;
       }
 
       logger.info("메뉴별 사용 가능한 채번 규칙 조회 완료", {
         companyCode,
         menuObjid,
-        level2MenuObjid,
+        siblingCount: siblingObjids.length,
         count: result.rowCount,
       });
 
@@ -394,8 +425,11 @@ class NumberingRuleService {
     } catch (error: any) {
       logger.error("메뉴별 채번 규칙 조회 실패", {
         error: error.message,
+        errorCode: error.code,
+        errorStack: error.stack,
         companyCode,
         menuObjid,
+        siblingObjids: siblingObjids || [],
       });
       throw error;
     }

backend-node/src/services/tableCategoryValueService.ts

@@ -1,5 +1,6 @@
 import { getPool } from "../database/db";
 import { logger } from "../utils/logger";
+import { getSiblingMenuObjids } from "./menuService";
 import {
   TableCategoryValue,
   CategoryColumn,
@@ -79,84 +80,164 @@ class TableCategoryValueService {
   }
 
   /**
-   * 특정 컬럼의 카테고리 값 목록 조회 (테이블 스코프)
+   * 특정 컬럼의 카테고리 값 목록 조회 (메뉴 스코프)
+   * 
+   * 메뉴 스코프 규칙:
+   * - menuObjid가 제공되면 해당 메뉴와 형제 메뉴의 카테고리 값을 조회
+   * - menuObjid가 없으면 테이블 스코프로 동작 (하위 호환성)
    */
   async getCategoryValues(
     tableName: string,
     columnName: string,
     companyCode: string,
-    includeInactive: boolean = false
+    includeInactive: boolean = false,
+    menuObjid?: number
   ): Promise<TableCategoryValue[]> {
     try {
-      logger.info("카테고리 값 목록 조회", {
+      logger.info("카테고리 값 목록 조회 (메뉴 스코프)", {
         tableName,
         columnName,
         companyCode,
         includeInactive,
+        menuObjid,
       });
 
       const pool = getPool();
       
-      // 멀티테넌시: 최고 관리자만 company_code="*" 데이터를 볼 수 있음
+      // 1. 메뉴 스코프: 형제 메뉴 OBJID 조회
+      let siblingObjids: number[] = [];
+      if (menuObjid) {
+        siblingObjids = await getSiblingMenuObjids(menuObjid);
+        logger.info("형제 메뉴 OBJID 목록", { menuObjid, siblingObjids });
+      }
+      
+      // 2. 카테고리 값 조회 (형제 메뉴 포함)
       let query: string;
       let params: any[];
       
       if (companyCode === "*") {
         // 최고 관리자: 모든 카테고리 값 조회
-        query = `
+        if (menuObjid && siblingObjids.length > 0) {
-          SELECT 
+          // 메뉴 스코프 적용
-            value_id AS "valueId",
+          query = `
-            table_name AS "tableName",
+            SELECT 
-            column_name AS "columnName",
+              value_id AS "valueId",
-            value_code AS "valueCode",
+              table_name AS "tableName",
-            value_label AS "valueLabel",
+              column_name AS "columnName",
-            value_order AS "valueOrder",
+              value_code AS "valueCode",
-            parent_value_id AS "parentValueId",
+              value_label AS "valueLabel",
-            depth,
+              value_order AS "valueOrder",
-            description,
+              parent_value_id AS "parentValueId",
-            color,
+              depth,
-            icon,
+              description,
-            is_active AS "isActive",
+              color,
-            is_default AS "isDefault",
+              icon,
-            company_code AS "companyCode",
+              is_active AS "isActive",
-            created_at AS "createdAt",
+              is_default AS "isDefault",
-            updated_at AS "updatedAt",
+              company_code AS "companyCode",
-            created_by AS "createdBy",
+              menu_objid AS "menuObjid",
-            updated_by AS "updatedBy"
+              created_at AS "createdAt",
-          FROM table_column_category_values
+              updated_at AS "updatedAt",
-          WHERE table_name = $1
+              created_by AS "createdBy",
-            AND column_name = $2
+              updated_by AS "updatedBy"
-        `;
+            FROM table_column_category_values
-        params = [tableName, columnName];
+            WHERE table_name = $1
+              AND column_name = $2
+              AND menu_objid = ANY($3)
+          `;
+          params = [tableName, columnName, siblingObjids];
+        } else {
+          // 테이블 스코프 (하위 호환성)
+          query = `
+            SELECT 
+              value_id AS "valueId",
+              table_name AS "tableName",
+              column_name AS "columnName",
+              value_code AS "valueCode",
+              value_label AS "valueLabel",
+              value_order AS "valueOrder",
+              parent_value_id AS "parentValueId",
+              depth,
+              description,
+              color,
+              icon,
+              is_active AS "isActive",
+              is_default AS "isDefault",
+              company_code AS "companyCode",
+              menu_objid AS "menuObjid",
+              created_at AS "createdAt",
+              updated_at AS "updatedAt",
+              created_by AS "createdBy",
+              updated_by AS "updatedBy"
+            FROM table_column_category_values
+            WHERE table_name = $1
+              AND column_name = $2
+          `;
+          params = [tableName, columnName];
+        }
         logger.info("최고 관리자 카테고리 값 조회");
       } else {
         // 일반 회사: 자신의 카테고리 값만 조회
-        query = `
+        if (menuObjid && siblingObjids.length > 0) {
-          SELECT 
+          // 메뉴 스코프 적용
-            value_id AS "valueId",
+          query = `
-            table_name AS "tableName",
+            SELECT 
-            column_name AS "columnName",
+              value_id AS "valueId",
-            value_code AS "valueCode",
+              table_name AS "tableName",
-            value_label AS "valueLabel",
+              column_name AS "columnName",
-            value_order AS "valueOrder",
+              value_code AS "valueCode",
-            parent_value_id AS "parentValueId",
+              value_label AS "valueLabel",
-            depth,
+              value_order AS "valueOrder",
-            description,
+              parent_value_id AS "parentValueId",
-            color,
+              depth,
-            icon,
+              description,
-            is_active AS "isActive",
+              color,
-            is_default AS "isDefault",
+              icon,
-            company_code AS "companyCode",
+              is_active AS "isActive",
-            created_at AS "createdAt",
+              is_default AS "isDefault",
-            updated_at AS "updatedAt",
+              company_code AS "companyCode",
-            created_by AS "createdBy",
+              menu_objid AS "menuObjid",
-            updated_by AS "updatedBy"
+              created_at AS "createdAt",
-          FROM table_column_category_values
+              updated_at AS "updatedAt",
-          WHERE table_name = $1
+              created_by AS "createdBy",
-            AND column_name = $2
+              updated_by AS "updatedBy"
-            AND company_code = $3
+            FROM table_column_category_values
-        `;
+            WHERE table_name = $1
-        params = [tableName, columnName, companyCode];
+              AND column_name = $2
+              AND menu_objid = ANY($3)
+              AND company_code = $4
+          `;
+          params = [tableName, columnName, siblingObjids, companyCode];
+        } else {
+          // 테이블 스코프 (하위 호환성)
+          query = `
+            SELECT 
+              value_id AS "valueId",
+              table_name AS "tableName",
+              column_name AS "columnName",
+              value_code AS "valueCode",
+              value_label AS "valueLabel",
+              value_order AS "valueOrder",
+              parent_value_id AS "parentValueId",
+              depth,
+              description,
+              color,
+              icon,
+              is_active AS "isActive",
+              is_default AS "isDefault",
+              company_code AS "companyCode",
+              menu_objid AS "menuObjid",
+              created_at AS "createdAt",
+              updated_at AS "updatedAt",
+              created_by AS "createdBy",
+              updated_by AS "updatedBy"
+            FROM table_column_category_values
+            WHERE table_name = $1
+              AND column_name = $2
+              AND company_code = $3
+          `;
+          params = [tableName, columnName, companyCode];
+        }
         logger.info("회사별 카테고리 값 조회", { companyCode });
       }
 
@@ -175,6 +256,8 @@ class TableCategoryValueService {
         tableName,
         columnName,
         companyCode,
+        menuObjid,
+        scopeType: menuObjid ? "menu" : "table",
       });
 
       return values;
@@ -185,17 +268,31 @@ class TableCategoryValueService {
   }
 
   /**
-   * 카테고리 값 추가
+   * 카테고리 값 추가 (메뉴 스코프)
+   * 
+   * @param value 카테고리 값 정보
+   * @param companyCode 회사 코드
+   * @param userId 생성자 ID
+   * @param menuObjid 메뉴 OBJID (필수)
    */
   async addCategoryValue(
     value: TableCategoryValue,
     companyCode: string,
-    userId: string
+    userId: string,
+    menuObjid: number
   ): Promise<TableCategoryValue> {
     const pool = getPool();
 
     try {
-      // 중복 코드 체크 (멀티테넌시 적용)
+      logger.info("카테고리 값 추가 (메뉴 스코프)", {
+        tableName: value.tableName,
+        columnName: value.columnName,
+        valueCode: value.valueCode,
+        menuObjid,
+        companyCode,
+      });
+
+      // 중복 코드 체크 (멀티테넌시 + 메뉴 스코프)
       let duplicateQuery: string;
       let duplicateParams: any[];
       
@@ -207,8 +304,9 @@ class TableCategoryValueService {
           WHERE table_name = $1
             AND column_name = $2
             AND value_code = $3
+            AND menu_objid = $4
         `;
-        duplicateParams = [value.tableName, value.columnName, value.valueCode];
+        duplicateParams = [value.tableName, value.columnName, value.valueCode, menuObjid];
       } else {
         // 일반 회사: 자신의 회사에서만 중복 체크
         duplicateQuery = `
@@ -217,9 +315,10 @@ class TableCategoryValueService {
           WHERE table_name = $1
             AND column_name = $2
             AND value_code = $3
-            AND company_code = $4
+            AND menu_objid = $4
+            AND company_code = $5
         `;
-        duplicateParams = [value.tableName, value.columnName, value.valueCode, companyCode];
+        duplicateParams = [value.tableName, value.columnName, value.valueCode, menuObjid, companyCode];
       }
 
       const duplicateResult = await pool.query(duplicateQuery, duplicateParams);
@@ -232,8 +331,8 @@ class TableCategoryValueService {
         INSERT INTO table_column_category_values (
           table_name, column_name, value_code, value_label, value_order,
           parent_value_id, depth, description, color, icon,
-          is_active, is_default, company_code, created_by
+          is_active, is_default, company_code, menu_objid, created_by
-        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)
+        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
         RETURNING 
           value_id AS "valueId",
           table_name AS "tableName",
@@ -249,6 +348,7 @@ class TableCategoryValueService {
           is_active AS "isActive",
           is_default AS "isDefault",
           company_code AS "companyCode",
+          menu_objid AS "menuObjid",
           created_at AS "createdAt",
           created_by AS "createdBy"
       `;
@@ -267,6 +367,7 @@ class TableCategoryValueService {
         value.isActive !== false,
         value.isDefault || false,
         companyCode,
+        menuObjid, // ← 메뉴 OBJID 저장
         userId,
       ]);
 
@@ -274,6 +375,7 @@ class TableCategoryValueService {
         valueId: result.rows[0].valueId,
         tableName: value.tableName,
         columnName: value.columnName,
+        menuObjid,
       });
 
       return result.rows[0];

frontend/app/(main)/screens/[screenId]/page.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import React, { useEffect, useState } from "react";
-import { useParams } from "next/navigation";
+import { useParams, useSearchParams } from "next/navigation";
 import { Button } from "@/components/ui/button";
 import { Loader2 } from "lucide-react";
 import { screenApi } from "@/lib/api/screen";
@@ -21,9 +21,13 @@ import { useResponsive } from "@/lib/hooks/useResponsive"; // 🆕 반응형 감
 
 export default function ScreenViewPage() {
   const params = useParams();
+  const searchParams = useSearchParams();
   const router = useRouter();
   const screenId = parseInt(params.screenId as string);
   
+  // URL 쿼리에서 menuObjid 가져오기 (메뉴 스코프)
+  const menuObjid = searchParams.get("menuObjid") ? parseInt(searchParams.get("menuObjid")!) : undefined;
+
   // 🆕 현재 로그인한 사용자 정보
   const { user, userName, companyCode } = useAuth();
 
@@ -404,6 +408,7 @@ export default function ScreenViewPage() {
                         userId={user?.userId}
                         userName={userName}
                         companyCode={companyCode}
+                        menuObjid={menuObjid}
                         selectedRowsData={selectedRowsData}
                         sortBy={tableSortBy}
                         sortOrder={tableSortOrder}

frontend/components/numbering-rule/NumberingRuleDesigner.tsx

@@ -26,6 +26,7 @@ interface NumberingRuleDesignerProps {
   isPreview?: boolean;
   className?: string;
   currentTableName?: string; // 현재 화면의 테이블명 (자동 감지용)
+  menuObjid?: number; // 현재 메뉴 OBJID (메뉴 스코프)
 }
 
 export const NumberingRuleDesigner: React.FC<NumberingRuleDesignerProps> = ({
@@ -36,6 +37,7 @@ export const NumberingRuleDesigner: React.FC<NumberingRuleDesignerProps> = ({
   isPreview = false,
   className = "",
   currentTableName,
+  menuObjid,
 }) => {
   const [savedRules, setSavedRules] = useState<NumberingRuleConfig[]>([]);
   const [selectedRuleId, setSelectedRuleId] = useState<string | null>(null);
@@ -53,7 +55,7 @@ export const NumberingRuleDesigner: React.FC<NumberingRuleDesignerProps> = ({
   const loadRules = useCallback(async () => {
     setLoading(true);
     try {
-      const response = await getNumberingRules();
+      const response = await getNumberingRules(menuObjid);
       if (response.success && response.data) {
         setSavedRules(response.data);
       } else {
@@ -64,7 +66,7 @@ export const NumberingRuleDesigner: React.FC<NumberingRuleDesignerProps> = ({
     } finally {
       setLoading(false);
     }
-  }, []);
+  }, [menuObjid]);
 
   useEffect(() => {
     if (currentRule) {
@@ -145,7 +147,7 @@ export const NumberingRuleDesigner: React.FC<NumberingRuleDesignerProps> = ({
         "currentRule.tableName": currentRule.tableName,
         "ruleToSave.tableName": ruleToSave.tableName,
         "ruleToSave.scopeType": ruleToSave.scopeType,
-        ruleToSave
+        ruleToSave,
       });
 
       let response;
@@ -273,7 +275,7 @@ export const NumberingRuleDesigner: React.FC<NumberingRuleDesignerProps> = ({
             savedRules.map((rule) => (
               <Card
                 key={rule.ruleId}
-                className={`py-2 border-border hover:bg-accent cursor-pointer transition-colors ${
+                className={`border-border hover:bg-accent cursor-pointer py-2 transition-colors ${
                   selectedRuleId === rule.ruleId ? "border-primary bg-primary/5" : "bg-card"
                 }`}
                 onClick={() => handleSelectRule(rule)}
@@ -356,7 +358,7 @@ export const NumberingRuleDesigner: React.FC<NumberingRuleDesignerProps> = ({
               {currentTableName && (
                 <div className="space-y-2">
                   <Label className="text-sm font-medium">적용 테이블</Label>
-                  <div className="flex h-9 items-center rounded-md border border-input bg-muted px-3 text-sm text-muted-foreground">
+                  <div className="border-input bg-muted text-muted-foreground flex h-9 items-center rounded-md border px-3 text-sm">
                     {currentTableName}
                   </div>
                   <p className="text-muted-foreground text-xs">

frontend/components/screen/RealtimePreviewDynamic.tsx

@@ -41,6 +41,7 @@ interface RealtimePreviewProps {
   userId?: string; // 🆕 현재 사용자 ID
   userName?: string; // 🆕 현재 사용자 이름
   companyCode?: string; // 🆕 현재 사용자의 회사 코드
+  menuObjid?: number; // 🆕 현재 메뉴 OBJID (메뉴 스코프)
   selectedRowsData?: any[];
   onSelectedRowsChange?: (selectedRows: any[], selectedRowsData: any[]) => void;
   flowSelectedData?: any[];
@@ -107,6 +108,7 @@ export const RealtimePreviewDynamic: React.FC<RealtimePreviewProps> = ({
   userId, // 🆕 사용자 ID
   userName, // 🆕 사용자 이름
   companyCode, // 🆕 회사 코드
+  menuObjid, // 🆕 메뉴 OBJID
   selectedRowsData,
   onSelectedRowsChange,
   flowSelectedData,
@@ -344,6 +346,7 @@ export const RealtimePreviewDynamic: React.FC<RealtimePreviewProps> = ({
           userId={userId}
           userName={userName}
           companyCode={companyCode}
+          menuObjid={menuObjid}
           selectedRowsData={selectedRowsData}
           onSelectedRowsChange={onSelectedRowsChange}
           flowSelectedData={flowSelectedData}

frontend/components/screen/panels/webtype-configs/TextTypeConfigPanel.tsx

@@ -14,7 +14,7 @@ interface TextTypeConfigPanelProps {
   config: TextTypeConfig;
   onConfigChange: (config: TextTypeConfig) => void;
   tableName?: string; // 화면의 테이블명 (선택)
-  menuObjid?: number; // 메뉴 objid (선택)
+  menuObjid?: number; // 메뉴 objid (선택) - 사용자가 선택한 부모 메뉴
 }
 
 export const TextTypeConfigPanel: React.FC<TextTypeConfigPanelProps> = ({
@@ -45,6 +45,10 @@ export const TextTypeConfigPanel: React.FC<TextTypeConfigPanelProps> = ({
   const [numberingRules, setNumberingRules] = useState<NumberingRuleConfig[]>([]);
   const [loadingRules, setLoadingRules] = useState(false);
   
+  // 부모 메뉴 목록 상태 (채번규칙 사용을 위한 선택)
+  const [parentMenus, setParentMenus] = useState<any[]>([]);
+  const [selectedMenuObjid, setSelectedMenuObjid] = useState<number | undefined>(menuObjid);
+
   // 로컬 상태로 실시간 입력 관리
   const [localValues, setLocalValues] = useState({
     minLength: safeConfig.minLength?.toString() || "",
@@ -60,31 +64,61 @@ export const TextTypeConfigPanel: React.FC<TextTypeConfigPanelProps> = ({
     numberingRuleId: safeConfig.numberingRuleId,
   });
 
-  // 채번 규칙 목록 로드
+  // 부모 메뉴 목록 로드 (최상위 메뉴 또는 레벨 2 메뉴)
+  useEffect(() => {
+    const loadParentMenus = async () => {
+      try {
+        const { apiClient } = await import("@/lib/api/client");
+        
+        // 관리자 메뉴와 사용자 메뉴 모두 가져오기
+        const [adminResponse, userResponse] = await Promise.all([
+          apiClient.get("/admin/menus", { params: { menuType: "0" } }),
+          apiClient.get("/admin/menus", { params: { menuType: "1" } })
+        ]);
+        
+        const allMenus = [
+          ...(adminResponse.data?.data || []),
+          ...(userResponse.data?.data || [])
+        ];
+        
+        // 레벨 2 이하 메뉴만 선택 가능 (부모가 있는 메뉴)
+        const parentMenuList = allMenus.filter((menu: any) => {
+          const level = menu.lev || menu.LEV || 0;
+          return level >= 2; // 레벨 2 이상만 표시 (형제 메뉴가 있을 가능성)
+        });
+        
+        setParentMenus(parentMenuList);
+        console.log("✅ 부모 메뉴 목록 로드:", parentMenuList.length);
+      } catch (error) {
+        console.error("❌ 부모 메뉴 목록 로드 실패:", error);
+      }
+    };
+    
+    loadParentMenus();
+  }, []);
+  
+  // 채번 규칙 목록 로드 (선택된 메뉴 기준)
   useEffect(() => {
     const loadRules = async () => {
       console.log("🔄 채번 규칙 로드 시작:", {
         autoValueType: localValues.autoValueType,
+        selectedMenuObjid,
         tableName,
-        hasTableName: !!tableName,
       });
       
+      // 메뉴를 선택하지 않으면 로드하지 않음
+      if (!selectedMenuObjid) {
+        console.warn("⚠️ 메뉴를 선택해야 채번 규칙을 조회할 수 있습니다");
+        setNumberingRules([]);
+        return;
+      }
+      
       setLoadingRules(true);
       try {
-        let response;
+        // 선택된 메뉴의 채번 규칙 조회 (메뉴 스코프)
-
+        console.log("📋 메뉴 기반 채번 규칙 조회 API 호출:", { menuObjid: selectedMenuObjid });
-        // 테이블명이 있으면 테이블 기반 필터링 사용
+        const response = await getAvailableNumberingRules(selectedMenuObjid);
-        if (tableName) {
+        console.log("📋 API 응답:", response);
-          console.log("📋 테이블 기반 채번 규칙 조회 API 호출:", { tableName });
-          response = await getAvailableNumberingRulesForScreen(tableName);
-          console.log("📋 API 응답:", response);
-        } else {
-          // 테이블명이 없으면 빈 배열 (테이블 필수)
-          console.warn("⚠️ 테이블명이 없어 채번 규칙을 조회할 수 없습니다");
-          setNumberingRules([]);
-          setLoadingRules(false);
-          return;
-        }
 
         if (response.success && response.data) {
           setNumberingRules(response.data);
@@ -93,7 +127,7 @@ export const TextTypeConfigPanel: React.FC<TextTypeConfigPanelProps> = ({
             rules: response.data.map((r: any) => ({
               ruleId: r.ruleId,
               ruleName: r.ruleName,
-              tableName: r.tableName,
+              menuObjid: selectedMenuObjid,
             })),
           });
         } else {
@@ -115,7 +149,7 @@ export const TextTypeConfigPanel: React.FC<TextTypeConfigPanelProps> = ({
     } else {
       console.log("⏭️ autoValueType !== 'numbering_rule', 규칙 로드 스킵:", localValues.autoValueType);
     }
-  }, [localValues.autoValueType, tableName]);
+  }, [localValues.autoValueType, selectedMenuObjid]);
 
   // config가 변경될 때 로컬 상태 동기화
   useEffect(() => {
@@ -314,37 +348,95 @@ export const TextTypeConfigPanel: React.FC<TextTypeConfigPanelProps> = ({
               </Select>
             </div>
 
+            {(() => {
+              console.log("🔍 메뉴 선택 UI 렌더링 체크:", {
+                autoValueType: localValues.autoValueType,
+                isNumberingRule: localValues.autoValueType === "numbering_rule",
+                parentMenusCount: parentMenus.length,
+                selectedMenuObjid,
+              });
+              return null;
+            })()}
+            
             {localValues.autoValueType === "numbering_rule" && (
-              <div>
+              <>
-                <Label htmlFor="numberingRuleId" className="text-sm font-medium">
+                {/* 부모 메뉴 선택 */}
-                  채번 규칙 선택 <span className="text-destructive">*</span>
+                <div>
-                </Label>
+                  <Label htmlFor="parentMenu" className="text-sm font-medium">
-                <Select
+                    대상 메뉴 선택 <span className="text-destructive">*</span>
-                  value={localValues.numberingRuleId}
+                  </Label>
-                  onValueChange={(value) => updateConfig("numberingRuleId", value)}
+                  <Select
-                  disabled={loadingRules}
+                    value={selectedMenuObjid?.toString() || ""}
-                >
+                    onValueChange={(value) => setSelectedMenuObjid(parseInt(value))}
-                  <SelectTrigger className="mt-1 h-6 w-full px-2 py-0 text-xs" style={{ fontSize: "12px" }}>
+                  >
-                    <SelectValue placeholder={loadingRules ? "규칙 로딩 중..." : "채번 규칙 선택"} />
+                    <SelectTrigger className="mt-1 h-8 w-full px-2 py-0 text-xs">
-                  </SelectTrigger>
+                      <SelectValue placeholder="채번 규칙을 사용할 메뉴 선택" />
-                  <SelectContent>
+                    </SelectTrigger>
-                    {numberingRules.length === 0 ? (
+                    <SelectContent>
-                      <SelectItem value="no-rules" disabled>
+                      {parentMenus.length === 0 ? (
-                        사용 가능한 규칙이 없습니다
+                        <SelectItem value="no-menus" disabled>
-                      </SelectItem>
+                          사용 가능한 메뉴가 없습니다
-                    ) : (
-                      numberingRules.map((rule) => (
-                        <SelectItem key={rule.ruleId} value={rule.ruleId}>
-                          {rule.ruleName} ({rule.ruleId})
                         </SelectItem>
-                      ))
+                      ) : (
-                    )}
+                        parentMenus.map((menu) => {
-                  </SelectContent>
+                          const objid = menu.objid || menu.OBJID;
-                </Select>
+                          const menuName = menu.menu_name_kor || menu.MENU_NAME_KOR;
-                <p className="text-muted-foreground mt-1 text-[10px]">
+                          return (
-                  현재 메뉴에서 사용 가능한 채번 규칙만 표시됩니다
+                            <SelectItem key={objid} value={objid.toString()}>
-                </p>
+                              {menuName}
-              </div>
+                            </SelectItem>
+                          );
+                        })
+                      )}
+                    </SelectContent>
+                  </Select>
+                  <p className="text-muted-foreground mt-1 text-[10px]">
+                    이 필드가 어느 메뉴에서 사용될 것인지 선택하세요
+                  </p>
+                </div>
+
+                {/* 채번 규칙 선택 */}
+                <div>
+                  <Label htmlFor="numberingRuleId" className="text-sm font-medium">
+                    채번 규칙 선택 <span className="text-destructive">*</span>
+                  </Label>
+                  <Select
+                    value={localValues.numberingRuleId}
+                    onValueChange={(value) => updateConfig("numberingRuleId", value)}
+                    disabled={loadingRules || !selectedMenuObjid}
+                  >
+                    <SelectTrigger className="mt-1 h-8 w-full px-2 py-0 text-xs">
+                      <SelectValue 
+                        placeholder={
+                          !selectedMenuObjid 
+                            ? "먼저 메뉴를 선택하세요" 
+                            : loadingRules 
+                            ? "규칙 로딩 중..." 
+                            : "채번 규칙 선택"
+                        } 
+                      />
+                    </SelectTrigger>
+                    <SelectContent>
+                      {numberingRules.length === 0 ? (
+                        <SelectItem value="no-rules" disabled>
+                          {!selectedMenuObjid 
+                            ? "메뉴를 먼저 선택하세요" 
+                            : "사용 가능한 규칙이 없습니다"}
+                        </SelectItem>
+                      ) : (
+                        numberingRules.map((rule) => (
+                          <SelectItem key={rule.ruleId} value={rule.ruleId}>
+                            {rule.ruleName} ({rule.ruleId})
+                          </SelectItem>
+                        ))
+                      )}
+                    </SelectContent>
+                  </Select>
+                  <p className="text-muted-foreground mt-1 text-[10px]">
+                    선택한 메뉴와 형제 메뉴에서 사용 가능한 채번 규칙만 표시됩니다
+                  </p>
+                </div>
+              </>
             )}
 
             {localValues.autoValueType === "custom" && (

frontend/components/screen/widgets/CategoryWidget.tsx

@@ -8,14 +8,15 @@ import { GripVertical } from "lucide-react";
 interface CategoryWidgetProps {
   widgetId: string;
   tableName: string; // 현재 화면의 테이블
+  menuObjid?: number; // 현재 메뉴 OBJID (메뉴 스코프)
 }
 
 /**
  * 카테고리 관리 위젯 (좌우 분할)
  * - 좌측: 현재 테이블의 카테고리 타입 컬럼 목록
- * - 우측: 선택된 컬럼의 카테고리 값 관리 (테이블 스코프)
+ * - 우측: 선택된 컬럼의 카테고리 값 관리 (메뉴 스코프)
  */
-export function CategoryWidget({ widgetId, tableName }: CategoryWidgetProps) {
+export function CategoryWidget({ widgetId, tableName, menuObjid }: CategoryWidgetProps) {
   const [selectedColumn, setSelectedColumn] = useState<{
     columnName: string;
     columnLabel: string;
@@ -69,6 +70,7 @@ export function CategoryWidget({ widgetId, tableName }: CategoryWidgetProps) {
           onColumnSelect={(columnName, columnLabel) =>
             setSelectedColumn({ columnName, columnLabel })
           }
+          menuObjid={menuObjid}
         />
       </div>
 
@@ -87,6 +89,7 @@ export function CategoryWidget({ widgetId, tableName }: CategoryWidgetProps) {
             tableName={tableName}
             columnName={selectedColumn.columnName}
             columnLabel={selectedColumn.columnLabel}
+            menuObjid={menuObjid}
           />
         ) : (
           <div className="flex h-64 flex-col items-center justify-center rounded-lg border bg-card shadow-sm">

frontend/components/table-category/CategoryColumnList.tsx

@@ -16,13 +16,14 @@ interface CategoryColumnListProps {
   tableName: string;
   selectedColumn: string | null;
   onColumnSelect: (columnName: string, columnLabel: string) => void;
+  menuObjid?: number; // 현재 메뉴 OBJID (메뉴 스코프)
 }
 
 /**
  * 카테고리 컬럼 목록 (좌측 패널)
- * - 현재 테이블에서 input_type='category'인 컬럼들을 표시 (테이블 스코프)
+ * - 현재 테이블에서 input_type='category'인 컬럼들을 표시 (메뉴 스코프)
  */
-export function CategoryColumnList({ tableName, selectedColumn, onColumnSelect }: CategoryColumnListProps) {
+export function CategoryColumnList({ tableName, selectedColumn, onColumnSelect, menuObjid }: CategoryColumnListProps) {
   const [columns, setColumns] = useState<CategoryColumn[]>([]);
   const [isLoading, setIsLoading] = useState(false);
 
@@ -89,7 +90,7 @@ export function CategoryColumnList({ tableName, selectedColumn, onColumnSelect }
           // 각 컬럼의 값 개수 가져오기
           let valueCount = 0;
           try {
-            const valuesResult = await getCategoryValues(tableName, colName, false);
+            const valuesResult = await getCategoryValues(tableName, colName, false, menuObjid);
             if (valuesResult.success && valuesResult.data) {
               valueCount = valuesResult.data.length;
             }

frontend/components/table-category/CategoryValueManager.tsx

@@ -29,6 +29,7 @@ interface CategoryValueManagerProps {
   columnName: string;
   columnLabel: string;
   onValueCountChange?: (count: number) => void;
+  menuObjid?: number; // 현재 메뉴 OBJID (메뉴 스코프)
 }
 
 export const CategoryValueManager: React.FC<CategoryValueManagerProps> = ({
@@ -36,6 +37,7 @@ export const CategoryValueManager: React.FC<CategoryValueManagerProps> = ({
   columnName,
   columnLabel,
   onValueCountChange,
+  menuObjid,
 }) => {
   const { toast } = useToast();
   const [values, setValues] = useState<TableCategoryValue[]>([]);
@@ -81,7 +83,7 @@ export const CategoryValueManager: React.FC<CategoryValueManagerProps> = ({
     setIsLoading(true);
     try {
       // includeInactive: true로 비활성 값도 포함
-      const response = await getCategoryValues(tableName, columnName, true);
+      const response = await getCategoryValues(tableName, columnName, true, menuObjid);
       if (response.success && response.data) {
         setValues(response.data);
         setFilteredValues(response.data);
@@ -101,11 +103,23 @@ export const CategoryValueManager: React.FC<CategoryValueManagerProps> = ({
 
   const handleAddValue = async (newValue: TableCategoryValue) => {
     try {
-      const response = await addCategoryValue({
+      if (!menuObjid) {
-        ...newValue,
+        toast({
-        tableName,
+          title: "오류",
-        columnName,
+          description: "메뉴 정보가 없습니다. 카테고리 값을 추가할 수 없습니다.",
-      });
+          variant: "destructive",
+        });
+        return;
+      }
+
+      const response = await addCategoryValue(
+        {
+          ...newValue,
+          tableName,
+          columnName,
+        },
+        menuObjid
+      );
 
       if (response.success && response.data) {
         await loadCategoryValues();
@@ -128,7 +142,7 @@ export const CategoryValueManager: React.FC<CategoryValueManagerProps> = ({
         title: "오류",
         description: error.message || "카테고리 값 추가에 실패했습니다",
         variant: "destructive",
-      });
+        });
     }
   };
 

frontend/lib/api/tableCategoryValue.ts

@@ -21,19 +21,30 @@ export async function getCategoryColumns(tableName: string) {
 }
 
 /**
- * 카테고리 값 목록 조회 (테이블 스코프)
+ * 카테고리 값 목록 조회 (메뉴 스코프)
+ * 
+ * @param tableName 테이블명
+ * @param columnName 컬럼명
+ * @param includeInactive 비활성 값 포함 여부
+ * @param menuObjid 메뉴 OBJID (선택사항, 제공 시 형제 메뉴의 카테고리 값 포함)
  */
 export async function getCategoryValues(
   tableName: string,
   columnName: string,
-  includeInactive: boolean = false
+  includeInactive: boolean = false,
+  menuObjid?: number
 ) {
   try {
+    const params: any = { includeInactive };
+    if (menuObjid) {
+      params.menuObjid = menuObjid;
+    }
+
     const response = await apiClient.get<{
       success: boolean;
       data: TableCategoryValue[];
     }>(`/table-categories/${tableName}/${columnName}/values`, {
-      params: { includeInactive },
+      params,
     });
     return response.data;
   } catch (error: any) {
@@ -43,14 +54,23 @@ export async function getCategoryValues(
 }
 
 /**
- * 카테고리 값 추가
+ * 카테고리 값 추가 (메뉴 스코프)
+ * 
+ * @param value 카테고리 값 정보
+ * @param menuObjid 메뉴 OBJID (필수)
  */
-export async function addCategoryValue(value: TableCategoryValue) {
+export async function addCategoryValue(
+  value: TableCategoryValue,
+  menuObjid: number
+) {
   try {
     const response = await apiClient.post<{
       success: boolean;
       data: TableCategoryValue;
-    }>("/table-categories/values", value);
+    }>("/table-categories/values", {
+      ...value,
+      menuObjid, // ← menuObjid 포함
+    });
     return response.data;
   } catch (error: any) {
     console.error("카테고리 값 추가 실패:", error);

frontend/lib/registry/DynamicComponentRenderer.tsx

@@ -98,6 +98,7 @@ export interface DynamicComponentRendererProps {
   screenId?: number;
   tableName?: string;
   menuId?: number; // 🆕 메뉴 ID (카테고리 관리 등에 필요)
+  menuObjid?: number; // 🆕 메뉴 OBJID (메뉴 스코프 - 카테고리/채번)
   selectedScreen?: any; // 🆕 화면 정보 전체 (menuId 등 추출용)
   userId?: string; // 🆕 현재 사용자 ID
   userName?: string; // 🆕 현재 사용자 이름
@@ -224,6 +225,7 @@ export const DynamicComponentRenderer: React.FC<DynamicComponentRendererProps> =
           onFormDataChange,
           tableName,
           menuId, // 🆕 메뉴 ID
+          menuObjid, // 🆕 메뉴 OBJID (메뉴 스코프)
           selectedScreen, // 🆕 화면 정보
           onRefresh,
           onClose,
@@ -319,6 +321,7 @@ export const DynamicComponentRenderer: React.FC<DynamicComponentRendererProps> =
           onChange: handleChange, // 개선된 onChange 핸들러 전달
           tableName,
           menuId, // 🆕 메뉴 ID
+          menuObjid, // 🆕 메뉴 OBJID (메뉴 스코프)
           selectedScreen, // 🆕 화면 정보
           onRefresh,
           onClose,

frontend/lib/registry/components/text-input/TextInputConfigPanel.tsx

@@ -15,32 +15,65 @@ export interface TextInputConfigPanelProps {
   config: TextInputConfig;
   onChange: (config: Partial<TextInputConfig>) => void;
   screenTableName?: string; // 🆕 현재 화면의 테이블명
+  menuObjid?: number; // 🆕 메뉴 OBJID (사용자 선택)
 }
 
 /**
  * TextInput 설정 패널
  * 컴포넌트의 설정값들을 편집할 수 있는 UI 제공
  */
-export const TextInputConfigPanel: React.FC<TextInputConfigPanelProps> = ({ config, onChange, screenTableName }) => {
+export const TextInputConfigPanel: React.FC<TextInputConfigPanelProps> = ({ config, onChange, screenTableName, menuObjid }) => {
   // 채번 규칙 목록 상태
   const [numberingRules, setNumberingRules] = useState<NumberingRuleConfig[]>([]);
   const [loadingRules, setLoadingRules] = useState(false);
   
-  // 채번 규칙 목록 로드
+  // 부모 메뉴 목록 상태 (채번규칙 사용을 위한 선택)
+  const [parentMenus, setParentMenus] = useState<any[]>([]);
+  const [selectedMenuObjid, setSelectedMenuObjid] = useState<number | undefined>(menuObjid);
+  const [loadingMenus, setLoadingMenus] = useState(false);
+
+  // 부모 메뉴 목록 로드 (사용자 메뉴의 레벨 2만)
+  useEffect(() => {
+    const loadMenus = async () => {
+      setLoadingMenus(true);
+      try {
+        const { apiClient } = await import("@/lib/api/client");
+        const response = await apiClient.get("/admin/menus");
+        
+        if (response.data.success && response.data.data) {
+          const allMenus = response.data.data;
+          
+          // 사용자 메뉴(menu_type='1')의 레벨 2만 필터링
+          const level2UserMenus = allMenus.filter((menu: any) => 
+            menu.menu_type === '1' && menu.lev === 2
+          );
+          
+          setParentMenus(level2UserMenus);
+          console.log("✅ 부모 메뉴 로드 완료:", level2UserMenus.length, "개", level2UserMenus);
+        }
+      } catch (error) {
+        console.error("부모 메뉴 로드 실패:", error);
+      } finally {
+        setLoadingMenus(false);
+      }
+    };
+    loadMenus();
+  }, []);
+
+  // 채번 규칙 목록 로드 (선택된 메뉴 기준)
   useEffect(() => {
     const loadRules = async () => {
+      // 메뉴가 선택되지 않았으면 로드하지 않음
+      if (!selectedMenuObjid) {
+        console.log("⚠️ 메뉴가 선택되지 않아 채번 규칙을 로드하지 않습니다");
+        setNumberingRules([]);
+        return;
+      }
+      
       setLoadingRules(true);
       try {
-        let response;
+        console.log("🔍 선택된 메뉴 기반 채번 규칙 로드", { selectedMenuObjid });
-        
+        const response = await getAvailableNumberingRules(selectedMenuObjid);
-        // 🆕 테이블명이 있으면 테이블 기반 필터링, 없으면 전체 조회
-        if (screenTableName) {
-          console.log("🔍 TextInputConfigPanel: 테이블 기반 채번 규칙 로드", { screenTableName });
-          response = await getAvailableNumberingRulesForScreen(screenTableName);
-        } else {
-          console.log("🔍 TextInputConfigPanel: 전체 채번 규칙 로드 (테이블명 없음)");
-          response = await getAvailableNumberingRules();
-        }
         
         if (response.success && response.data) {
           setNumberingRules(response.data);
@@ -48,6 +81,7 @@ export const TextInputConfigPanel: React.FC<TextInputConfigPanelProps> = ({ conf
         }
       } catch (error) {
         console.error("채번 규칙 목록 로드 실패:", error);
+        setNumberingRules([]);
       } finally {
         setLoadingRules(false);
       }
@@ -57,7 +91,7 @@ export const TextInputConfigPanel: React.FC<TextInputConfigPanelProps> = ({ conf
     if (config.autoGeneration?.type === "numbering_rule") {
       loadRules();
     }
-  }, [config.autoGeneration?.type, screenTableName]);
+  }, [config.autoGeneration?.type, selectedMenuObjid]);
 
   const handleChange = (key: keyof TextInputConfig, value: any) => {
     onChange({ [key]: value });
@@ -157,50 +191,100 @@ export const TextInputConfigPanel: React.FC<TextInputConfigPanelProps> = ({ conf
 
             {/* 채번 규칙 선택 */}
             {config.autoGeneration?.type === "numbering_rule" && (
-              <div className="space-y-2">
+              <>
-                <Label htmlFor="numberingRuleId">
+                {/* 부모 메뉴 선택 */}
-                  채번 규칙 선택 <span className="text-destructive">*</span>
+                <div className="space-y-2">
-                </Label>
+                  <Label htmlFor="targetMenu">
-                <Select
+                    대상 메뉴 선택 <span className="text-destructive">*</span>
-                  value={config.autoGeneration?.options?.numberingRuleId || ""}
+                  </Label>
-                  onValueChange={(value) => {
+                  <Select
-                    const currentConfig = config.autoGeneration!;
+                    value={selectedMenuObjid?.toString() || ""}
-                    handleChange("autoGeneration", {
+                    onValueChange={(value) => {
-                      ...currentConfig,
+                      const menuObjid = parseInt(value);
-                      options: {
+                      setSelectedMenuObjid(menuObjid);
-                        ...currentConfig.options,
+                      console.log("✅ 메뉴 선택됨:", menuObjid);
-                        numberingRuleId: value,
+                    }}
-                      },
+                    disabled={loadingMenus}
-                    });
+                  >
-                  }}
+                    <SelectTrigger>
-                  disabled={loadingRules}
+                      <SelectValue placeholder={loadingMenus ? "메뉴 로딩 중..." : "채번규칙을 사용할 메뉴 선택"} />
-                >
+                    </SelectTrigger>
-                  <SelectTrigger>
+                    <SelectContent>
-                    <SelectValue placeholder={loadingRules ? "규칙 로딩 중..." : "채번 규칙 선택"} />
+                      {parentMenus.length === 0 ? (
-                  </SelectTrigger>
+                        <SelectItem value="no-menus" disabled>
-                  <SelectContent>
+                          사용 가능한 메뉴가 없습니다
-                    {numberingRules.length === 0 ? (
-                      <SelectItem value="no-rules" disabled>
-                        사용 가능한 규칙이 없습니다
-                      </SelectItem>
-                    ) : (
-                      numberingRules.map((rule) => (
-                        <SelectItem key={rule.ruleId} value={rule.ruleId}>
-                          {rule.ruleName}
-                          {rule.description && (
-                            <span className="text-muted-foreground ml-2 text-xs">
-                              - {rule.description}
-                            </span>
-                          )}
                         </SelectItem>
-                      ))
+                      ) : (
-                    )}
+                        parentMenus.map((menu) => (
-                  </SelectContent>
+                          <SelectItem key={menu.objid} value={menu.objid.toString()}>
-                </Select>
+                            {menu.menu_name_kor}
-                <p className="text-muted-foreground text-xs">
+                            {menu.menu_name_eng && (
-                  현재 메뉴에서 사용 가능한 채번 규칙만 표시됩니다
+                              <span className="text-muted-foreground ml-2 text-xs">
-                </p>
+                                ({menu.menu_name_eng})
-              </div>
+                              </span>
+                            )}
+                          </SelectItem>
+                        ))
+                      )}
+                    </SelectContent>
+                  </Select>
+                  <p className="text-muted-foreground text-xs">
+                    이 입력 필드가 어느 메뉴에 속할지 선택하세요 (해당 메뉴의 채번규칙이 적용됩니다)
+                  </p>
+                </div>
+
+                {/* 채번 규칙 선택 (메뉴 선택 후) */}
+                {selectedMenuObjid ? (
+                  <div className="space-y-2">
+                    <Label htmlFor="numberingRuleId">
+                      채번 규칙 선택 <span className="text-destructive">*</span>
+                    </Label>
+                    <Select
+                      value={config.autoGeneration?.options?.numberingRuleId || ""}
+                      onValueChange={(value) => {
+                        const currentConfig = config.autoGeneration!;
+                        handleChange("autoGeneration", {
+                          ...currentConfig,
+                          options: {
+                            ...currentConfig.options,
+                            numberingRuleId: value,
+                          },
+                        });
+                      }}
+                      disabled={loadingRules}
+                    >
+                      <SelectTrigger>
+                        <SelectValue placeholder={loadingRules ? "규칙 로딩 중..." : "채번 규칙 선택"} />
+                      </SelectTrigger>
+                      <SelectContent>
+                        {numberingRules.length === 0 ? (
+                          <SelectItem value="no-rules" disabled>
+                            선택된 메뉴에 사용 가능한 규칙이 없습니다
+                          </SelectItem>
+                        ) : (
+                          numberingRules.map((rule) => (
+                            <SelectItem key={rule.ruleId} value={rule.ruleId}>
+                              {rule.ruleName}
+                              {rule.description && (
+                                <span className="text-muted-foreground ml-2 text-xs">
+                                  - {rule.description}
+                                </span>
+                              )}
+                            </SelectItem>
+                          ))
+                        )}
+                      </SelectContent>
+                    </Select>
+                    <p className="text-muted-foreground text-xs">
+                      선택된 메뉴 및 형제 메뉴에서 사용 가능한 채번 규칙만 표시됩니다
+                    </p>
+                  </div>
+                ) : (
+                  <div className="rounded-md border border-amber-200 bg-amber-50 p-3 text-sm text-amber-800">
+                    먼저 대상 메뉴를 선택하세요
+                  </div>
+                )}
+              </>
             )}
           </div>
         )}