@@ -21,7 +21,7 @@ async def lifespan(app: FastAPI):
 class SearchRequest(BaseModel):
     query: str
     project_id: str
-    top_k: int = 5
+    top_k: int = 10  # 열린 과제 13-19. Node rag.service.ts RAG_TOP_K 와 같이 움직인다
 
 
 class IndexRequest(BaseModel):
 
@@ -36,7 +36,7 @@ def collect_documents(repo_path: str, project_id: str, max_files: int | None = N
 
             # 파일 읽기 (바이너리 파일이나 읽기 실패 시 건너뜀)
             try:
-                with open(file_path, "r", encoding="utf-8") as f:
+                with open(file_path, "r", encoding="utf-8-sig") as f:  # BOM 이 있으면 벗긴다 — 첫 줄이 \ufeff 로 시작하면 청크·줄 번호가 어긋난다
                     content = f.read()
             except (UnicodeDecodeError, OSError):
                 logger.warning("파일 읽기 실패, 건너뜀: %s", relative_path)
 
@@ -13,7 +13,7 @@ async def search_pipeline(query: str, project_id: str, top_k: int) -> dict:
         raw_results = hybrid_search(query, project_id, top_k)
         filtered = filter_by_threshold(raw_results)
         deduped = dedup(filtered)
-        reranked = rerank(query, deduped)
+        reranked = rerank(query, deduped, top_k)
 
         return {
             "chunks": reranked,
 
@@ -31,7 +31,9 @@ def rerank(query: str, docs: list[Document], top_k: int | None = None) -> list[D
 
     try:
         reranker = _get_reranker()
-        
+        # CohereRerank 의 top_n 기본값은 3 이다 — 그대로 두면 top_k 를 몇으로 올려도 LLM 에는 3개만 간다
+        # (2026-09-16 실측: top_k 10 → final 3). 전부 돌려받고 아래에서 top_k 로 자른다.
+        reranker.top_n = len(docs)
         reranked_docs = reranker.compress_documents(documents=docs, query=query)
 
         for d in reranked_docs:
 
@@ -12,4 +12,6 @@ psycopg[binary]>=3.0.0
 psycopg2-binary
 fastapi>=0.110.0
 uvicorn>=0.29.0
-rank-bm25>=0.2.2
+rank-bm25>=0.2.2
+tree-sitter-language-pack>=1.0.0
+
@@ -0,0 +1,144 @@
+# ADR-020 · 열린 과제 13-21 — 코드는 tree-sitter AST 로 함수·클래스 단위로 자른다
+from langchain_core.documents import Document
+
+from app.parsing.splitter import split_documents
+
+
+def code_doc(text, language, extension):
+    return Document(page_content=text, metadata={"language": language, "extension": extension, "project_id": "p1", "source": f"f{extension}"})
+
+
+def assert_covers_and_lines_match(src, chunks):
+    lines = src.split("\n")
+    for line in lines:
+        if line.strip():
+            assert any(line.rstrip() in c.page_content for c in chunks), f"사라진 줄: {line!r}"
+    for c in chunks:
+        start, end = c.metadata["start_line"], c.metadata["end_line"]
+        first, last = c.page_content.split("\n")[0], c.page_content.split("\n")[-1]
+        assert lines[start - 1].strip() == first.strip(), (start, first)
+        assert lines[end - 1].strip() == last.strip(), (end, last)
+
+
+def whole_in_one_chunk(chunks, text):
+    owners = [c for c in chunks if text in c.page_content]
+    assert len(owners) == 1, f"{text[:30]!r} 가 {len(owners)}개 청크에 있다"
+    return owners[0]
+
+
+BIG_BODY = "\n".join(f"    value_{i} = compute_something(value_{i - 1}, factor={i})" for i in range(1, 12))
+METHOD_BODY = BIG_BODY.replace("\n    ", "\n        ").replace("    value_1 ", "        value_1 ", 1)
+PY_SRC = f'''import os
+from typing import Any
+
+DEFAULT_TIMEOUT = 5.0
+
+
+def tiny(x):
+    return x
+
+
+def big_function(arg: int) -> int:
+    """긴 함수 — 문자 기준이면 한가운데가 잘렸다"""
+    value_0 = arg
+{BIG_BODY}
+    return value_11
+
+
+class Client:
+    """클래스는 chunk_size 를 넘으므로 메서드 단위로 내려간다"""
+
+    def __init__(self, base_url: str):
+        self.base_url = base_url
+
+    def request(self, method: str, path: str) -> dict:
+        url = self.base_url + path
+{METHOD_BODY}
+        return {{"method": method, "url": url}}
+
+    def close(self):
+        pass
+'''
+
+
+def test_python_functions_are_not_cut_in_the_middle():
+    chunks = split_documents([code_doc(PY_SRC, "python", ".py")], chunk_size=900)
+
+    assert_covers_and_lines_match(PY_SRC, chunks)
+    for c in chunks:
+        assert len(c.page_content) <= 900
+
+    big = whole_in_one_chunk(chunks, "def big_function(arg: int) -> int:\n" + '    """긴 함수')
+    assert big.metadata["symbol_name"] == "big_function"
+    assert big.metadata["symbol_kind"] == "function_definition"
+    assert big.metadata["start_line"] == PY_SRC.split("\n").index("def big_function(arg: int) -> int:") + 1
+    assert "return value_11" in big.page_content
+
+    request = whole_in_one_chunk(chunks, "def request(self, method: str, path: str) -> dict:")
+    assert request.metadata["symbol_name"] == "request"
+    assert 'return {"method": method, "url": url}' in request.page_content
+
+    # 작은 것(import·상수·한 줄 함수)은 홀로 서지 않고 이웃과 합쳐져 50자 하한에 안 걸린다
+    consts = whole_in_one_chunk(chunks, "DEFAULT_TIMEOUT = 5.0")
+    assert "import os" in consts.page_content
+    assert consts.metadata["symbol_kind"] != "module", "파이썬 루트 노드(module)를 정의로 보면 안 된다"
+    assert all(len(c.page_content) >= 50 for c in chunks)
+
+
+def test_oversized_function_splits_on_lines_and_keeps_symbol():
+    body = "\n".join(f"    step_{i} = run_step_number({i}, previous=step_{i - 1})" for i in range(1, 60))
+    src = f"def huge(step_0):\n{body}\n    return step_59\n"
+    chunks = split_documents([code_doc(src, "python", ".py")], chunk_size=500)
+
+    assert len(chunks) > 1
+    assert_covers_and_lines_match(src, chunks)
+    assert {c.metadata["symbol_name"] for c in chunks} == {"huge"}
+    src_lines = src.split("\n")
+    for c in chunks:
+        for line in c.page_content.split("\n"):
+            assert line in src_lines, f"줄 중간에서 잘렸다: {line!r}"
+
+
+TS_SRC = '''import { useEffect, useState } from "react";
+
+export const CONFIG = { retries: 3, timeoutMs: 5000 };
+
+export const useThing = (id: string) => {
+  const [state, setState] = useState<string | null>(null);
+  useEffect(() => {
+    let cancelled = false;
+    fetchThing(id).then((value) => {
+      if (!cancelled) setState(value);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [id]);
+  return state;
+};
+
+export default function Page({ id }: { id: string }) {
+  const thing = useThing(id);
+  return <section className="page"><h1>{thing ?? "loading"}</h1></section>;
+}
+'''
+
+
+def test_tsx_arrow_components_get_symbol_names():
+    chunks = split_documents([code_doc(TS_SRC, "typescript", ".tsx")], chunk_size=400)
+
+    assert_covers_and_lines_match(TS_SRC, chunks)
+    hook = whole_in_one_chunk(chunks, "export const useThing = (id: string) => {")
+    assert hook.metadata["symbol_name"] == "useThing"
+    page = whole_in_one_chunk(chunks, "export default function Page")
+    assert page.metadata["symbol_name"] == "Page"
+    # 상수는 정의로 세우지 않는다 — 홀로 서면 50자 하한에 걸려 사라진다
+    assert whole_in_one_chunk(chunks, "export const CONFIG").metadata["symbol_name"] != "CONFIG"
+
+
+def test_unknown_language_falls_back_to_character_splitter():
+    src = "\n".join(f"key_{i}: value_{i}" for i in range(80))
+    chunks = split_documents([code_doc(src, "yaml", ".yml")], chunk_size=200, chunk_overlap=0)
+    assert len(chunks) > 1
+    assert "symbol_name" not in chunks[0].metadata
+    assert chunks[0].metadata["start_line"] == 1
@@ -4,7 +4,8 @@
 from app.parsing.splitter import split_documents
 
 
-def make_doc(text, language="python"):
+def make_doc(text, language="unknown"):
+    # 문자 기준 분할기가 도는 언어로 고정한다 — 코드는 AST 경로(test_splitter_ast.py)로 간다
     return Document(page_content=text, metadata={"language": language, "project_id": "p1"})
 
 
@@ -48,9 +49,7 @@ def split_documents(self, docs):
 def test_unlocatable_chunk_has_no_line_range(monkeypatch):
     # 열린 과제 13-13 — 원문에서 못 찾으면 옛 코드는 start_line을 정하지 않았다.
     # 첫 청크면 NameError, 이후 청크면 이전 청크의 줄 번호를 그대로 인용한다.
-    monkeypatch.setattr(
-        splitter_module, "_build_language_splitter", lambda *_: {"python": _UnlocatableSplitter()}
-    )
+    monkeypatch.setattr(splitter_module, "_build_default_splitter", lambda *_: _UnlocatableSplitter())
     chunks = split_documents([make_doc("a = 1\nb = 2\nc = 3\n")], chunk_size=100, chunk_overlap=20)
 
     # 못 찾은 청크는 줄 범위를 비운다 — 틀린 줄을 붙이지 않는다
 
@@ -0,0 +1,55 @@
+import re
+
+from langchain_core.documents import Document
+
+from app.parsing.splitter import split_documents
+
+FENCE_LINE = re.compile(r"^```", re.MULTILINE)
+
+
+def md_doc(text):
+    return Document(page_content=text, metadata={"language": "markdown", "project_id": "p1", "source": "README.md"})
+
+
+def test_code_fence_stays_in_one_chunk():
+    # 열린 과제 13-1 — 기본 마크다운 분할 규칙은 닫는 ``` 앞에서 자른다.
+    # 코드블록은 A 청크에, 닫는 ``` 는 B 청크 첫 줄에 놓여 B를 마크다운으로
+    # 읽으면 그 아래가 전부 코드블록으로 먹힌다("백틱 뒤가 잘린다").
+    # 또 '\n# ' 헤딩 규칙이 코드블록 안의 파이썬 주석에도 걸려 블록 한가운데를 자른다.
+    sections = []
+    for i in range(12):
+        sections.append(
+            f"## Step {i}\n\n설명 문장 {i}.\n\n"
+            f"```python\n# 주석 {i}\nvalue_{i} = compute({i})\nprint(value_{i})\n```\n\n"
+            f"펜스 뒤 문장 {i}은 살아야 한다.\n"
+        )
+    src = "\n".join(sections)
+
+    chunks = split_documents([md_doc(src)], chunk_size=300, chunk_overlap=0)
+
+    for c in chunks:
+        text = c.page_content
+        assert not text.startswith("```\n"), f"닫는 펜스가 청크 첫 줄에 떨어졌다: {text[:40]!r}"
+        assert len(FENCE_LINE.findall(text)) % 2 == 0, f"펜스가 짝이 안 맞는다: {text[:60]!r}"
+        assert not text.startswith("# 주석"), "코드블록 안 주석을 헤딩으로 보고 잘랐다"
+
+    # 텍스트 손실 없음 + 줄 번호 정확
+    lines = src.split("\n")
+    for line in lines:
+        if line.strip():
+            assert any(line in c.page_content for c in chunks), f"사라진 줄: {line!r}"
+    for c in chunks:
+        start = c.metadata["start_line"]
+        assert start is not None
+        assert lines[start - 1].startswith(c.page_content.split("\n")[0])
+
+
+def test_oversized_code_block_is_split_on_lines_only():
+    # chunk_size를 넘는 코드블록은 어쩔 수 없이 잘리지만, 줄 중간(공백)에서 자르지는 않는다
+    body = "\n".join(f"item_{i} = load_something_reasonably_long({i})" for i in range(40))
+    src = f"# Big\n\n```python\n{body}\n```\n"
+    chunks = split_documents([md_doc(src)], chunk_size=300, chunk_overlap=0)
+    assert len(chunks) > 1
+    for c in chunks:
+        for line in c.page_content.split("\n"):
+            assert line in src.split("\n"), f"줄 중간에서 잘렸다: {line!r}"
@@ -0,0 +1,38 @@
+# 열린 과제 13-19 후속 — 리랭커가 top_k 만큼 돌려줘야 top_k 상향이 LLM 에 닿는다
+from langchain_core.documents import Document
+
+import app.retrieval.reranker as reranker_module
+from app.retrieval.reranker import rerank
+
+
+class _CohereLike:
+    """langchain_cohere.CohereRerank 흉내 — top_n(기본 3)개만 돌려준다."""
+
+    top_n = 3
+
+    def compress_documents(self, documents, query):
+        ranked = sorted(documents, key=lambda d: d.metadata["score"])  # 벡터 점수 역순으로 뒤집어 재정렬을 흉내
+        for d in ranked:
+            d.metadata["relevance_score"] = 0.9
+        return ranked[: self.top_n]
+
+
+def docs(n):
+    return [Document(page_content=f"chunk {i}", metadata={"score": i / 10}) for i in range(n)]
+
+
+def test_rerank_returns_top_k_not_cohere_default_three(monkeypatch):
+    monkeypatch.setattr(reranker_module, "RERANKER_ENABLED", True)
+    monkeypatch.setattr(reranker_module, "_get_reranker", lambda: _CohereLike())
+
+    result = rerank("q", docs(9), top_k=10)
+
+    assert len(result) == 9, "Cohere 기본 top_n=3 에 잘리면 top_k 상향이 무의미하다"
+    assert result[0].page_content == "chunk 0", "리랭커의 순서를 따라야 한다"
+    assert all("rerank_score" in d.metadata for d in result)
+
+
+def test_rerank_slices_to_top_k(monkeypatch):
+    monkeypatch.setattr(reranker_module, "RERANKER_ENABLED", True)
+    monkeypatch.setattr(reranker_module, "_get_reranker", lambda: _CohereLike())
+    assert len(rerank("q", docs(9), top_k=5)) == 5