refactor(agent-office): tarot 모듈 제거 (tarot-lab으로 cutover 완료)

- DELETE: app/tarot/ 디렉토리 (pipeline, prompt, schema 모듈)
- DELETE: app/routers/tarot.py (FastAPI 라우터)
- DELETE: 4개 tarot 테스트 파일 (test_tarot_*.py)
- MODIFY: app/main.py — tarot 라우터 import + register 제거
- MODIFY: app/models.py — 5개 Tarot* 클래스 제거
- MODIFY: app/config.py — 4개 TAROT_* 환경변수 제거
- MODIFY: app/db.py — 6개 tarot_readings CRUD 함수 제거

KEEP:
- tarot_readings CREATE TABLE 블록 (DB 호환성)
- CREATE INDEX ... tarot_readings 인덱스 2개
- scripts/migrate_tarot_to_lab.py (cutover 마이그레이션)
- tests/test_migrate_tarot.py (마이그레이션 테스트)

테스트: 88 pass (migrate_tarot tests 포함)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

agent-office/tests/test_tarot_db.py

@@ -1,70 +0,0 @@
-import json
-import os
-import tempfile
-
-import pytest
-
-from app import db as db_module
-
-
-@pytest.fixture(autouse=True)
-def fresh_db(monkeypatch, tmp_path):
-    db_file = tmp_path / "test_tarot.db"
-    monkeypatch.setattr(db_module, "DB_PATH", str(db_file))
-    db_module.init_db()
-    yield
-    if db_file.exists():
-        db_file.unlink()
-
-
-def test_save_and_get_tarot_reading():
-    rid = db_module.save_tarot_reading({
-        "spread_type": "three_card",
-        "category": "연애",
-        "question": "Q",
-        "cards": [{"position": "과거", "card_id": "the-fool", "reversed": False}],
-        "interpretation_json": {"summary": "S", "cards": [], "interactions": [], "advice": "A", "warning": None, "confidence": "medium"},
-        "model": "claude-sonnet-4-6",
-        "tokens_in": 100, "tokens_out": 200, "cost_usd": 0.005,
-        "confidence": "medium",
-    })
-    assert rid > 0
-    row = db_module.get_tarot_reading(rid)
-    assert row["id"] == rid
-    assert row["category"] == "연애"
-    assert row["interpretation_json"]["summary"] == "S"
-    assert row["favorite"] == 0
-
-
-def test_list_tarot_readings_filters_and_pagination():
-    for cat in ["연애", "연애", "재물"]:
-        db_module.save_tarot_reading({
-            "spread_type": "three_card", "category": cat, "question": "Q",
-            "cards": [], "interpretation_json": {"summary": "S", "cards": [], "interactions": [], "advice": "", "warning": None, "confidence": "low"},
-            "model": "x", "tokens_in": 0, "tokens_out": 0, "cost_usd": 0.0, "confidence": "low",
-        })
-    res = db_module.list_tarot_readings(page=1, size=10, category="연애")
-    assert res["total"] == 2
-    assert all(r["category"] == "연애" for r in res["items"])
-
-
-def test_update_tarot_reading_favorite_and_note():
-    rid = db_module.save_tarot_reading({
-        "spread_type": "one_card", "category": None, "question": None,
-        "cards": [], "interpretation_json": {"summary": "S", "cards": [], "interactions": [], "advice": "", "warning": None, "confidence": "high"},
-        "model": "x", "tokens_in": 0, "tokens_out": 0, "cost_usd": 0.0, "confidence": "high",
-    })
-    db_module.update_tarot_reading(rid, favorite=True, note="기억하고 싶음")
-    row = db_module.get_tarot_reading(rid)
-    assert row["favorite"] == 1
-    assert row["note"] == "기억하고 싶음"
-
-
-def test_delete_tarot_reading():
-    rid = db_module.save_tarot_reading({
-        "spread_type": "one_card", "category": None, "question": None,
-        "cards": [], "interpretation_json": {"summary": "S", "cards": [], "interactions": [], "advice": "", "warning": None, "confidence": "high"},
-        "model": "x", "tokens_in": 0, "tokens_out": 0, "cost_usd": 0.0, "confidence": "high",
-    })
-    db_module.delete_tarot_reading(rid)
-    assert db_module.get_tarot_reading(rid) is None

agent-office/tests/test_tarot_pipeline.py

@@ -1,113 +0,0 @@
-import json
-import pytest
-import respx
-from httpx import Response
-
-from app.tarot import pipeline as p
-from app.models import TarotInterpretRequest
-
-
-def _valid_response_text():
-    return json.dumps({
-        "summary": "S",
-        "cards": [
-            {"position": "과거", "card": "the-fool", "reversed": False,
-             "interpretation": "i", "advice": "a",
-             "evidence": {"card_meaning_used": "k", "position_logic": "p", "category_lens": "c"}},
-            {"position": "현재", "card": "the-lovers", "reversed": True,
-             "interpretation": "i", "advice": "a",
-             "evidence": {"card_meaning_used": "k", "position_logic": "p", "category_lens": "c"}},
-            {"position": "미래", "card": "ten-of-cups", "reversed": False,
-             "interpretation": "i", "advice": "a",
-             "evidence": {"card_meaning_used": "k", "position_logic": "p", "category_lens": "c"}},
-        ],
-        "interactions": [{"type": "synergy", "between": ["the-fool", "ten-of-cups"], "explanation": "."}],
-        "advice": "A", "warning": None, "confidence": "medium",
-    })
-
-
-def _claude_resp(text, in_tok=100, out_tok=200):
-    return {
-        "content": [{"type": "text", "text": text}],
-        "usage": {"input_tokens": in_tok, "output_tokens": out_tok},
-    }
-
-
-def _req():
-    return TarotInterpretRequest(
-        spread_type="three_card",
-        category="연애",
-        question="Q",
-        cards=[
-            {"position": "과거", "card_id": "the-fool", "reversed": False},
-            {"position": "현재", "card_id": "the-lovers", "reversed": True},
-            {"position": "미래", "card_id": "ten-of-cups", "reversed": False},
-        ],
-        cards_reference="REFERENCE",
-        context_meta={"major_minor_ratio": "2:1"},
-    )
-
-
-@pytest.mark.asyncio
-async def test_interpret_happy_path(monkeypatch):
-    monkeypatch.setattr(p, "ANTHROPIC_API_KEY", "sk-test")
-    with respx.mock(base_url="https://api.anthropic.com") as mock:
-        mock.post("/v1/messages").mock(return_value=Response(200, json=_claude_resp(_valid_response_text())))
-        out = await p.interpret(_req())
-    assert out["interpretation_json"]["confidence"] == "medium"
-    assert out["tokens_in"] == 100
-    assert out["tokens_out"] == 200
-    assert out["reroll_count"] == 0
-    assert out["cost_usd"] > 0
-
-
-@pytest.mark.asyncio
-async def test_interpret_codeblock_strip(monkeypatch):
-    monkeypatch.setattr(p, "ANTHROPIC_API_KEY", "sk-test")
-    wrapped = "```json\n" + _valid_response_text() + "\n```"
-    with respx.mock(base_url="https://api.anthropic.com") as mock:
-        mock.post("/v1/messages").mock(return_value=Response(200, json=_claude_resp(wrapped)))
-        out = await p.interpret(_req())
-    assert out["interpretation_json"]["summary"] == "S"
-
-
-@pytest.mark.asyncio
-async def test_interpret_reroll_on_validation_fail(monkeypatch):
-    monkeypatch.setattr(p, "ANTHROPIC_API_KEY", "sk-test")
-    bad = json.loads(_valid_response_text())
-    bad["cards"][0]["evidence"]["card_meaning_used"] = ""
-    bad_text = json.dumps(bad)
-    with respx.mock(base_url="https://api.anthropic.com") as mock:
-        route = mock.post("/v1/messages")
-        route.side_effect = [
-            Response(200, json=_claude_resp(bad_text)),
-            Response(200, json=_claude_resp(_valid_response_text())),
-        ]
-        out = await p.interpret(_req())
-    assert out["reroll_count"] == 1
-    assert out["interpretation_json"]["cards"][0]["evidence"]["card_meaning_used"] == "k"
-
-
-@pytest.mark.asyncio
-async def test_interpret_raises_when_both_attempts_fail(monkeypatch):
-    monkeypatch.setattr(p, "ANTHROPIC_API_KEY", "sk-test")
-    bad = json.loads(_valid_response_text())
-    bad["cards"][0]["evidence"]["card_meaning_used"] = ""
-    bad_text = json.dumps(bad)
-    with respx.mock(base_url="https://api.anthropic.com") as mock:
-        mock.post("/v1/messages").mock(return_value=Response(200, json=_claude_resp(bad_text)))
-        with pytest.raises(p.TarotError):
-            await p.interpret(_req())
-
-
-@pytest.mark.asyncio
-async def test_interpret_raises_when_api_key_missing(monkeypatch):
-    monkeypatch.setattr(p, "ANTHROPIC_API_KEY", "")
-    with pytest.raises(p.TarotError):
-        await p.interpret(_req())
-
-
-def test_calc_cost():
-    assert p.calc_cost(1_000_000, 0) == pytest.approx(3.0)
-    assert p.calc_cost(0, 1_000_000) == pytest.approx(15.0)
-    assert p.calc_cost(500_000, 500_000) == pytest.approx(9.0)

agent-office/tests/test_tarot_routes.py

@@ -1,86 +0,0 @@
-import json
-import pytest
-from fastapi.testclient import TestClient
-
-from app import db as db_module
-
-
-@pytest.fixture(autouse=True)
-def fresh_db(monkeypatch, tmp_path):
-    db_file = tmp_path / "test_routes.db"
-    monkeypatch.setattr(db_module, "DB_PATH", str(db_file))
-    db_module.init_db()
-    from app.main import app
-    yield app
-
-
-def test_interpret_calls_pipeline(monkeypatch, fresh_db):
-    async def fake_interpret(req):
-        return {
-            "interpretation_json": {"summary": "S", "cards": [], "interactions": [], "advice": "A", "warning": None, "confidence": "high"},
-            "model": "claude-sonnet-4-6", "tokens_in": 100, "tokens_out": 200,
-            "cost_usd": 0.005, "latency_ms": 1234, "reroll_count": 0,
-        }
-    from app.tarot import pipeline
-    monkeypatch.setattr(pipeline, "interpret", fake_interpret)
-    client = TestClient(fresh_db)
-    r = client.post("/api/agent-office/tarot/interpret", json={
-        "spread_type": "one_card",
-        "category": "일반",
-        "question": "Q",
-        "cards": [{"position": "오늘", "card_id": "the-fool", "reversed": False}],
-        "cards_reference": "REF",
-        "context_meta": {},
-    })
-    assert r.status_code == 200, r.text
-    assert r.json()["interpretation_json"]["confidence"] == "high"
-
-
-def test_save_and_list(fresh_db):
-    client = TestClient(fresh_db)
-    save = client.post("/api/agent-office/tarot/readings", json={
-        "spread_type": "three_card", "category": "연애", "question": "Q",
-        "cards": [{"position": "과거", "card_id": "the-fool", "reversed": False}],
-        "interpretation_json": {"summary": "S", "cards": [], "interactions": [], "advice": "A", "warning": None, "confidence": "medium"},
-        "model": "claude-sonnet-4-6", "tokens_in": 1, "tokens_out": 2, "cost_usd": 0.01,
-        "confidence": "medium",
-    })
-    assert save.status_code == 200, save.text
-    rid = save.json()["id"]
-    lst = client.get("/api/agent-office/tarot/readings?page=1&size=10")
-    assert lst.json()["total"] == 1
-    assert lst.json()["items"][0]["id"] == rid
-
-
-def test_patch_favorite(fresh_db):
-    client = TestClient(fresh_db)
-    save = client.post("/api/agent-office/tarot/readings", json={
-        "spread_type": "one_card", "cards": [],
-        "interpretation_json": {"summary": "S", "cards": [], "interactions": [], "advice": "A", "warning": None, "confidence": "low"},
-        "model": "x", "tokens_in": 0, "tokens_out": 0, "cost_usd": 0.0, "confidence": "low",
-    })
-    rid = save.json()["id"]
-    p = client.patch(f"/api/agent-office/tarot/readings/{rid}", json={"favorite": True})
-    assert p.status_code == 200
-    g = client.get(f"/api/agent-office/tarot/readings/{rid}")
-    assert g.json()["favorite"] == 1
-
-
-def test_delete(fresh_db):
-    client = TestClient(fresh_db)
-    save = client.post("/api/agent-office/tarot/readings", json={
-        "spread_type": "one_card", "cards": [],
-        "interpretation_json": {"summary": "S", "cards": [], "interactions": [], "advice": "A", "warning": None, "confidence": "low"},
-        "model": "x", "tokens_in": 0, "tokens_out": 0, "cost_usd": 0.0, "confidence": "low",
-    })
-    rid = save.json()["id"]
-    d = client.delete(f"/api/agent-office/tarot/readings/{rid}")
-    assert d.status_code == 200
-    g = client.get(f"/api/agent-office/tarot/readings/{rid}")
-    assert g.status_code == 404
-
-
-def test_get_missing_reading_404(fresh_db):
-    client = TestClient(fresh_db)
-    r = client.get("/api/agent-office/tarot/readings/99999")
-    assert r.status_code == 404

agent-office/tests/test_tarot_schema.py

@@ -1,75 +0,0 @@
-import pytest
-
-from app.tarot.schema import validate_interpretation
-
-
-def _valid_three():
-    return {
-        "summary": "S",
-        "cards": [
-            {"position": "과거", "card": "the-fool", "reversed": False,
-             "interpretation": "...", "advice": "a",
-             "evidence": {"card_meaning_used": "키워드", "position_logic": "p", "category_lens": "c"}},
-            {"position": "현재", "card": "the-lovers", "reversed": True,
-             "interpretation": "...", "advice": "a",
-             "evidence": {"card_meaning_used": "키워드", "position_logic": "p", "category_lens": "c"}},
-            {"position": "미래", "card": "ten-of-cups", "reversed": False,
-             "interpretation": "...", "advice": "a",
-             "evidence": {"card_meaning_used": "키워드", "position_logic": "p", "category_lens": "c"}},
-        ],
-        "interactions": [{"type": "synergy", "between": ["the-fool", "ten-of-cups"], "explanation": "..."}],
-        "advice": "A",
-        "warning": None,
-        "confidence": "medium",
-    }
-
-
-def test_valid_three_card_passes():
-    ok, msg = validate_interpretation(_valid_three(), "three_card")
-    assert ok, msg
-
-
-def test_missing_evidence_fails():
-    bad = _valid_three()
-    del bad["cards"][0]["evidence"]
-    ok, msg = validate_interpretation(bad, "three_card")
-    assert not ok
-    assert "evidence" in msg
-
-
-def test_empty_card_meaning_used_fails():
-    bad = _valid_three()
-    bad["cards"][0]["evidence"]["card_meaning_used"] = ""
-    ok, msg = validate_interpretation(bad, "three_card")
-    assert not ok
-    assert "card_meaning_used" in msg
-
-
-def test_three_card_requires_interactions():
-    bad = _valid_three()
-    bad["interactions"] = []
-    ok, msg = validate_interpretation(bad, "three_card")
-    assert not ok
-    assert "interactions" in msg
-
-
-def test_one_card_accepts_empty_interactions():
-    one = {
-        "summary": "S",
-        "cards": [{"position": "오늘", "card": "the-fool", "reversed": False,
-                   "interpretation": "...", "advice": "a",
-                   "evidence": {"card_meaning_used": "k", "position_logic": "p", "category_lens": "c"}}],
-        "interactions": [],
-        "advice": "A",
-        "warning": None,
-        "confidence": "high",
-    }
-    ok, msg = validate_interpretation(one, "one_card")
-    assert ok, msg
-
-
-def test_invalid_confidence_fails():
-    bad = _valid_three()
-    bad["confidence"] = "very high"
-    ok, msg = validate_interpretation(bad, "three_card")
-    assert not ok