feat: FedEntry에 kind/applies_to/tags 필드 추가

비즈니스 용어를 Metric/Table/Rule/Dimension으로 분류할 수 있도록
FedEntry에 kind, applies_to, tags 필드를 추가한다.

- FedEntry: kind, applies_to, tags 필드 추가 (기존 JSON 하위호환)
- term_custom tool spec: 세 파라미터 노출
- _fmt_entry: kind 배지 표시 (`metric` 등)
- 신규 테스트 3개: round-trip, 하위호환, kind 배지 렌더링

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: thrcle

src/lang2sql/tools/semantic_federation.py

@@ -61,17 +61,23 @@ class FedEntry:
     definition: str
     synonyms: list[str] = field(default_factory=list)
     inferred: bool = False
+    kind: str = ""          # metric | table | rule | dimension
+    applies_to: str = ""    # 관련 테이블/컬럼 (예: users, orders.amount)
+    tags: list[str] = field(default_factory=list)
 
     def __post_init__(self) -> None:
         if not isinstance(self.synonyms, list):
             self.synonyms = _parse_synonyms(self.synonyms)
+        if not isinstance(self.tags, list):
+            self.tags = [t.strip() for t in str(self.tags).split(",") if t.strip()]
 
     def to_json(self) -> str:
         return json.dumps(
             {
                 "term": self.term, "layer": self.layer, "entity": self.entity,
                 "definition": self.definition, "synonyms": self.synonyms,
-                "inferred": self.inferred,
+                "inferred": self.inferred, "kind": self.kind,
+                "applies_to": self.applies_to, "tags": self.tags,
             },
             ensure_ascii=False,
         )
@@ -82,7 +88,8 @@ def from_json(raw: str) -> "FedEntry":
         return FedEntry(
             term=d["term"], layer=d["layer"], entity=d.get("entity", ""),
             definition=d["definition"], synonyms=d.get("synonyms", []),
-            inferred=d.get("inferred", False),
+            inferred=d.get("inferred", False), kind=d.get("kind", ""),
+            applies_to=d.get("applies_to", ""), tags=d.get("tags", []),
         )
 
 
@@ -117,6 +124,19 @@ def spec(self) -> ToolSpec:
                         "type": "string",
                         "description": "쉼표 구분 동의어 (예: active_user,활성화고객)",
                     },
+                    "kind": {
+                        "type": "string",
+                        "enum": ["metric", "table", "rule", "dimension"],
+                        "description": "용어 종류. metric=지표, table=테이블/엔티티, rule=비즈니스 규칙, dimension=분류 기준.",
+                    },
+                    "applies_to": {
+                        "type": "string",
+                        "description": "관련 테이블 또는 컬럼 (예: users, orders.amount).",
+                    },
+                    "tags": {
+                        "type": "string",
+                        "description": "쉼표 구분 태그 (예: growth,retention).",
+                    },
                     "inferred": {
                         "type": "boolean",
                         "description": "true 시 LLM 추론 임시 정의로 표시. 사용자 확인 후 재등록 권장.",
@@ -215,9 +235,13 @@ async def run(self, args: dict[str, Any], ctx: "HarnessContext") -> ToolResult:
 
         synonyms = _parse_synonyms(args.get("synonyms"))
         inferred = bool(args.get("inferred", False))
+        kind = str(args.get("kind", "")).strip().lower()
+        applies_to = str(args.get("applies_to", "")).strip()
+        tags = [t.strip() for t in str(args.get("tags", "")).split(",") if t.strip()]
 
         entry = FedEntry(term=term, layer=layer, entity=entity,
-                         definition=definition, synonyms=synonyms, inferred=inferred)
+                         definition=definition, synonyms=synonyms, inferred=inferred,
+                         kind=kind, applies_to=applies_to, tags=tags)
         ctx.store.kv_set(scope, key, entry.to_json())
         if ctx.audit is not None:
             await ctx.audit.record(
@@ -360,7 +384,8 @@ def _fmt_entry(e: FedEntry, tag: str) -> str:
     syns = ", ".join(e.synonyms)
     syn_str = f" (= {syns})" if syns else ""
     inferred_badge = " 🤖" if e.inferred else ""
-    return f"- **{e.term}** [{tag}]{syn_str}{inferred_badge}: {e.definition}"
+    kind_badge = f" `{e.kind}`" if e.kind else ""
+    return f"- **{e.term}**{kind_badge} [{tag}]{syn_str}{inferred_badge}: {e.definition}"
 
 
 def _resolve_term(entries: list[FedEntry], channel_id: str, user_id: str) -> str:

tests/test_semantic.py

@@ -84,3 +84,38 @@ def test_build_prompt_section_includes_ambiguous_term_policy() -> None:
     store = SqliteStore()
     section = build_prompt_section(store, "g1", "c1", "u1")
     assert "Ambiguous Term Policy" in section
+
+
+def test_fed_entry_kind_applies_to_tags_roundtrip() -> None:
+    entry = FedEntry(
+        term="활성고객", layer="guild", entity="",
+        definition="30일 내 로그인한 users",
+        kind="metric", applies_to="users", tags=["growth", "retention"],
+    )
+    restored = FedEntry.from_json(entry.to_json())
+    assert restored.kind == "metric"
+    assert restored.applies_to == "users"
+    assert restored.tags == ["growth", "retention"]
+
+
+def test_fed_entry_backward_compat_missing_new_fields() -> None:
+    # kind/applies_to/tags 없는 기존 JSON도 파싱 가능해야 함
+    import json
+    old_json = json.dumps({
+        "term": "revenue", "layer": "guild", "entity": "",
+        "definition": "net revenue", "synonyms": [], "inferred": False,
+    })
+    entry = FedEntry.from_json(old_json)
+    assert entry.kind == ""
+    assert entry.applies_to == ""
+    assert entry.tags == []
+
+
+def test_fmt_entry_shows_kind_badge() -> None:
+    from lang2sql.tools.semantic_federation import _fmt_entry
+    entry = FedEntry(
+        term="활성고객", layer="guild", entity="",
+        definition="30일 내 로그인", kind="metric",
+    )
+    rendered = _fmt_entry(entry, "전사")
+    assert "`metric`" in rendered