feat(ocr): bundle PP-OCRv5 ONNX models (det 4.7MB + rec 13MB)

paddle-onnx engine assets — committed as plain binary blobs (git-lfs not installed on this host; see .gitattributes for the LFS migration recipe). NOTICE (Apache-2.0) + korean_dict.txt already tracked. Loaded by default from this dir or KEBAB_IMAGE_OCR_MODEL_DIR. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
chore(ocr): T11/T12 — clippy clean + docs + v0.27.0 bump
2026-06-04 08:36:34 +00:00 · 2026-06-04 08:36:19 +00:00 · 2026-06-04 08:22:47 +00:00 · 2026-06-04 08:15:30 +00:00 · 2026-06-04 07:52:39 +00:00 · 2026-06-04 07:43:53 +00:00
88 changed files with 17614 additions and 1398 deletions
--- a/.gitattributes
+++ b/.gitattributes
@@ -0,0 +1,6 @@
+# PP-OCRv5 ONNX OCR models (paddle-onnx engine). git-lfs is not installed on
+# this host, so they are committed as plain binary blobs (treated as binary —
+# no textual diff/merge). If/when git-lfs becomes available, migrate with
+# `git lfs migrate import --include='*.onnx'` and restore the filter line:
+#   *.onnx filter=lfs diff=lfs merge=lfs -text
+*.onnx -text
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -82,7 +82,10 @@ Release 절차:

 1. `gitea-release v<X.Y.Z>` (gitea-ops skill) 으로 tag + push + release notes.
 2. release notes 는 사용자 도그푸딩에 영향이 가는 surface 변경을 위주로 — wire schema 추가, CLI flag 신규, TUI 키 변경, V00X migration 등 — 다룬다. 이때 추가된 기능과 변경사항은 유저가 이해할 수 있도록 친절하고 자세하게 풀어서 설명해야 하며, 단순히 commit subject 를 나열하는 형태로 끝내면 안 된다. 필요하다면 도그푸딩이나 테스트 결과도 함께 적어 둔다.
-3. 프리-1.0 (`0.x.y`) 단계: minor bump 시 wire schema additive / surface 변경 누적, patch bump 시 bug fix only.
+3. 프리-1.0 (`0.x.y`) 단계 bump 규칙 — **기능(behavior) 또는 인터페이스(interface) 변경 여부**로 판정:
+   - **minor bump** (`0.x.0`): 기능 또는 인터페이스에 *실질적* 변경이 있을 때. 인터페이스 = 신규/변경/삭제된 CLI subcommand·flag, config 키, wire schema 의 **breaking** 변경, 임베딩/검색/RAG 등 사용자가 받는 **결과·동작**의 변화, V00X migration, frozen 설계 변경. 기능 = 새 source 형식·검색 모드·백엔드 등 *할 수 있는 일*의 추가/변경.
+   - **patch bump** (`0.x.y`): 기능·인터페이스 변경이 **없을** 때. bug fix, 내부 refactor, 성능 개선, 로깅/진행표시 등 **관측성(observability) 개선**, **additive-only wire 변경**(backward-compat 신규 필드/이벤트라 기존 소비자 무영향), 문서. ← 즉 "결과가 같고 새 명령/플래그/config 도 없으면 patch".
+   - 경계 예: 진행 로그에 phase/파일명 추가 + additive wire 이벤트(asset_phase) = **patch** (검색·색인 결과 불변, 새 명령/플래그/config 없음). arctic 임베더 provider + 신규 config 키 = **minor** (인터페이스 추가). 별칭 기능 제거 + migration = **minor** (동작·인터페이스 변경).

 **bump 시점 = release 시점 같은 commit**. 즉 commit `chore: bump version 0.x → 0.y` 직후 같은 commit 에 tag. v0.1.0 (`2319206`) 처럼 bump 없이 tag 만 찍는 패턴은 후속 release 가 대상 commit 을 헷갈리게 함 — pre-release snapshot 은 SHA reference 로 충분.

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4417,6 +4417,24 @@ dependencies = [
 "quick-error 2.0.1",
 ]

+[[package]]
+name = "imageproc"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "602b4e8a4cc3e98372b766cd184ab532999bc0e839b7469e759511ccabc65d77"
+dependencies = [
+ "ab_glyph",
+ "approx",
+ "getrandom 0.2.17",
+ "image",
+ "itertools 0.12.1",
+ "nalgebra",
+ "num",
+ "rand 0.8.6",
+ "rand_distr 0.4.3",
+ "rayon",
+]
+
 [[package]]
 name = "imgref"
 version = "1.12.1"
@@ -4548,6 +4566,15 @@ dependencies = [
 "either",
 ]

+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itertools"
 version = "0.13.0"
@@ -4724,7 +4751,7 @@ dependencies = [

 [[package]]
 name = "kebab-app"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "base64 0.22.1",
@@ -4739,6 +4766,7 @@ dependencies = [
 "kebab-embed",
 "kebab-embed-candle",
 "kebab-embed-local",
+ "kebab-embed-ollama",
 "kebab-llm",
 "kebab-llm-local",
 "kebab-nli",
@@ -4771,7 +4799,7 @@ dependencies = [

 [[package]]
 name = "kebab-chunk"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "blake3",
@@ -4789,7 +4817,7 @@ dependencies = [

 [[package]]
 name = "kebab-cli"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "clap",
@@ -4810,7 +4838,7 @@ dependencies = [

 [[package]]
 name = "kebab-config"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "dirs 5.0.1",
@@ -4826,7 +4854,7 @@ dependencies = [

 [[package]]
 name = "kebab-core"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "blake3",
@@ -4840,7 +4868,7 @@ dependencies = [

 [[package]]
 name = "kebab-embed"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "blake3",
@@ -4854,7 +4882,7 @@ dependencies = [

 [[package]]
 name = "kebab-embed-candle"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "candle-core",
@@ -4864,6 +4892,7 @@ dependencies = [
 "kebab-config",
 "kebab-core",
 "kebab-embed-local",
+ "kebab-embed-ollama",
 "rayon",
 "serde_json",
 "tempfile",
@@ -4873,7 +4902,7 @@ dependencies = [

 [[package]]
 name = "kebab-embed-local"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "fastembed",
@@ -4884,9 +4913,24 @@ dependencies = [
 "tracing",
 ]

+[[package]]
+name = "kebab-embed-ollama"
+version = "0.27.0"
+dependencies = [
+ "anyhow",
+ "kebab-config",
+ "kebab-core",
+ "reqwest 0.12.28",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tracing",
+ "wiremock",
+]
+
 [[package]]
 name = "kebab-eval"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "kebab-app",
@@ -4905,7 +4949,7 @@ dependencies = [

 [[package]]
 name = "kebab-llm"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "kebab-core",
@@ -4914,7 +4958,7 @@ dependencies = [

 [[package]]
 name = "kebab-llm-local"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "kebab-config",
@@ -4931,7 +4975,7 @@ dependencies = [

 [[package]]
 name = "kebab-mcp"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "kebab-app",
@@ -4949,7 +4993,7 @@ dependencies = [

 [[package]]
 name = "kebab-nli"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "hf-hub",
@@ -4964,7 +5008,7 @@ dependencies = [

 [[package]]
 name = "kebab-parse-code"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "gix",
@@ -4987,22 +5031,26 @@ dependencies = [

 [[package]]
 name = "kebab-parse-image"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "ab_glyph",
 "anyhow",
 "base64 0.22.1",
 "blake3",
 "image",
+ "imageproc",
 "kamadak-exif",
 "kebab-config",
 "kebab-core",
 "kebab-llm",
 "kebab-llm-local",
+ "ndarray",
+ "ort",
 "reqwest 0.12.28",
 "serde",
 "serde_json",
 "tempfile",
+ "thiserror 2.0.18",
 "time",
 "tokio",
 "tracing",
@@ -5011,7 +5059,7 @@ dependencies = [

 [[package]]
 name = "kebab-parse-md"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "kebab-core",
@@ -5028,7 +5076,7 @@ dependencies = [

 [[package]]
 name = "kebab-parse-pdf"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "blake3",
@@ -5043,7 +5091,7 @@ dependencies = [

 [[package]]
 name = "kebab-rag"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "blake3",
@@ -5065,7 +5113,7 @@ dependencies = [

 [[package]]
 name = "kebab-search"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "globset",
@@ -5084,7 +5132,7 @@ dependencies = [

 [[package]]
 name = "kebab-source-fs"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "blake3",
@@ -5102,7 +5150,7 @@ dependencies = [

 [[package]]
 name = "kebab-store-sqlite"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "blake3",
@@ -5122,7 +5170,7 @@ dependencies = [

 [[package]]
 name = "kebab-store-vector"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "arrow",
@@ -5146,7 +5194,7 @@ dependencies = [

 [[package]]
 name = "kebab-tui"
-version = "0.23.0"
+version = "0.27.0"
 dependencies = [
 "anyhow",
 "crossterm",
@@ -6406,6 +6454,21 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13d2233c9842d08cfe13f9eac96e207ca6a2ea10b80259ebe8ad0268be27d2af"

+[[package]]
+name = "nalgebra"
+version = "0.32.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5c17de023a86f59ed79891b2e5d5a94c705dbe904a5b5c9c952ea6221b03e4"
+dependencies = [
+ "approx",
+ "matrixmultiply",
+ "num-complex",
+ "num-rational",
+ "num-traits",
+ "simba",
+ "typenum",
+]
+
 [[package]]
 name = "native-tls"
 version = "0.2.18"
@@ -8221,6 +8284,15 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd29631678d6fb0903b69223673e122c32e9ae559d0960a38d574695ebc0ea15"

+[[package]]
+name = "safe_arch"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96b02de82ddbe1b636e6170c21be622223aea188ef2e139be0a5b219ec215323"
+dependencies = [
+ "bytemuck",
+]
+
 [[package]]
 name = "safetensors"
 version = "0.4.5"
@@ -8598,6 +8670,19 @@ dependencies = [
 "libc",
 ]

+[[package]]
+name = "simba"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "061507c94fc6ab4ba1c9a0305018408e312e17c041eb63bef8aa726fa33aceae"
+dependencies = [
+ "approx",
+ "num-complex",
+ "num-traits",
+ "paste",
+ "wide",
+]
+
 [[package]]
 name = "simd-adler32"
 version = "0.3.9"
@@ -10203,6 +10288,16 @@ version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"

+[[package]]
+name = "wide"
+version = "0.7.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce5da8ecb62bcd8ec8b7ea19f69a51275e91299be594ea5cc6ef7819e16cd03"
+dependencies = [
+ "bytemuck",
+ "safe_arch",
+]
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,6 +12,7 @@ members = [
    "crates/kebab-embed",
    "crates/kebab-embed-local",
    "crates/kebab-embed-candle",
+    "crates/kebab-embed-ollama",
    "crates/kebab-llm",
    "crates/kebab-llm-local",
    "crates/kebab-rag",
@@ -31,7 +32,7 @@ edition       = "2024"
 rust-version  = "1.85"
 license       = "MIT OR Apache-2.0"
 repository    = "https://github.com/altair823/kebab"
-version       = "0.23.0"   # v0.23.0 — candle Metal(Apple Silicon GPU) opt-in build feature (`--features embed_metal`): M-series 맥에서 e5-large 임베딩을 GPU 로 → 대용량 ingest 가속. macOS 전용, 벡터는 CPU candle 과 호환. default(비-metal) 동작 불변. — CLAUDE.md §Release 도그푸딩 트리거
+version       = "0.27.0"   # v0.27.0 — PP-OCRv5 ONNX Rust 네이티브 OCR 엔진: `[image.ocr] engine = "paddle-onnx"` (default 여전히 "ollama-vision") 로 in-process 검출+인식(`ort` =2.0.0-rc.9, Python 런타임 0). DBNet det + CTC rec, 후처리(min-area rect/unclip)는 pure-Rust. e2e CER 0.005(synthetic 한/영, PoC 0.024 대비 우수), 큰 페이지 CPU <4초(Ollama vision ~50초 대비). 신규 config `det_model`/`rec_model`/`dict`/`score_thresh`/`unclip_ratio`/`max_boxes` + `KEBAB_IMAGE_OCR_*` env. ingest 서명 `|ocr:1:{engine}:{engine_version}` 로 engine/모델 변경 시 자동 재색인. 신규 인터페이스(engine 값/config 키) → minor. — CLAUDE.md §Release

 # pre-v0.18 workspace-wide cleanup: enable clippy::pedantic group with
 # intentional allow-list. The allowed lints are either cosmetic (doc style),
--- a/HANDOFF.md
+++ b/HANDOFF.md
@@ -35,6 +35,11 @@ P0~P5 직렬. P6~P9 P5 이후 병렬 가능.

 머지 후 발견된 모든 deviation / hotfix 의 dated 로그는 [tasks/HOTFIXES.md](tasks/HOTFIXES.md). 본 요약은 \"누군가가 인수받을 때 알아두면 시간을 많이 절약하는\" 항목만:

+- **2026-06-04 PP-OCRv5 ONNX Rust 네이티브 OCR** — v0.27.0. `[image.ocr] engine = "paddle-onnx"` 로 PP-OCRv5(검출+인식) ONNX 를 in-process(`ort` =2.0.0-rc.9) 실행 — Python 런타임/원격 호출 없이 큰 페이지 CPU <4초(Ollama vision ~50초 대비). default 는 여전히 `"ollama-vision"`. 후처리(min-area rect/unclip)는 pure-Rust. **함정**: unclip 은 corner 를 centroid 에서 방사 확장하면 안 되고 edge 별 polygon offset 이어야 함(방사 확장 시 wide/short 텍스트 박스 높이가 안 커져 글자 윗부분 잘림 → ㄷ→ㄴ, e2e CER 0.26). 수정 후 CER 0.005. 모델 ONNX 는 `crates/kebab-parse-image/assets/paddleocr-onnx/`(LFS). 자세한 내용: `tasks/HOTFIXES.md` (2026-06-04 PP-OCRv5 ONNX), spec/plan `docs/superpowers/{specs,plans}/2026-06-04-rust-native-ocr-*.md`.
+- **2026-06-03 ingest 설정 변경 자동 재색인** — v0.26.2. ingest 산출에 영향 주는 설정(청킹/이미지 OCR·caption/pdf.ocr/`[ingest.code]`)을 변경하면 `--force-reingest` 없이 영향 자산만 자동 재색인. 그 설정들의 결정적 서명(`ingest_config_signature`)을 effective parser_version(skip 비교 + 저장 doc 필드 양쪽)에 폴딩 → 다음 ingest 비교가 mismatch. 비산출 설정(search/rag/ui/log + max_pixels/languages/timeout)은 제외(과도 무효화 회피), doc_id 는 base 로 안정 유지. **업그레이드 후 첫 ingest 는 전 자산 1회 재색인**(저장된 상수 parser_version ≠ 새 composite; embedding 은 V012 캐시 히트). 결과 포맷·CLI·wire 불변(내부 skip 판정 정정). 자세한 내용: `tasks/HOTFIXES.md` (2026-06-03 ingest 설정 변경 자동 재색인), spec/plan `docs/superpowers/{specs,plans}/2026-06-03-*invalidation*.md`.
+- **2026-06-03 ingest 진행 로그 개선** — v0.26.1. 이미지/PDF + OCR/caption on 볼트 ingest 가 "멈춘 듯" 보이던 문제 해소: TTY 진행바에 현재 파일명 + 느린 phase(ocr/caption/embed)+모델명 + 경과초 `(Ns)` heartbeat, 종료 시 최장 소요 파일 top-5 요약. 신규 wire `asset_phase{idx,total,phase,model}` + `asset_timings.ocr_ms`/`caption_ms`(additive, `ingest_progress.v1` 유지, serde default 0). 이미지·PDF 경로도 `asset_timings` emit(이전 markdown 만). 기본 동작 불변. 자세한 내용: `tasks/HOTFIXES.md` (2026-06-03 ingest 진행 로그), spec/plan `docs/superpowers/{specs,plans}/2026-06-03-ingest-log-improve-*.md`.
+- **2026-06-03 arctic-embed-l-v2.0 임베더 통합** — v0.26.0. 별칭 제거 후 설명형 query recall 보강(측정 recall@10 130/132, e5 +7). `kebab-embed-candle` 모델 레지스트리화(e5 mean + `snowflake-arctic-embed-l-v2.0` CLS, 모델별 pooling/prefix) + 신규 `kebab-embed-ollama`(`provider="ollama"`, `/api/embed`). config `endpoint: Option<String>` 추가. 기본 e5 유지(opt-in), arctic 전환은 embedding_version cascade → 재색인. candle↔Ollama cosine>0.99 게이트로 pooling/prefix 정확성 고정(`#[ignore]`). 자세한 내용: `tasks/HOTFIXES.md` (2026-06-03 arctic), spec `docs/superpowers/specs/2026-06-03-arctic-embedder-spec.md`.
+- **2026-06-03 doc-side expansion(별칭) 기능 완전 제거** — v0.25.0. 아래 2026-05-31 항목의 색인-시 청크당 LLM 별칭 생성 + 별칭 검색 채널을 **전부 제거**(ROI 음수: cross-lingual 은 e5-large 단독으로 충분, 기여는 설명형 +2 그룹뿐인데 대가가 청크당 색인-시 LLM). `Chunk.aliases`/`expansion.rs`/`IngestExpansionCfg`/alias lexical arm/`expansion_progress` wire kind 제거, 신규 마이그레이션 **V013** 이 `chunk_aliases_fts`+`chunks.aliases` DROP. 별칭 default-off 였어 사용자 체감 0, 기존 KB 도 재색인 불요(잔존 별칭 벡터는 `strip_alias_suffix` graceful 매핑/`reset` 정리). `AssetTimings.expansion_ms` 는 wire 호환 위해 값 0 으로 유지. 자세한 내용: `tasks/HOTFIXES.md` (2026-06-03), spec `docs/superpowers/specs/2026-06-03-remove-doc-expansion-spec.md`.
 - **2026-05-31 Phase 2 doc-side expansion 별칭(개별 dense 벡터) + 파생물 캐시(V012)** — v0.21.0 cut. 색인 시 LLM 이 청크별 별칭("같은 의미 다른 표현")을 생성, 줄별 **개별 dense 벡터**(sentinel `{chunk}#alias#N`)로 색인 (묶음 1벡터는 평균화 희석으로 회귀 → 폐기) + boilerplate 청크 skip. `[ingest.expansion]` default off. 측정(나무위키 ~1000 문서 CS corpus): 변형 일관성 14/18 → **16/18**, spread 0.222→0.111, 대조군 false-positive 별칭 무죄. 비용 병목(별칭 18문서 2.5h)은 **파생물 캐시(V012, 청크 내용 해시 키)**로 해소 — 정답 3개 cold 1879s → warm 13s **≈ 145배**, embedding+별칭 LLM 캐싱, version_key cascade 정합. search/ask 가 `kebab.sqlite`+`lancedb` 만으로 동작 → 외부 서버 색인 후 DB 만 복사하는 이식 워크플로 가능. **결정/known limitation**: grounded/refusal 판정이 부분 인용을 grounded 로 오분류(정직한 거부가 false-positive 로 집계) — 별도 개선 후보. stack·svm 설명형 2개 잔존. 자세한 내용: `tasks/HOTFIXES.md` (2026-05-31), 측정: `docs/superpowers/handoffs/2026-05-31-namu-wiki-alias-cache-study.md`.
 - **2026-05-29 v0.20.2 dogfood findings + 검색 품질 baseline** — 8-finding 라운드 완료. (1) Ask 응답언어: rag-v3 default (질문 언어 = 답변 언어). (2) eval `--config` facade 패치 로 dogfood KB 직접 eval 가능. (3) 검색 품질 baseline — hybrid hit@3=1.0 / MRR=0.833, lexical hit@3=1.0 / MRR=0.7 (golden 10 query). **O-2 known limitation**: 소형 모델(gemma4:e4b) refusal 메시지의 query 언어 불일치 가능 — 판정은 정상, 표시 문구만 해당. 자세한 내용: `tasks/HOTFIXES.md` (2026-05-29).
 - **v0.20 sub-item 1 (scanned PDF OCR via qwen2.5vl:3b)**: post-extract enrichment pattern (`kebab-app::pdf_ocr_apply`, H-1 resolution), DCTDecode-only v1 scope (FlateDecode/CCITTFax page 는 warning + skip), parser_version `"pdf-text-v1"` 보존 + force-reingest UX 명문 (H-4).
--- a/README.md
+++ b/README.md
@@ -41,17 +41,30 @@ clone 없이 git URL 로 바로 설치할 수도 있다: `cargo install --git ht

 lexical (FTS5 BM25) 과 vector (cosine) 두 채널을 **RRF fusion** 으로 합쳐 검색한다. 모든 hit 은 출처 위치를 매체별로 정확히 담는다 — Markdown/코드는 line, 이미지는 region, PDF 는 page. `--tag` · `--media` · `--lang` · `--path-glob` 등 다양한 필터와 `--max-tokens` · `--cursor` 같은 agent budget flag 를 지원한다.

-### doc-side expansion 별칭 (opt-in)
-
-색인 시 각 청크에 대해 "같은 의미의 다른 표현"(동의어 · 약어 · 한↔영 번역 · 풀어쓴 설명) 별칭을 LLM 으로 생성해 별도 dense 벡터로 색인한다. 설명형 query 나 cross-lingual query 의 검색 일관성을 높인다 (나무위키 ~1000 문서 CS corpus 측정: 변형 일관성 14/18 → 16/18, 대조군 false-positive 미유발). 청크당 LLM 호출이 들어 비용이 크므로 **default off** — `[ingest.expansion] enabled = true` 로 opt-in.
-
 ### 파생물 캐시 (자동)

-embedding 벡터와 별칭 LLM 결과를 청크 **내용 해시** 로 캐싱한다 (`derivation_cache`). 재색인·갱신 시 내용이 같은 청크는 재계산을 건너뛴다 (측정: cold 1879s → warm 13s ≈ 145배). 캐시 키에 모델·프롬프트·차원 버전이 포함돼 버전 변경 시 자동 무효화된다 (cascade 안전). 별도 설정 없이 투명하게 동작한다. (현재 TTL/LRU 자동 정리는 미구현 — 누적된 캐시는 `kebab reset` 으로만 정리.)
+embedding 벡터를 청크 **내용 해시** 로 캐싱한다 (`derivation_cache`). 재색인·갱신 시 내용이 같은 청크는 재계산을 건너뛴다. 캐시 키에 모델·차원 버전이 포함돼 버전 변경 시 자동 무효화된다 (cascade 안전). 별도 설정 없이 투명하게 동작한다. (현재 TTL/LRU 자동 정리는 미구현 — 누적된 캐시는 `kebab reset` 으로만 정리.)

 ### 외부 계산 + 로컬 검색 워크플로

-search/ask 는 asset 파일 없이 `kebab.sqlite` + `lancedb` 만으로 동작한다. 비싼 색인(임베딩·OCR·별칭 생성)을 성능 좋은 서버에서 수행한 뒤, 이 두 산출물만 로컬로 복사하면 그대로 검색·질문할 수 있다.
+search/ask 는 원본 파일 없이 KB 산출물만으로 동작한다 (청크 본문이 SQLite 에 저장되고 문서 경로는 상대경로로 기록됨). 비싼 색인(임베딩·OCR)을 성능 좋은 머신에서 수행한 뒤(예: Apple Silicon 맥에서 candle Metal GPU), **두 산출물만** 다른 머신(예: NUMA 서버)으로 복사하면 그대로 검색·질문할 수 있다.
+
+**무엇을 복사하나 — `[storage]` 에서 정의된 두 경로:**
+
+| 복사 대상 | config 키 (`[storage]`) | 기본 경로 | 내용 |
+|-----------|------------------------|-----------|------|
+| `kebab.sqlite` | `sqlite = "{data_dir}/kebab.sqlite"` | `{data_dir}/kebab.sqlite` | 문서·청크·본문·FTS5·메타 |
+| `lancedb/` | `vector_dir = "{data_dir}/lancedb"` | `{data_dir}/lancedb/` | 임베딩 벡터 |
+
+`{data_dir}` 는 `[storage].data_dir` (예: `~/.local/share/kebab`). `models/`(`model_dir`)·`assets/`(`asset_dir`)는 **복사 불필요** — 모델은 각 머신이 자기 캐시를 받고, asset 원본 바이트는 검색·질문에 쓰이지 않는다 (단일파일/`stdin` 색인의 원본 재읽기·재색인까지 보존하려면 `assets/` 도 함께 복사).
+
+```bash
+# ingest 가 끝난(쓰기 없는) 상태에서 복사
+rsync -a <src-data_dir>/kebab.sqlite  user@server:<dst-data_dir>/
+rsync -a <src-data_dir>/lancedb/      user@server:<dst-data_dir>/lancedb/
+```
+
+조건: **양쪽 동일 `kebab` 버전 + 동일 임베딩 모델/차원** (`[models.embedding].model`·`dimensions`). provider 는 달라도 됨 (예: 맥 `candle`/Metal ↔ 서버 `candle`/CPU 또는 `fastembed` — 같은 모델이면 벡터 호환). 복사는 반드시 ingest 가 돌지 않을 때.

 ### 멀티미디어 색인

@@ -70,7 +83,7 @@ Markdown · PDF · 이미지(OCR + caption) · 소스코드(Rust/Python/TS/JS/Go
 | 명령 | 동작 |
 |------|------|
 | `kebab init` | XDG 경로에 데이터 디렉토리 + config.toml 생성 |
-| `kebab ingest [<path>]` | 워크스페이스 스캔 후 새/변경 문서 색인 (idempotent · incremental, `--force-reingest` 로 강제 재처리). 미지원 확장자는 자동 skip |
+| `kebab ingest [<path>]` | 워크스페이스 스캔 후 새/변경 문서 색인 (idempotent · incremental, `--force-reingest` 로 강제 재처리). 미지원 확장자는 자동 skip. 진행바는 현재 **파일명** · 느린 **phase(ocr/caption/embed)+모델명** · **경과초**`(Ns)` · 문서별 청크 수 · phase별 소요시간(parse/chunk/ocr/caption/embed/store)을 표시하고, 종료 시 **최장 소요 파일 top-5** 를 요약한다 (`--json` 은 `asset_phase`/`asset_chunked`/`asset_timings` 이벤트로, 사람용 요약은 미출력) |
 | `kebab ingest-file <path>` | 단일 파일 ingest (workspace 외부 가능 — `_external/` 로 deterministic copy) |
 | `kebab ingest-stdin --title <T>` | stdin 의 markdown 본문 ingest |
 | `kebab search --mode {lexical,vector,hybrid} "<query>" [flags]` | 검색 (default hybrid = RRF fusion, citation 포함). 필터/budget flag 는 `--help` |
@@ -98,18 +111,46 @@ root = "~/KnowledgeBase"   # 색인할 폴더. 절대 / tilde / env / 상대 경

 [models.embedding]
 provider = "fastembed"            # "fastembed"(기본, onnxruntime) / "candle"(순수 Rust)
-                                  # / "none"(lexical-only). candle 는 같은 모델·같은 벡터를
-                                  # 순수 Rust 로 돌려 NUMA 서버의 onnxruntime 48-스레드
-                                  # double-free 를 피하는 opt-in 백엔드 (재색인 불필요).
+                                  # / "ollama"(원격 HTTP) / "none"(lexical-only).
+                                  # candle 는 같은 모델·같은 벡터를 순수 Rust 로 돌려
+                                  # NUMA 서버의 onnxruntime 48-스레드 double-free 를 피하는
+                                  # opt-in 백엔드 (e5 는 재색인 불필요).
 model = "multilingual-e5-large"   # 다국어 sentence embedding (1024-dim).
                                  # 첫 ingest 시 ONNX (~1.3GB) 자동 다운로드.
                                  # candle provider 는 safetensors (~2GB) 다운로드.
+                                  # candle/ollama 는 "snowflake-arctic-embed-l-v2.0"
+                                  # (설명형 query 의 recall 보강) 도 지원 — 아래 참고.
 dimensions = 1024                 # config 와 LanceDB stored dim 불일치 시 검색 0건.
 num_threads = 0                   # candle 전용 CPU 스레드 캡 (0=auto=#cores).
                                  # env KEBAB_EMBED_THREADS 가 우선. NUMA 노드 바인딩은
                                  # numactl 과 조합. fastembed provider 는 무시.
+# endpoint = "http://127.0.0.1:11434"  # provider="ollama" 전용 HTTP endpoint.
+                                  # 생략 시 [models.llm].endpoint 로 폴백.
+                                  # fastembed/candle provider 는 무시.
 ```

+**arctic-embed-l-v2.0 (설명형 query recall 보강)**: 기본 e5-large 대신
+Snowflake `arctic-embed-l-v2.0` 임베더를 쓸 수 있다 (1024-dim, opt-in). 측정에서
+설명형/약어/영문 용어 query 의 recall@10 이 e5 대비 향상됐다. 두 경로:
+
+```toml
+# (A) candle 백엔드 — 순수 Rust, in-process (NUMA 안전, Metal GPU 가능):
+[models.embedding]
+provider = "candle"
+model    = "snowflake-arctic-embed-l-v2.0"   # CLS pooling, query 에 "query: " 접두어
+                                             # (문서는 무접두어). safetensors ~2GB 다운로드.
+
+# (B) ollama 백엔드 — 원격/로컬 Ollama 데몬에 위임 (POST /api/embed):
+[models.embedding]
+provider = "ollama"
+model    = "snowflake-arctic-embed2"          # Ollama 모델 태그 (ollama pull 필요)
+endpoint = "http://127.0.0.1:11434"           # 생략 시 [models.llm].endpoint
+```
+
+> ⚠️ e5 → arctic 전환은 `embedding_version` cascade 를 트리거한다 (모델이 다르면
+> 벡터도 다름). 기존 e5 KB 와 혼용 불가 — 전환 시 **재색인** 필요 (`kebab reset`
+> 후 재 ingest). 기본값은 e5 라 기존 사용자는 영향 없음.
+
 **Apple Silicon GPU 가속 (candle / macOS)**: M-시리즈 맥에서 candle 임베딩을
 GPU(Metal)로 돌리면 CPU 대비 대용량 ingest 가 크게 빨라진다. 빌드 또는 설치 시
 `embed_metal` feature 를 켠다:
@@ -133,11 +174,6 @@ endpoint = "http://localhost:11434"   # Ollama host:port
 model = "gemma4:e4b"
 # request_timeout_secs = 300          # 큰 모델은 늘림. 0 은 disable 이 아니라 "즉시 timeout".

-[ingest.expansion]        # doc-side expansion 별칭 (opt-in)
-enabled = false           # true 면 청크당 LLM 호출로 별칭 생성 — 비용 큼.
-embed_aliases = true      # 별칭을 줄별 개별 dense 벡터로 색인.
-max_aliases_per_chunk = 8
-
 [search]
 stale_threshold_days = 30   # search hit / citation 의 stale 플래그 기준 (0 = off).

@@ -146,9 +182,10 @@ prompt_template_version = "rag-v3"   # 답변 언어 = 질문 언어. rag-v1/v2
 nli_threshold = 0.0                  # >0 (예: 0.5) 면 mDeBERTa XNLI groundedness 검증.
 ```

- **파생물 캐시** — embedding·별칭 결과를 내용 해시로 자동 캐싱한다 (위 「핵심 기능」 참고). 설정 항목 없음.
+- **파생물 캐시** — embedding 결과를 내용 해시로 자동 캐싱한다 (위 「핵심 기능」 참고). 설정 항목 없음.
 - **`[ingest.code]`** — code ingest 의 skip 정책 (`skip_generated_header`, `max_file_bytes`, `extra_skip_globs`). `.gitignore` 자동 honor, `.kebabignore` 는 추가 layer.
- **`[pdf.ocr]`** — scanned PDF 의 page-단위 OCR (default off / opt-in, page 당 ~수십 초 cost). 활성화 후 v0.19 시절 색인분은 `kebab ingest --force-reingest` 로 재처리.
+- **`[image.ocr]`** — 이미지 OCR (default off / opt-in). `engine` 으로 백엔드 선택: `"ollama-vision"` (default, 원격 vision LM) 또는 `"paddle-onnx"` (v0.27.0 신규 — PP-OCRv5 ONNX 를 in-process 로 실행, Python 런타임 불필요, 큰 페이지 CPU <4초, 오프라인). `paddle-onnx` 는 워크스페이스에 번들된 모델을 쓰며 `det_model`/`rec_model`/`dict` 로 경로 override, `score_thresh`(0.3)/`unclip_ratio`(1.5)/`max_boxes`(1000) 로 검출 튜닝 가능 (`KEBAB_IMAGE_OCR_*` env 동일 지원). engine 또는 모델을 바꾸면 영향 이미지가 자동 재색인된다.
+- **`[pdf.ocr]`** — scanned PDF 의 page-단위 OCR (default off / opt-in, page 당 ~수십 초 cost). `engine` 은 `[image.ocr]` 과 동일하게 `"ollama-vision"`/`"paddle-onnx"` 선택. 활성화 후 v0.19 시절 색인분은 `kebab ingest --force-reingest` 로 재처리.
 - **`--config <path>`** — 임시 워크스페이스 / 격리 테스트용 (CLI · TUI 모두 honor).
 - **`kebab config migrate`** — 새 버전에서 추가된 config 섹션을 기존 `config.toml` 에 설명 주석과 함께 채워 넣는다 (사용자가 손본 값·주석·순서는 보존, 멱등, 변경 시 자동 `.bak` 백업). `--dry-run` 으로 변경 미리보기. `kebab doctor` 가 갱신 필요 시 안내한다. `kebab init` 으로 새로 생성되는 config.toml 도 섹션별 주석을 포함한다.
 - **`KEBAB_*` env** — 일부 키 override (`KEBAB_RAG_SCORE_GATE`, `KEBAB_EVAL_GOLDEN` 등).
--- a/crates/kebab-app/Cargo.toml
+++ b/crates/kebab-app/Cargo.toml
@@ -19,6 +19,7 @@ kebab-search = { path = "../kebab-search" }
 kebab-embed = { path = "../kebab-embed" }
 kebab-embed-local = { path = "../kebab-embed-local" }
 kebab-embed-candle = { path = "../kebab-embed-candle" }
+kebab-embed-ollama = { path = "../kebab-embed-ollama" }
 kebab-llm = { path = "../kebab-llm" }
 kebab-llm-local = { path = "../kebab-llm-local" }
 kebab-rag = { path = "../kebab-rag" }
--- a/crates/kebab-app/src/app.rs
+++ b/crates/kebab-app/src/app.rs
@@ -45,6 +45,7 @@ use kebab_core::{
 };
 use kebab_embed_candle::CandleEmbedder;
 use kebab_embed_local::FastembedEmbedder;
+use kebab_embed_ollama::OllamaEmbedder;
 use kebab_llm_local::OllamaLanguageModel;
 use kebab_parse_code::{
    CAstExtractor, CppAstExtractor, GoAstExtractor, JavaAstExtractor, JavascriptAstExtractor,
@@ -834,11 +835,13 @@ impl App {
        if let Some(e) = self.embedder.get() {
            return Ok(Some(e.clone()));
        }
-        // Provider branch (Track 1 spec §3). `embeddings_disabled()` above
-        // already handled `"none"`; here we route the live providers.
-        // `fastembed`/`onnx`/(empty) keep the default onnxruntime path
-        // (vectors unchanged — `embedding_version` is preserved); `candle`
-        // selects the pure-Rust NUMA-safe backend.
+        // Provider branch (Track 1 spec §3 + arctic-embedder spec). The
+        // `embeddings_disabled()` check above already handled `"none"`; here we
+        // route the live providers. `fastembed`/`onnx`/(empty) keep the default
+        // onnxruntime path (vectors unchanged — `embedding_version` is
+        // preserved); `candle` selects the pure-Rust NUMA-safe backend (e5 or
+        // arctic via its model registry); `ollama` offloads to a remote
+        // `/api/embed` daemon.
        let provider = self.config.models.embedding.provider.as_str();
        let emb: Arc<dyn Embedder + Send + Sync> = match provider {
            "fastembed" | "onnx" | "" => Arc::new(
@@ -847,10 +850,13 @@ impl App {
            "candle" => Arc::new(
                CandleEmbedder::new(&self.config).context("kb-app: load CandleEmbedder")?,
            ),
+            "ollama" => Arc::new(
+                OllamaEmbedder::new(&self.config).context("kb-app: load OllamaEmbedder")?,
+            ),
            other => {
                return Err(anyhow!(
                    "kb-app: unknown embedding provider {other:?}; expected one of \
-                     `fastembed` (default), `candle`, or `none` (lexical-only)"
+                     `fastembed` (default), `candle`, `ollama`, or `none` (lexical-only)"
                ));
            }
        };
--- a/crates/kebab-app/src/expansion.rs
+++ b/crates/kebab-app/src/expansion.rs
@@ -1,274 +0,0 @@
-//! 색인시 doc-side expansion (Phase 2) — 청크당 "검색용 별칭" 생성.
-//!
-//! 설계 spec docs/superpowers/specs/2026-05-30-doc-side-expansion-design.md §3.2 / §5.
-
-use kebab_core::{Chunk, GenerateRequest, LanguageModel};
-
-/// 별칭 1줄의 최대 글자 수(이 이상은 문장형/환각으로 보고 drop).
-const MAX_ALIAS_CHARS: usize = 120;
-
-/// 별칭 프롬프트 템플릿 버전. derivation cache 의 alias version_key 에 포함되어
-/// (§3.1), 프롬프트를 바꾸면 bump 해 캐시를 무효화한다(전부 miss → 재생성).
-/// `build_request` 의 gemma 프롬프트와 한 쌍 — 프롬프트 수정 시 함께 bump.
-pub const PROMPT_VERSION: &str = "expansion-v1";
-
-/// 청크당 검색용 별칭을 생성한다.
-///
-/// 반환: 검증·상한 적용된 별칭들을 개행 join 한 문자열. 생성 0개 / LLM
-/// 실패 / 빈 출력이면 `None` (호출측은 chunk.aliases 를 None 으로 두고 진행).
-pub struct ExpansionGenerator<'a> {
-    llm: &'a dyn LanguageModel,
-    max_aliases: usize,
-}
-
-impl<'a> ExpansionGenerator<'a> {
-    pub fn new(llm: &'a dyn LanguageModel, max_aliases: usize) -> Self {
-        Self { llm, max_aliases }
-    }
-
-    /// gemma 프롬프트(expansion-v1)를 구성한다. (self 미사용 — associated fn.)
-    fn build_request(chunk: &Chunk) -> GenerateRequest {
-        let heading = chunk.heading_path.join(" > ");
-        let system = "당신은 검색 색인용 별칭 생성기다. 주어진 문단을 찾을 사용자가 \
-입력할 법한 짧은 검색어/질문을 생성한다. 동의어·풀어쓴 표현을 포함하라. \
-문단이 한국어면 영어 표현도, 영어면 한국어 표현도 섞어라. \
-한 줄에 하나씩, 설명·번호·머리기호 없이 검색어만 출력하라."
-            .to_string();
-        let user = format!(
-            "제목 경로: {heading}\n\n문단:\n{}\n\n검색 별칭(한 줄에 하나):",
-            chunk.text
-        );
-        GenerateRequest {
-            system,
-            user,
-            stop: vec![],
-            max_tokens: 256,
-            temperature: 0.0,
-            seed: Some(0),
-            images: vec![],
-        }
-    }
-
-    pub fn generate(&self, chunk: &Chunk) -> Option<String> {
-        // 나무위키 네비게이션 boilerplate 청크는 LLM 호출 없이 skip — 별칭
-        // 생성 가치가 없고 노이즈 sentinel 벡터만 만든다.
-        if is_nav_boilerplate(chunk) {
-            return None;
-        }
-        let req = Self::build_request(chunk);
-        let raw = match self.llm.generate_stream(req) {
-            Ok(iter) => {
-                let mut acc = String::new();
-                for ch in iter {
-                    match ch {
-                        Ok(kebab_core::TokenChunk::Token(t)) => acc.push_str(&t),
-                        Ok(kebab_core::TokenChunk::Done { .. }) => {}
-                        Err(_) => return None, // fail-soft
-                    }
-                }
-                acc
-            }
-            Err(_) => return None, // fail-soft (connection refused 등)
-        };
-        let aliases = parse_aliases(&raw, self.max_aliases);
-        if aliases.is_empty() {
-            None
-        } else {
-            Some(aliases.join("\n"))
-        }
-    }
-}
-
-/// 나무위키 네비게이션 boilerplate 청크 판정.
-///
-/// heading_path 가 비어 있고(문서 본문 섹션이 아닌 머리/꼬리 nav), text 앞부분에
-/// nav 키워드("최근 변경" 등)가 하나라도 있으면 boilerplate 로 본다. 둘 다
-/// 만족할 때만 true — 정상 본문(heading 있음, 또는 nav 키워드 없음)은 false.
-pub fn is_nav_boilerplate(chunk: &Chunk) -> bool {
-    const NAV_KEYWORDS: [&str; 5] = [
-        "최근 변경",
-        "Recent changes",
-        "최근 토론",
-        "특수 기능",
-        "편집 토론 역사",
-    ];
-    if !chunk.heading_path.is_empty() {
-        return false;
-    }
-    let head: String = chunk.text.chars().take(200).collect();
-    NAV_KEYWORDS.iter().any(|kw| head.contains(kw))
-}
-
-/// 줄 선두의 목록 마커만 1회 제거한다. **마커 뒤 공백이 필수** — 별칭 내용이
-/// 숫자/하이픈/별표로 시작하는 경우(예: "3D 렌더링", "-fast", "2단계")는 보존한다.
-/// (Task 4 리뷰 MAJOR-1: 탐욕적 `trim_start_matches` 가 정당한 별칭을 손상시키던 버그 수정.)
-fn strip_list_marker(s: &str) -> &str {
-    // 1) 머리기호 + 공백 ("- " / "* " / "• ").
-    for marker in ["- ", "* ", "• "] {
-        if let Some(rest) = s.strip_prefix(marker) {
-            return rest.trim_start();
-        }
-    }
-    // 2) 번호 + ('.' | ')') + 공백 ("1. " / "2) "). 마커 뒤 공백이 없으면
-    //    ("3D", "2단계") 번호가 아니라 내용으로 보고 보존.
-    let digit_end = s.find(|c: char| !c.is_ascii_digit()).unwrap_or(s.len());
-    if digit_end > 0 {
-        let after = &s[digit_end..];
-        if let Some(rest) = after.strip_prefix(". ").or_else(|| after.strip_prefix(") ")) {
-            return rest.trim_start();
-        }
-    }
-    s
-}
-
-/// LLM 출력 문자열 → 검증된 별칭 리스트.
-/// 줄 단위 split → trim → 목록 마커 1회 제거 → 빈 줄·과길이 drop →
-/// 중복 제거 → 상한 N.
-fn parse_aliases(raw: &str, max_aliases: usize) -> Vec<String> {
-    let mut out: Vec<String> = Vec::new();
-    for line in raw.lines() {
-        let t = strip_list_marker(line.trim());
-        if t.is_empty() || t.chars().count() > MAX_ALIAS_CHARS {
-            continue;
-        }
-        let s = t.to_string();
-        if !out.contains(&s) {
-            out.push(s);
-        }
-        if out.len() >= max_aliases {
-            break;
-        }
-    }
-    out
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use kebab_core::{ChunkId, ChunkerVersion, DocumentId, FinishReason, TokenUsage};
-    use kebab_llm::MockLanguageModel;
-
-    fn mk_chunk(text: &str) -> Chunk {
-        Chunk {
-            chunk_id: ChunkId("c1".into()),
-            doc_id: DocumentId("d1".into()),
-            block_ids: vec![],
-            text: text.into(),
-            heading_path: vec!["Guide".into()],
-            source_spans: vec![],
-            token_estimate: 3,
-            chunker_version: ChunkerVersion("md-heading-v1".into()),
-            policy_hash: "h".into(),
-            tokenized_korean_text: None,
-            aliases: None,
-        }
-    }
-
-    fn mock(resp: &str) -> MockLanguageModel {
-        MockLanguageModel {
-            model_id: "gemma4:e4b".into(),
-            provider: "ollama".into(),
-            context_tokens: 32768,
-            canned_response: resp.into(),
-            canned_finish: FinishReason::Stop,
-            canned_usage: TokenUsage {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                latency_ms: 0,
-            },
-        }
-    }
-
-    #[test]
-    fn parses_lines_strips_bullets_and_caps() {
-        let llm = mock("- 메모리 안전성\n1. who owns the value\nborrow checker\n\n* 소유권");
-        let generator = ExpansionGenerator::new(&llm, 2);
-        let out = generator.generate(&mk_chunk("Rust ownership")).unwrap();
-        // 상한 2 → 앞 2개만, 접두 제거됨.
-        assert_eq!(out, "메모리 안전성\nwho owns the value");
-    }
-
-    #[test]
-    fn drops_overlong_lines() {
-        let long = "x".repeat(200);
-        let llm = mock(&format!("{long}\n짧은 별칭"));
-        let generator = ExpansionGenerator::new(&llm, 8);
-        let out = generator.generate(&mk_chunk("t")).unwrap();
-        assert_eq!(out, "짧은 별칭", "120자 초과 줄은 drop");
-    }
-
-    #[test]
-    fn empty_output_returns_none() {
-        let llm = mock("   \n\n");
-        let generator = ExpansionGenerator::new(&llm, 8);
-        assert_eq!(generator.generate(&mk_chunk("t")), None);
-    }
-
-    /// Task 4 리뷰 MAJOR-1 회귀: 숫자/하이픈/별표로 시작하는 정당한 별칭은
-    /// 손상 없이 보존돼야 한다(목록 마커는 마커 뒤 공백이 있을 때만 제거).
-    #[test]
-    fn preserves_numeric_and_dash_leading_aliases() {
-        let llm = mock("3D 렌더링\n2단계 커밋\n-fast 플래그\n- 메모리 안전성\n1. 첫 항목");
-        let generator = ExpansionGenerator::new(&llm, 8);
-        let out = generator.generate(&mk_chunk("graphics")).unwrap();
-        // 마커 없는 선두 숫자/하이픈은 보존; "- "/"1. " 만 마커로 제거.
-        assert_eq!(out, "3D 렌더링\n2단계 커밋\n-fast 플래그\n메모리 안전성\n첫 항목");
-    }
-
-    fn mk_chunk_nav(text: &str, heading: Vec<String>) -> Chunk {
-        let mut c = mk_chunk(text);
-        c.heading_path = heading;
-        c
-    }
-
-    #[test]
-    fn nav_boilerplate_skips_alias_generation() {
-        // heading 없음 + nav 키워드 → boilerplate → LLM 호출 전에 None.
-        let llm = mock("별칭1\n별칭2");
-        let generator = ExpansionGenerator::new(&llm, 8);
-        let chunk = mk_chunk_nav("최근 변경 최근 토론 특수 기능", vec![]);
-        assert_eq!(generator.generate(&chunk), None);
-    }
-
-    #[test]
-    fn normal_body_chunk_generates_aliases() {
-        // heading 없지만 nav 키워드도 없음 → 정상 본문 → 별칭 생성.
-        let llm = mock("별칭1\n별칭2");
-        let generator = ExpansionGenerator::new(&llm, 8);
-        let chunk = mk_chunk_nav("러스트의 소유권과 빌림 검사기 개요", vec![]);
-        assert_eq!(generator.generate(&chunk).unwrap(), "별칭1\n별칭2");
-    }
-
-    #[test]
-    fn nav_keyword_with_heading_is_not_boilerplate() {
-        // nav 키워드가 있어도 heading 이 있으면 본문 섹션 → 생성.
-        let llm = mock("별칭1");
-        let generator = ExpansionGenerator::new(&llm, 8);
-        let chunk = mk_chunk_nav("최근 변경 내역 설명", vec!["문서 변경사항".into()]);
-        assert_eq!(generator.generate(&chunk).unwrap(), "별칭1");
-    }
-
-    #[test]
-    fn is_nav_boilerplate_unit() {
-        assert!(is_nav_boilerplate(&mk_chunk_nav("Recent changes list", vec![])));
-        assert!(is_nav_boilerplate(&mk_chunk_nav("편집 토론 역사", vec![])));
-        assert!(!is_nav_boilerplate(&mk_chunk_nav("일반 본문 텍스트", vec![])));
-        assert!(!is_nav_boilerplate(&mk_chunk_nav(
-            "최근 변경",
-            vec!["섹션".into()]
-        )));
-    }
-
-    #[test]
-    fn strip_list_marker_unit() {
-        assert_eq!(strip_list_marker("- 메모리"), "메모리");
-        assert_eq!(strip_list_marker("* 소유권"), "소유권");
-        assert_eq!(strip_list_marker("1. who owns"), "who owns");
-        assert_eq!(strip_list_marker("2) 항목"), "항목");
-        // 마커 뒤 공백 없음 → 보존.
-        assert_eq!(strip_list_marker("3D 렌더링"), "3D 렌더링");
-        assert_eq!(strip_list_marker("-fast"), "-fast");
-        assert_eq!(strip_list_marker("2단계"), "2단계");
-        assert_eq!(strip_list_marker("2.0 릴리스"), "2.0 릴리스");
-    }
-}
--- a/crates/kebab-app/src/ingest_progress.rs
+++ b/crates/kebab-app/src/ingest_progress.rs
@@ -47,11 +47,19 @@ pub struct AggregateCounts {
 ///
 /// ```text
 /// ScanStarted < ScanCompleted
-///   < (AssetStarted [< (PdfOcrStarted < PdfOcrFinished)*] < AssetFinished)*
+///   < ( AssetStarted
+///         [< (PdfOcrStarted < PdfOcrFinished)*]
+///         [< AssetChunked]
+///         [< AssetTimings]
+///       < AssetFinished )*
 ///   < (Completed | Aborted)
 /// ```
 ///
-/// `[]` = optional, per-PDF asset only (v0.20.0 sub-item 1).
+/// `[]` = optional. `PdfOcr*` is per-PDF asset only (v0.20.0 sub-item 1).
+/// `AssetChunked` / `AssetTimings` are the v0.24.0 asset-internal phase
+/// events: `AssetChunked` fires once right after chunking (markdown /
+/// image / PDF); `AssetTimings` reports per-phase wall-clock once
+/// (markdown only).
 ///
 /// Embed-batch events (`embed_batch_started` / `embed_batch_finished`
 /// in §2.4a) are reserved for a future iteration and are not emitted
@@ -82,6 +90,52 @@ pub enum IngestEvent {
        result: IngestItemKind,
        chunks: u32,
    },
+    /// v0.24.0 (additive): emitted right after an asset is chunked, before
+    /// expansion / embed / store. Surfaces "this document is N chunks"
+    /// immediately so a single large document no longer looks frozen at
+    /// `idx/total` while its per-chunk phases churn. `chunks` is the chunk
+    /// count for asset `idx`.
+    AssetChunked { idx: u32, total: u32, chunks: u32 },
+    /// v0.26.1 (additive): emitted when an asset enters a *slow* internal
+    /// phase, so the interactive progress bar can show **which** phase
+    /// (and which model) is currently running instead of looking frozen.
+    /// `phase` ∈ {`"ocr"`, `"caption"`, `"embed"`}; short phases
+    /// (parse / chunk / store) are intentionally *not* emitted to avoid
+    /// noise. `model` is the model performing the phase — the vision LLM
+    /// id for `ocr` / `caption`, the embedder `model_id` for `embed`
+    /// (`None` when the phase runs without a configured model, e.g. embed
+    /// with no embedder wired). Emitted once per (asset, phase); no
+    /// throttle needed (low frequency). Wire v1 consumers that predate
+    /// this variant simply ignore the unknown `asset_phase` kind.
+    AssetPhase {
+        idx: u32,
+        total: u32,
+        phase: String,
+        model: Option<String>,
+    },
+    /// v0.24.0 (additive): per-phase wall-clock (milliseconds) for asset
+    /// `idx`, emitted once the asset's pipeline finishes. Lets a user see
+    /// *where* the time went (parse / chunk / ocr / caption / embed /
+    /// store) without parsing logs. The markdown path leaves `ocr_ms` /
+    /// `caption_ms` at 0 (no image analysis); the image / PDF paths fill
+    /// them so the slowest-asset summary attributes vision-model time
+    /// correctly. `expansion_ms` is retained for wire compatibility but is
+    /// always 0 since doc-side expansion was removed (HOTFIXES 2026-06-03).
+    /// `ocr_ms` / `caption_ms` (v0.26.1) are additive with serde default 0
+    /// so pre-v0.26.1 consumers deserialize cleanly.
+    AssetTimings {
+        idx: u32,
+        total: u32,
+        parse_ms: u64,
+        chunk_ms: u64,
+        expansion_ms: u64,
+        embed_ms: u64,
+        store_ms: u64,
+        #[serde(default)]
+        ocr_ms: u64,
+        #[serde(default)]
+        caption_ms: u64,
+    },
    /// Run finished normally. `counts` is the final aggregate.
    Completed { counts: AggregateCounts },
    /// Run finished by user cancellation. `counts` is the partial
@@ -199,6 +253,121 @@ mod tests {
        assert_eq!(v.get("media").and_then(|s| s.as_str()), Some("markdown"));
    }

+    #[test]
+    fn asset_chunked_serializes_with_discriminator() {
+        // v0.24.0 additive variant — `kind` must be snake_case
+        // `asset_chunked` so wire v1 consumers branch on it cleanly.
+        let ev = IngestEvent::AssetChunked {
+            idx: 3,
+            total: 10,
+            chunks: 142,
+        };
+        let v = serde_json::to_value(&ev).unwrap();
+        assert_eq!(
+            v.get("kind").and_then(|s| s.as_str()),
+            Some("asset_chunked")
+        );
+        assert_eq!(v.get("idx").and_then(serde_json::Value::as_u64), Some(3));
+        assert_eq!(
+            v.get("chunks").and_then(serde_json::Value::as_u64),
+            Some(142)
+        );
+    }
+
+    #[test]
+    fn asset_timings_serializes_all_phase_fields() {
+        let ev = IngestEvent::AssetTimings {
+            idx: 2,
+            total: 7,
+            parse_ms: 12,
+            chunk_ms: 3,
+            expansion_ms: 45_000,
+            embed_ms: 800,
+            store_ms: 20,
+            ocr_ms: 1_200,
+            caption_ms: 3_400,
+        };
+        let v = serde_json::to_value(&ev).unwrap();
+        assert_eq!(
+            v.get("kind").and_then(|s| s.as_str()),
+            Some("asset_timings")
+        );
+        // All phase fields are present (plain u64, always serialized).
+        for (field, want) in [
+            ("parse_ms", 12u64),
+            ("chunk_ms", 3),
+            ("expansion_ms", 45_000),
+            ("embed_ms", 800),
+            ("store_ms", 20),
+            ("ocr_ms", 1_200),
+            ("caption_ms", 3_400),
+        ] {
+            assert_eq!(
+                v.get(field).and_then(serde_json::Value::as_u64),
+                Some(want),
+                "field {field}"
+            );
+        }
+    }
+
+    #[test]
+    fn asset_timings_ocr_caption_default_to_zero_for_legacy_wire() {
+        // v0.26.1 additive: a pre-v0.26.1 wire payload omits ocr_ms /
+        // caption_ms; serde `default` must fill 0 so old producers stay
+        // compatible.
+        let legacy = serde_json::json!({
+            "kind": "asset_timings",
+            "idx": 1, "total": 1,
+            "parse_ms": 5, "chunk_ms": 2, "expansion_ms": 0,
+            "embed_ms": 10, "store_ms": 3
+        });
+        let ev: IngestEvent = serde_json::from_value(legacy).unwrap();
+        match ev {
+            IngestEvent::AssetTimings {
+                ocr_ms,
+                caption_ms,
+                embed_ms,
+                ..
+            } => {
+                assert_eq!(ocr_ms, 0);
+                assert_eq!(caption_ms, 0);
+                assert_eq!(embed_ms, 10);
+            }
+            other => panic!("unexpected event: {other:?}"),
+        }
+    }
+
+    #[test]
+    fn asset_phase_serializes_with_discriminator() {
+        // v0.26.1 additive variant — `kind` must be snake_case
+        // `asset_phase`, `phase` is the slow-phase label, `model` the
+        // model id (nullable).
+        let ev = IngestEvent::AssetPhase {
+            idx: 4,
+            total: 12,
+            phase: "ocr".into(),
+            model: Some("gemma4:e4b".into()),
+        };
+        let v = serde_json::to_value(&ev).unwrap();
+        assert_eq!(v.get("kind").and_then(|s| s.as_str()), Some("asset_phase"));
+        assert_eq!(v.get("idx").and_then(serde_json::Value::as_u64), Some(4));
+        assert_eq!(v.get("phase").and_then(|s| s.as_str()), Some("ocr"));
+        assert_eq!(v.get("model").and_then(|s| s.as_str()), Some("gemma4:e4b"));
+    }
+
+    #[test]
+    fn asset_phase_model_none_serializes_as_null() {
+        let ev = IngestEvent::AssetPhase {
+            idx: 1,
+            total: 1,
+            phase: "embed".into(),
+            model: None,
+        };
+        let v = serde_json::to_value(&ev).unwrap();
+        assert_eq!(v.get("phase").and_then(|s| s.as_str()), Some("embed"));
+        assert!(v.get("model").is_some_and(serde_json::Value::is_null));
+    }
+
    #[test]
    fn ingest_event_completed_has_counts() {
        let ev = IngestEvent::Completed {
--- a/crates/kebab-app/src/lib.rs
+++ b/crates/kebab-app/src/lib.rs
--- a/crates/kebab-app/tests/code_ingest_smoke.rs
+++ b/crates/kebab-app/tests/code_ingest_smoke.rs
@@ -52,7 +52,9 @@ fn rust_file_ingests_and_searches_as_code_citation() {
        "at least one chunk expected: {code_item:?}"
    );
    assert_eq!(
-        code_item.parser_version.as_ref().map(|p| p.0.as_str()),
+        code_item.parser_version
+            .as_ref()
+            .map(|p| p.0.split('|').next().unwrap()),
        Some("code-rust-v1"),
        "parser_version must be code-rust-v1"
    );
@@ -185,7 +187,9 @@ fn python_file_ingests_and_searches_as_code_citation() {
        .find(|i| i.doc_path.0.ends_with("metrics.py"))
        .expect("metrics.py item");
    assert_eq!(
-        py_item.parser_version.as_ref().map(|p| p.0.as_str()),
+        py_item.parser_version
+            .as_ref()
+            .map(|p| p.0.split('|').next().unwrap()),
        Some("code-python-v1"),
        "parser_version must be code-python-v1"
    );
@@ -261,7 +265,9 @@ fn typescript_file_ingests_and_searches_as_code_citation() {
        .find(|i| i.doc_path.0.ends_with("Foo.ts"))
        .expect("Foo.ts item");
    assert_eq!(
-        ts_item.parser_version.as_ref().map(|p| p.0.as_str()),
+        ts_item.parser_version
+            .as_ref()
+            .map(|p| p.0.split('|').next().unwrap()),
        Some("code-ts-v1"),
        "parser_version must be code-ts-v1"
    );
@@ -337,7 +343,9 @@ fn javascript_file_ingests_and_searches_as_code_citation() {
        .find(|i| i.doc_path.0.ends_with("Bar.js"))
        .expect("Bar.js item");
    assert_eq!(
-        js_item.parser_version.as_ref().map(|p| p.0.as_str()),
+        js_item.parser_version
+            .as_ref()
+            .map(|p| p.0.split('|').next().unwrap()),
        Some("code-js-v1"),
        "parser_version must be code-js-v1"
    );
@@ -415,7 +423,9 @@ fn go_file_ingests_and_searches_as_code_citation() {
        .find(|i| i.doc_path.0.ends_with("ast.go"))
        .expect("ast.go item present");
    assert_eq!(
-        go_item.parser_version.as_ref().map(|p| p.0.as_str()),
+        go_item.parser_version
+            .as_ref()
+            .map(|p| p.0.split('|').next().unwrap()),
        Some("code-go-v1"),
        "parser_version must be code-go-v1"
    );
@@ -486,7 +496,9 @@ fn java_file_ingests_and_searches_as_code_citation() {
        .find(|i| i.doc_path.0.ends_with("Foo.java"))
        .expect("Foo.java item present");
    assert_eq!(
-        java_item.parser_version.as_ref().map(|p| p.0.as_str()),
+        java_item.parser_version
+            .as_ref()
+            .map(|p| p.0.split('|').next().unwrap()),
        Some("code-java-v1"),
        "parser_version must be code-java-v1"
    );
@@ -561,7 +573,9 @@ fn kotlin_file_ingests_and_searches_as_code_citation() {
        .find(|i| i.doc_path.0.ends_with("Foo.kt"))
        .expect("Foo.kt item present");
    assert_eq!(
-        kt_item.parser_version.as_ref().map(|p| p.0.as_str()),
+        kt_item.parser_version
+            .as_ref()
+            .map(|p| p.0.split('|').next().unwrap()),
        Some("code-kotlin-v1"),
        "parser_version must be code-kotlin-v1"
    );
@@ -634,7 +648,9 @@ fn tier2_k8s_yaml_ingest_searchable() {
        .find(|i| i.doc_path.0.ends_with("deploy.yaml"))
        .expect("deploy.yaml item present");
    assert_eq!(
-        yaml_item.parser_version.as_ref().map(|p| p.0.as_str()),
+        yaml_item.parser_version
+            .as_ref()
+            .map(|p| p.0.split('|').next().unwrap()),
        Some("none-v1"),
        "parser_version must be none-v1"
    );
@@ -717,7 +733,9 @@ fn tier2_dockerfile_ingest_searchable() {
        .find(|i| i.doc_path.0.ends_with("Dockerfile"))
        .expect("Dockerfile item present");
    assert_eq!(
-        df_item.parser_version.as_ref().map(|p| p.0.as_str()),
+        df_item.parser_version
+            .as_ref()
+            .map(|p| p.0.split('|').next().unwrap()),
        Some("none-v1"),
        "parser_version must be none-v1"
    );
@@ -800,7 +818,9 @@ fn tier2_cargo_toml_ingest_searchable() {
        .find(|i| i.doc_path.0.ends_with("Cargo.toml"))
        .expect("Cargo.toml item present");
    assert_eq!(
-        toml_item.parser_version.as_ref().map(|p| p.0.as_str()),
+        toml_item.parser_version
+            .as_ref()
+            .map(|p| p.0.split('|').next().unwrap()),
        Some("none-v1"),
        "parser_version must be none-v1"
    );
@@ -883,7 +903,9 @@ fn tier3_shell_ingest_searchable() {
        .find(|i| i.doc_path.0.ends_with("deploy.sh"))
        .expect("deploy.sh item present");
    assert_eq!(
-        sh_item.parser_version.as_ref().map(|p| p.0.as_str()),
+        sh_item.parser_version
+            .as_ref()
+            .map(|p| p.0.split('|').next().unwrap()),
        Some("none-v1"),
        "parser_version must be none-v1 for shell (Tier 3 direct)"
    );
@@ -974,7 +996,9 @@ fn tier3_yaml_fallback_picks_up_non_k8s_yaml() {
        .find(|i| i.doc_path.0.ends_with("docker-compose.yml"))
        .expect("docker-compose.yml item present");
    assert_eq!(
-        yaml_item.parser_version.as_ref().map(|p| p.0.as_str()),
+        yaml_item.parser_version
+            .as_ref()
+            .map(|p| p.0.split('|').next().unwrap()),
        Some("none-v1"),
        "parser_version must be none-v1 after Tier 3 fallback"
    );
@@ -1144,7 +1168,9 @@ fn tier1_c_ingest_searchable() {
        .find(|i| i.doc_path.0.ends_with("parser.c"))
        .expect("parser.c item present");
    assert_eq!(
-        c_item.parser_version.as_ref().map(|p| p.0.as_str()),
+        c_item.parser_version
+            .as_ref()
+            .map(|p| p.0.split('|').next().unwrap()),
        Some("code-c-v2"),
        "parser_version must be code-c-v2 (v0.17.0 PR-B: typedef-wrapped struct/enum/union 이 typedef alias unit 으로 방출)"
    );
@@ -1228,7 +1254,9 @@ fn tier1_cpp_ingest_searchable() {
        .find(|i| i.doc_path.0.ends_with("chunker.cpp"))
        .expect("chunker.cpp item present");
    assert_eq!(
-        cpp_item.parser_version.as_ref().map(|p| p.0.as_str()),
+        cpp_item.parser_version
+            .as_ref()
+            .map(|p| p.0.split('|').next().unwrap()),
        Some("code-cpp-v1"),
        "parser_version must be code-cpp-v1"
    );
--- a/crates/kebab-app/tests/common/mock_ocr.rs
+++ b/crates/kebab-app/tests/common/mock_ocr.rs
@@ -39,6 +39,11 @@ impl OcrEngine for MockOcrEngine {
        "mock-v1".to_string()
    }

+    #[allow(clippy::unnecessary_literal_bound)]
+    fn model(&self) -> &str {
+        "mock-model"
+    }
+
    fn recognize(&self, _img: &[u8], _hint: Option<&Lang>) -> Result<OcrText> {
        if self.fail {
            anyhow::bail!("mock failure");
--- a/crates/kebab-app/tests/config_invalidation.rs
+++ b/crates/kebab-app/tests/config_invalidation.rs
@@ -0,0 +1,148 @@
+//! v0.26.2: ingest-config invalidation — changing a setting that affects
+//! ingest output auto-re-indexes the affected assets on the next ingest
+//! (no `--force-reingest`), while changing an unrelated setting does not.
+//!
+//! These end-to-end tests exercise the model-free signals (chunking +
+//! `[ingest.code]` options vs `search` settings). The exhaustive per-setting
+//! mapping (image OCR / caption, pdf.ocr, code options, search/rag/ui
+//! invariance) is unit-tested in
+//! `kebab-app/src/lib.rs::ingest_config_signature_tests` — those toggles
+//! (OCR/caption) require a live vision endpoint to ingest, so the wiring is
+//! verified here via the signature-driven chunking path that shares the same
+//! `effective_parser_version` plumbing.
+
+mod common;
+
+use common::TestEnv;
+
+use kebab_app::{IngestOpts, ingest_with_config, ingest_with_config_opts};
+use kebab_core::IngestItemKind;
+
+/// Seed a workspace with a markdown + a rust file so both the markdown and
+/// the code ingest paths are exercised. Returns the first-ingest report.
+fn seed_and_first_ingest(env: &TestEnv) -> kebab_core::IngestReport {
+    std::fs::write(
+        env.workspace_root.join("demo.rs"),
+        "/// adds two integers\npub fn add(a: i32, b: i32) -> i32 {\n    a + b\n}\n",
+    )
+    .unwrap();
+    let first = ingest_with_config(env.config.clone(), env.scope(), false).expect("first ingest");
+    assert_eq!(first.errors, 0, "first ingest must not error: {first:?}");
+    assert!(first.new >= 1, "first ingest creates docs: {first:?}");
+    assert_eq!(first.unchanged, 0, "first ingest has no unchanged: {first:?}");
+    first
+}
+
+fn reingest(env: &TestEnv) -> kebab_core::IngestReport {
+    ingest_with_config_opts(env.config.clone(), env.scope(), false, IngestOpts::default())
+        .expect("re-ingest")
+}
+
+/// Re-running with the identical config skips every asset (no spurious
+/// re-index). Regression guard for over-invalidation.
+#[test]
+fn identical_config_skips_all_assets() {
+    let env = TestEnv::lexical_only();
+    let first = seed_and_first_ingest(&env);
+    let scanned = first.scanned;
+
+    let second = reingest(&env);
+    assert_eq!(second.scanned, scanned);
+    assert_eq!(second.new, 0, "no new docs: {second:?}");
+    assert_eq!(second.updated, 0, "nothing re-indexed: {second:?}");
+    assert_eq!(second.unchanged, scanned, "every doc Unchanged: {second:?}");
+    assert_eq!(second.errors, 0);
+}
+
+/// Changing a common chunking parameter re-indexes EVERY media type
+/// (markdown + code here) without `--force-reingest`.
+#[test]
+fn chunking_change_reindexes_all_types() {
+    let mut env = TestEnv::lexical_only();
+    let first = seed_and_first_ingest(&env);
+    let scanned = first.scanned;
+
+    // Bump target_tokens — folds into every type's signature.
+    env.config.chunking.target_tokens += 100;
+
+    let second = reingest(&env);
+    assert_eq!(second.scanned, scanned);
+    assert_eq!(second.new, 0, "no new docs: {second:?}");
+    assert_eq!(
+        second.unchanged, 0,
+        "chunking change must re-index all: {second:?}"
+    );
+    assert_eq!(
+        second.updated, scanned,
+        "every doc re-indexed as Updated: {second:?}"
+    );
+    assert_eq!(second.errors, 0);
+}
+
+/// Changing an `[ingest.code]` option re-indexes only the code asset; the
+/// markdown assets stay Unchanged.
+#[test]
+fn code_option_change_reindexes_code_only() {
+    let mut env = TestEnv::lexical_only();
+    let first = seed_and_first_ingest(&env);
+    let scanned = first.scanned;
+
+    // Raise max_file_lines (keeps the tiny demo.rs in-scope; only the code
+    // signature changes).
+    env.config.ingest.code.max_file_lines += 1000;
+
+    let second = reingest(&env);
+    assert_eq!(second.scanned, scanned);
+    assert_eq!(second.new, 0, "no new docs: {second:?}");
+    assert_eq!(second.errors, 0);
+    assert_eq!(
+        second.updated, 1,
+        "exactly the code asset re-indexed: {second:?}"
+    );
+    assert_eq!(
+        second.unchanged,
+        scanned - 1,
+        "all markdown assets stay Unchanged: {second:?}"
+    );
+
+    let items = second.items.as_ref().expect("items present");
+    let code = items
+        .iter()
+        .find(|i| i.doc_path.0.ends_with("demo.rs"))
+        .expect("demo.rs item");
+    assert_eq!(
+        code.kind,
+        IngestItemKind::Updated,
+        "demo.rs must be re-indexed: {code:?}"
+    );
+    for i in items.iter().filter(|i| i.doc_path.0.ends_with(".md")) {
+        assert_eq!(
+            i.kind,
+            IngestItemKind::Unchanged,
+            "markdown must be Unchanged: {i:?}"
+        );
+    }
+}
+
+/// Regression guard: changing a non-ingest setting (`search.default_k`) does
+/// NOT re-index anything.
+#[test]
+fn search_setting_change_reindexes_nothing() {
+    let mut env = TestEnv::lexical_only();
+    let first = seed_and_first_ingest(&env);
+    let scanned = first.scanned;
+
+    env.config.search.default_k += 5;
+    env.config.search.snippet_chars += 50;
+    env.config.rag.score_gate = 0.5;
+
+    let second = reingest(&env);
+    assert_eq!(second.scanned, scanned);
+    assert_eq!(
+        second.unchanged, scanned,
+        "search/rag changes must not re-index: {second:?}"
+    );
+    assert_eq!(second.updated, 0, "nothing re-indexed: {second:?}");
+    assert_eq!(second.new, 0);
+    assert_eq!(second.errors, 0);
+}
--- a/crates/kebab-app/tests/config_migrate.rs
+++ b/crates/kebab-app/tests/config_migrate.rs
@@ -29,7 +29,7 @@ fn migrate_writes_backup_and_atomic_with_dry_run_noop() {
    assert!(dir.path().join("config.toml.bak").exists());
    let new = fs::read_to_string(&cfg).unwrap();
    assert!(!new.contains("include"));
-    assert!(new.contains("[ingest.expansion]"));
+    assert!(new.contains("[ingest.code]"));

    // 멱등: 재실행 changed=false.
    let report = kebab_app::config_migrate_with_config_path(Some(&cfg), false).unwrap();
@@ -47,8 +47,11 @@ fn migrate_missing_file_errors() {
 fn annotated_default_serialization_contains_section_comments() {
    let doc = kebab_config::migrate::annotated_default_document();
    let text = doc.to_string();
-    assert!(text.contains("doc-side 별칭"), "section comment missing:\n{text}");
-    assert!(text.contains("[ingest.expansion]"));
+    assert!(
+        text.contains("code ingest skip 정책"),
+        "section comment missing:\n{text}"
+    );
+    assert!(text.contains("[ingest.code]"));
 }

 #[test]
--- a/crates/kebab-app/tests/ingest_progress.rs
+++ b/crates/kebab-app/tests/ingest_progress.rs
@@ -69,40 +69,74 @@ fn progress_event_sequence_matches_design_section_2_4a() {
        other => panic!("expected Completed last, got {other:?}"),
    }

-    // Middle: 3 AssetStarted/AssetFinished pairs in monotonic idx order.
-    let asset_events: Vec<&IngestEvent> = events[2..events.len() - 1].iter().collect();
-    assert_eq!(
-        asset_events.len(),
-        6,
-        "expected 3 (Started + Finished) pairs, got {asset_events:?}"
-    );
-    for (chunk_idx, pair) in asset_events.chunks(2).enumerate() {
-        let expected_idx = chunk_idx as u32 + 1;
-        match (pair[0], pair[1]) {
-            (
-                IngestEvent::AssetStarted {
-                    idx: si,
-                    total: st,
-                    media,
-                    ..
-                },
-                IngestEvent::AssetFinished {
-                    idx: fi,
-                    total: ft,
-                    result,
-                    chunks,
-                },
-            ) => {
-                assert_eq!(*si, expected_idx, "Started idx mismatch: {pair:?}");
-                assert_eq!(*fi, expected_idx, "Finished idx mismatch: {pair:?}");
-                assert_eq!(*st, 3, "Started total mismatch");
-                assert_eq!(*ft, 3, "Finished total mismatch");
-                assert_eq!(media, "markdown", "fixture is markdown only");
-                assert_eq!(*result, IngestItemKind::New, "first ingest → New");
-                assert!(*chunks >= 1, "chunks: {pair:?}");
+    // Middle (v0.24.0 ordering invariant §2.4a): per asset the stream is
+    //   AssetStarted < AssetChunked < [ExpansionProgress*] < AssetTimings
+    //     < AssetFinished
+    // Expansion is disabled in the lexical fixture, so no ExpansionProgress
+    // frames appear here — but AssetChunked + AssetTimings are emitted for
+    // every markdown asset.
+    let middle = &events[2..events.len() - 1];
+
+    // 3 AssetStarted events, monotonic idx 1..=3, all markdown, total = 3.
+    let started: Vec<u32> = middle
+        .iter()
+        .filter_map(|e| match e {
+            IngestEvent::AssetStarted {
+                idx, total, media, ..
+            } => {
+                assert_eq!(*total, 3, "Started total mismatch: {e:?}");
+                assert_eq!(media, "markdown", "fixture is markdown only: {e:?}");
+                Some(*idx)
            }
-            other => panic!("expected Started+Finished pair, got {other:?}"),
-        }
+            _ => None,
+        })
+        .collect();
+    assert_eq!(started, vec![1, 2, 3], "AssetStarted idx order: {middle:?}");
+
+    // 3 AssetFinished events, monotonic idx 1..=3, each New with ≥1 chunk.
+    let finished: Vec<u32> = middle
+        .iter()
+        .filter_map(|e| match e {
+            IngestEvent::AssetFinished {
+                idx,
+                total,
+                result,
+                chunks,
+            } => {
+                assert_eq!(*total, 3, "Finished total mismatch: {e:?}");
+                assert_eq!(*result, IngestItemKind::New, "first ingest → New: {e:?}");
+                assert!(*chunks >= 1, "chunks: {e:?}");
+                Some(*idx)
+            }
+            _ => None,
+        })
+        .collect();
+    assert_eq!(finished, vec![1, 2, 3], "AssetFinished idx order: {middle:?}");
+
+    // v0.24.0 additive events: exactly one AssetChunked + one AssetTimings
+    // per asset, each strictly bracketed by that asset's Started / Finished.
+    for target in 1u32..=3 {
+        let started_at = middle
+            .iter()
+            .position(|e| matches!(e, IngestEvent::AssetStarted { idx, .. } if *idx == target))
+            .unwrap_or_else(|| panic!("missing AssetStarted for idx {target}: {middle:?}"));
+        let finished_at = middle
+            .iter()
+            .position(|e| matches!(e, IngestEvent::AssetFinished { idx, .. } if *idx == target))
+            .unwrap_or_else(|| panic!("missing AssetFinished for idx {target}: {middle:?}"));
+        let chunked_at = middle
+            .iter()
+            .position(|e| matches!(e, IngestEvent::AssetChunked { idx, chunks, .. } if *idx == target && *chunks >= 1))
+            .unwrap_or_else(|| panic!("missing AssetChunked for idx {target}: {middle:?}"));
+        let timings_at = middle
+            .iter()
+            .position(|e| matches!(e, IngestEvent::AssetTimings { idx, .. } if *idx == target))
+            .unwrap_or_else(|| panic!("missing AssetTimings for idx {target}: {middle:?}"));
+        assert!(
+            started_at < chunked_at && chunked_at < timings_at && timings_at < finished_at,
+            "idx {target} ordering: started={started_at} chunked={chunked_at} \
+             timings={timings_at} finished={finished_at}: {middle:?}"
+        );
    }
 }

--- a/crates/kebab-app/tests/pdf_pipeline.rs
+++ b/crates/kebab-app/tests/pdf_pipeline.rs
@@ -162,7 +162,9 @@ fn ingest_3_page_pdf_produces_one_doc_and_per_page_chunks() {
        "one chunk per non-empty page"
    );
    assert_eq!(
-        pdf_item.parser_version.as_ref().map(|p| p.0.as_str()),
+        pdf_item.parser_version
+            .as_ref()
+            .map(|p| p.0.split('|').next().unwrap()),
        Some("pdf-text-v1")
    );
    assert_eq!(
@@ -477,7 +479,10 @@ fn inspect_doc_surfaces_page_spans() {
        .find(|i| i.doc_path.0.ends_with("inspect.pdf"))
        .unwrap();
    let doc = kebab_app::inspect_doc_with_config(cfg, pdf_item.doc_id.as_ref().unwrap()).unwrap();
-    assert_eq!(doc.parser_version.0, "pdf-text-v1");
+    // v0.26.2: stored parser_version is now `pdf-text-v1|<ingest-config-sig>`
+    // (the signature folds chunking / pdf.ocr settings for skip detection).
+    // Assert the base identity by taking the prefix before the first '|'.
+    assert_eq!(doc.parser_version.0.split('|').next().unwrap(), "pdf-text-v1");
    assert_eq!(doc.blocks.len(), 3);
    for block in &doc.blocks {
        match block {
--- a/crates/kebab-app/tests/search_lexical.rs
+++ b/crates/kebab-app/tests/search_lexical.rs
@@ -111,7 +111,8 @@ fn first_ingest_bumps_corpus_revision() {
    store_before.run_migrations().unwrap();
    // V004 seeds 0; V009 + V010 + V011 migrations each bump by 1 to
    // invalidate stale LRU caches (spec §5.2). Baseline before ingest = 3.
-    // (V012 derivation_cache is purely additive — does NOT bump.)
+    // (V012 derivation_cache + V013 drop-chunk-aliases are structural/additive
+    // — neither bumps corpus_revision.)
    let baseline = store_before.corpus_revision();
    assert_eq!(baseline, 3, "fresh store post-V011 baseline = 3");

--- a/crates/kebab-chunk/src/code_c_ast_v1.rs
+++ b/crates/kebab-chunk/src/code_c_ast_v1.rs
@@ -152,7 +152,6 @@ fn make_chunk(
        token_estimate,
        chunker_version: chunker_version.clone(),
        policy_hash: base_policy_hash.to_string(),
-        aliases: None,
    }
 }

--- a/crates/kebab-chunk/src/code_cpp_ast_v1.rs
+++ b/crates/kebab-chunk/src/code_cpp_ast_v1.rs
@@ -154,7 +154,6 @@ fn make_chunk(
        token_estimate,
        chunker_version: chunker_version.clone(),
        policy_hash: base_policy_hash.to_string(),
-        aliases: None,
    }
 }

--- a/crates/kebab-chunk/src/code_go_ast_v1.rs
+++ b/crates/kebab-chunk/src/code_go_ast_v1.rs
@@ -154,7 +154,6 @@ fn make_chunk(
        token_estimate,
        chunker_version: chunker_version.clone(),
        policy_hash: base_policy_hash.to_string(),
-        aliases: None,
    }
 }

--- a/crates/kebab-chunk/src/code_java_ast_v1.rs
+++ b/crates/kebab-chunk/src/code_java_ast_v1.rs
@@ -154,7 +154,6 @@ fn make_chunk(
        token_estimate,
        chunker_version: chunker_version.clone(),
        policy_hash: base_policy_hash.to_string(),
-        aliases: None,
    }
 }

--- a/crates/kebab-chunk/src/code_js_ast_v1.rs
+++ b/crates/kebab-chunk/src/code_js_ast_v1.rs
@@ -154,7 +154,6 @@ fn make_chunk(
        token_estimate,
        chunker_version: chunker_version.clone(),
        policy_hash: base_policy_hash.to_string(),
-        aliases: None,
    }
 }

--- a/crates/kebab-chunk/src/code_kotlin_ast_v1.rs
+++ b/crates/kebab-chunk/src/code_kotlin_ast_v1.rs
@@ -154,7 +154,6 @@ fn make_chunk(
        token_estimate,
        chunker_version: chunker_version.clone(),
        policy_hash: base_policy_hash.to_string(),
-        aliases: None,
    }
 }

--- a/crates/kebab-chunk/src/code_python_ast_v1.rs
+++ b/crates/kebab-chunk/src/code_python_ast_v1.rs
@@ -154,7 +154,6 @@ fn make_chunk(
        token_estimate,
        chunker_version: chunker_version.clone(),
        policy_hash: base_policy_hash.to_string(),
-        aliases: None,
    }
 }

--- a/crates/kebab-chunk/src/code_rust_ast_v1.rs
+++ b/crates/kebab-chunk/src/code_rust_ast_v1.rs
@@ -154,7 +154,6 @@ fn make_chunk(
        token_estimate,
        chunker_version: chunker_version.clone(),
        policy_hash: base_policy_hash.to_string(),
-        aliases: None,
    }
 }

--- a/crates/kebab-chunk/src/code_ts_ast_v1.rs
+++ b/crates/kebab-chunk/src/code_ts_ast_v1.rs
@@ -154,7 +154,6 @@ fn make_chunk(
        token_estimate,
        chunker_version: chunker_version.clone(),
        policy_hash: base_policy_hash.to_string(),
-        aliases: None,
    }
 }

--- a/crates/kebab-chunk/src/md_heading_v1.rs
+++ b/crates/kebab-chunk/src/md_heading_v1.rs
@@ -339,7 +339,6 @@ fn build_chunk(
        token_estimate,
        chunker_version: chunker_version.clone(),
        policy_hash: policy_hash.to_string(),
-        aliases: None,
    }
 }

--- a/crates/kebab-chunk/src/pdf_page_v1.rs
+++ b/crates/kebab-chunk/src/pdf_page_v1.rs
@@ -177,7 +177,6 @@ impl Chunker for PdfPageV1Chunker {
                    token_estimate,
                    chunker_version: chunker_version.clone(),
                    policy_hash: base_policy_hash.clone(),
-                    aliases: None,
                });
            }
        }
--- a/crates/kebab-chunk/src/tier2_shared.rs
+++ b/crates/kebab-chunk/src/tier2_shared.rs
@@ -196,6 +196,5 @@ fn build_chunk_from_span(
        token_estimate,
        chunker_version: chunker_version.clone(),
        policy_hash: base_policy_hash.to_string(),
-        aliases: None,
    }
 }
--- a/crates/kebab-chunk/tests/fixtures/code-sample.c.chunks.snapshot.json
+++ b/crates/kebab-chunk/tests/fixtures/code-sample.c.chunks.snapshot.json
@@ -1,6 +1,5 @@
 [
  {
-    "aliases": null,
    "block_ids": [
      "8149e12ca002489acb4a0f74c97a061a"
    ],
@@ -23,7 +22,6 @@
    "tokenized_korean_text": "# include < stdio . h > # include < stdlib . h > # define MAX _ BUF 4096 typedef enum { OK = 0 , ERR _ PARSE , ERR _ IO , } status _ t ; typedef struct { int id ; char name [ 64 ]; status _ t status ; } record _ t ; static int counter = 0 ;"
  },
  {
-    "aliases": null,
    "block_ids": [
      "1baaa89f21a47b2f32d6396a24a85454"
    ],
@@ -46,7 +44,6 @@
    "tokenized_korean_text": "int parse _ record ( const char * line , record _ t * out ) { if ( line == NULL || out == NULL ) return ERR _ PARSE ; return OK ; }"
  },
  {
-    "aliases": null,
    "block_ids": [
      "8d0e14cbcc6d1e92d7878ab796ea68b8"
    ],
@@ -69,7 +66,6 @@
    "tokenized_korean_text": "void print _ record ( const record _ t * r ) { printf (\"[% d ] % s ( status =% d )\\ n \", r -> id , r -> name , r -> status ); }"
  },
  {
-    "aliases": null,
    "block_ids": [
      "9c2ede84423871b615d48c38fefb1853"
    ],
--- a/crates/kebab-chunk/tests/fixtures/code-sample.chunks.snapshot.json
+++ b/crates/kebab-chunk/tests/fixtures/code-sample.chunks.snapshot.json
--- a/crates/kebab-chunk/tests/fixtures/code-sample.cpp.chunks.snapshot.json
+++ b/crates/kebab-chunk/tests/fixtures/code-sample.cpp.chunks.snapshot.json
@@ -1,6 +1,5 @@
 [
  {
-    "aliases": null,
    "block_ids": [
      "53292605459065d170cd36c118e20546"
    ],
@@ -23,7 +22,6 @@
    "tokenized_korean_text": "# include < string > # include < vector > namespace kebab {"
  },
  {
-    "aliases": null,
    "block_ids": [
      "f349acad94c9fa4cf9ad1c0a93e83610"
    ],
@@ -46,7 +44,6 @@
    "tokenized_korean_text": "class MdHeadingV 1 Chunker { public : MdHeadingV 1 Chunker ( ) = default ; ~ MdHeadingV 1 Chunker ( ) = default ; std : : string chunk _ doc ( const std : : string & doc ) { return doc ; } int operator ( ) ( int x ) const { return x * 2 ; } private : int counter _ = 0 ; };"
  },
  {
-    "aliases": null,
    "block_ids": [
      "8b9811387717d0bd4abf84abcc35b8b1"
    ],
@@ -69,7 +66,6 @@
    "tokenized_korean_text": "template < typename T > T identity ( T value ) { return value ; }"
  },
  {
-    "aliases": null,
    "block_ids": [
      "1754cb6b971f6a4cb292f144a4f0570b"
    ],
@@ -92,7 +88,6 @@
    "tokenized_korean_text": "void global _ helper ( ) { / / free function in kebab namespace }"
  },
  {
-    "aliases": null,
    "block_ids": [
      "14b5f3393d6d25f822f5b70763d24acd"
    ],
--- a/crates/kebab-chunk/tests/fixtures/code-sample.go.chunks.snapshot.json
+++ b/crates/kebab-chunk/tests/fixtures/code-sample.go.chunks.snapshot.json
@@ -1,6 +1,5 @@
 [
  {
-    "aliases": null,
    "block_ids": [
      "c182bf37e32c7fc1b868bd617f8eaf66"
    ],
@@ -23,7 +22,6 @@
    "tokenized_korean_text": "import ( \" fmt \" \" os \" \" strings \" )"
  },
  {
-    "aliases": null,
    "block_ids": [
      "c9992cdcfdf3c2a7700a4abc4782a8a4"
    ],
@@ -46,7 +44,6 @@
    "tokenized_korean_text": "func ComputeMRR ( scores [ ] float 64 ) float 64 { if len ( scores ) == 0 { return 0 . 0 } _ = fmt . Sprintf (\"% v \", scores ) return 1 . 0 / float 64 ( len ( scores ) ) }"
  },
  {
-    "aliases": null,
    "block_ids": [
      "5f18dc3e79fe946ba05d32c3bfc00684"
    ],
@@ -69,7 +66,6 @@
    "tokenized_korean_text": "type MetricsCollector struct { Scores [ ] float 64 Labels [ ] string Counts map [ string ] int Totals map [ string ] float 64 Tags [ ] string }"
  },
  {
-    "aliases": null,
    "block_ids": [
      "3009cc022ca832c323393e4f9bcdb388"
    ],
@@ -92,7 +88,6 @@
    "tokenized_korean_text": "type BaseEvaluator struct { Name string } func ( e * BaseEvaluator ) Evaluate ( data [ ] string ) error { _ = os . Stderr _ = strings . Join ( data , \",\") return nil }"
  },
  {
-    "aliases": null,
    "block_ids": [
      "e0e83d1d7f9327a1902ae9a8f67c1f1c"
    ],
@@ -115,7 +110,6 @@
    "tokenized_korean_text": "func ( m * MetricsCollector ) Run ( inputs [ ] float 64 ) { for _, inp := range inputs { m . Scores = append ( m . Scores , inp , ) } }"
  },
  {
-    "aliases": null,
    "block_ids": [
      "0e6a572bc3fe2bd6d173fe614bd1b763"
    ],
@@ -138,7 +132,6 @@
    "tokenized_korean_text": "func ( m * MetricsCollector ) Report ( ) map [ string ] interface {} { return map [ string ] interface {}{ \" mean \": 0 . 0 , \" count \": len ( m . Scores ) , \" tags \": m . Tags , } }"
  },
  {
-    "aliases": null,
    "block_ids": [
      "5d269745b2e5dbdcbef0c09ba54b0bd6"
    ],
@@ -161,7 +154,6 @@
    "tokenized_korean_text": "func BigCompute ( data [ ] int ) int { v 0 := 0 if 0 < len ( data ) { v 0 = data [ 0 ] } v 1 := 0 if 1 < len ( data ) { v 1 = data [ 1 ] } v 2 := 0 if 2 < len ( data ) { v 2 = data [ 2 ] } v 3 := 0 if 3 < len ( data ) { v 3 = data [ 3 ] } v 4 := 0 if 4 < len ( data ) { v 4 = data [ 4 ] } v 5 := 0 if 5 < len ( data ) { v 5 = data [ 5 ] } v 6 := 0 if 6 < len ( data ) { v 6 = data [ 6 ] } v 7 := 0 if 7 < len ( data ) { v 7 = data [ 7 ] } v 8 := 0 if 8 < len ( data ) { v 8 = data [ 8 ] } v 9 := 0 if 9 < len ( data ) { v 9 = data [ 9 ] } v 10 := 0 if 10 < len ( data ) { v 10 = data [ 10 ] } v 11 := 0 if 11 < len ( data ) { v 11 = data [ 11 ] } v 12 := 0 if 12 < len ( data ) { v 12 = data [ 12 ] } v 13 := 0 if 13 < len ( data ) { v 13 = data [ 13 ] } v 14 := 0 if 14 < len ( data ) { v 14 = data [ 14 ] } v 15 := 0 if 15 < len ( data ) { v 15 = data [ 15 ] } v 16 := 0 if 16 < len ( data ) { v 16 = data [ 16 ] } v 17 := 0 if 17 < len ( data ) { v 17 = data [ 17 ] } v 18 := 0 if 18 < len ( data ) { v 18 = data [ 18 ] } v 19 := 0 if 19 < len ( data ) { v 19 = data [ 19 ] } v 20 := 0 if 20 < len ( data ) { v 20 = data [ 20 ] } v 21 := 0 if 21 < len ( data ) { v 21 = data [ 21 ] } v 22 := 0 if 22 < len ( data ) { v 22 = data [ 22 ] } v 23 := 0 if 23 < len ( data ) { v 23 = data [ 23 ] } v 24 := 0 if 24 < len ( data ) { v 24 = data [ 24 ] } v 25 := 0 if 25 < len ( data ) { v 25 = data [ 25 ] } v 26 := 0 if 26 < len ( data ) { v 26 = data [ 26 ] } v 27 := 0 if 27 < len ( data ) { v 27 = data [ 27 ] } v 28 := 0 if 28 < len ( data ) { v 28 = data [ 28 ] } v 29 := 0 if 29 < len ( data ) { v 29 = data [ 29 ] } v 30 := 0 if 30 < len ( data ) { v 30 = data [ 30 ] } v 31 := 0 if 31 < len ( data ) { v 31 = data [ 31 ] } v 32 := 0 if 32 < len ( data ) { v 32 = data [ 32 ] } v 33 := 0 if 33 < len ( data ) { v 33 = data [ 33 ] } v 34 := 0 if 34 < len ( data ) { v 34 = data [ 34 ] } v 35 := 0 if 35 < len ( data ) { v 35 = data [ 35 ] } v 36 := 0 if 36 < len ( data ) { v 36 = data [ 36 ] } v 37 := 0 if 37 < len ( data ) { v 37 = data [ 37 ] } v 38 := 0 if 38 < len ( data ) { v 38 = data [ 38 ] } v 39 := 0 if 39 < len ( data ) { v 39 = data [ 39 ] } v 40 := 0 if 40 < len ( data ) { v 40 = data [ 40 ] } v 41 := 0 if 41 < len ( data ) { v 41 = data [ 41 ] } v 42 := 0 if 42 < len ( data ) { v 42 = data [ 42 ] } v 43 := 0 if 43 < len ( data ) { v 43 = data [ 43 ] } v 44 := 0 if 44 < len ( data ) { v 44 = data [ 44 ] } v 45 := 0 if 45 < len ( data ) { v 45 = data [ 45 ] } v 46 := 0 if 46 < len ( data ) { v 46 = data [ 46 ] } v 47 := 0 if 47 < len ( data ) { v 47 = data [ 47 ] } v 48 := 0 if 48 < len ( data ) { v 48 = data [ 48 ] } v 49 := 0 if 49 < len ( data ) { v 49 = data [ 49 ]"
  },
  {
-    "aliases": null,
    "block_ids": [
      "5d269745b2e5dbdcbef0c09ba54b0bd6"
    ],
@@ -184,7 +176,6 @@
    "tokenized_korean_text": "} v 50 := 0 if 50 < len ( data ) { v 50 = data [ 50 ] } v 51 := 0 if 51 < len ( data ) { v 51 = data [ 51 ] } v 52 := 0 if 52 < len ( data ) { v 52 = data [ 52 ] } v 53 := 0 if 53 < len ( data ) { v 53 = data [ 53 ] } v 54 := 0 if 54 < len ( data ) { v 54 = data [ 54 ] } v 55 := 0 if 55 < len ( data ) { v 55 = data [ 55 ] } v 56 := 0 if 56 < len ( data ) { v 56 = data [ 56 ] } v 57 := 0 if 57 < len ( data ) { v 57 = data [ 57 ] } v 58 := 0 if 58 < len ( data ) { v 58 = data [ 58 ] } v 59 := 0 if 59 < len ( data ) { v 59 = data [ 59 ] } v 60 := 0 if 60 < len ( data ) { v 60 = data [ 60 ] } v 61 := 0 if 61 < len ( data ) { v 61 = data [ 61 ] } v 62 := 0 if 62 < len ( data ) { v 62 = data [ 62 ] } v 63 := 0 if 63 < len ( data ) { v 63 = data [ 63 ] } v 64 := 0 if 64 < len ( data ) { v 64 = data [ 64 ] } v 65 := 0 if 65 < len ( data ) { v 65 = data [ 65 ] } v 66 := 0 if 66 < len ( data ) { v 66 = data [ 66 ] } v 67 := 0 if 67 < len ( data ) { v 67 = data [ 67 ] } v 68 := 0 if 68 < len ( data ) { v 68 = data [ 68 ] } v 69 := 0 if 69 < len ( data ) { v 69 = data [ 69 ] } v 70 := 0 if 70 < len ( data ) { v 70 = data [ 70 ] } v 71 := 0 if 71 < len ( data ) { v 71 = data [ 71 ] } v 72 := 0 if 72 < len ( data ) { v 72 = data [ 72 ] } v 73 := 0 if 73 < len ( data ) { v 73 = data [ 73 ] } v 74 := 0 if 74 < len ( data ) { v 74 = data [ 74 ] } v 75 := 0 if 75 < len ( data ) { v 75 = data [ 75 ] } v 76 := 0 if 76 < len ( data ) { v 76 = data [ 76 ] } v 77 := 0 if 77 < len ( data ) { v 77 = data [ 77 ] } v 78 := 0 if 78 < len ( data ) { v 78 = data [ 78 ] } v 79 := 0 if 79 < len ( data ) { v 79 = data [ 79 ] } v 80 := 0 if 80 < len ( data ) { v 80 = data [ 80 ] } v 81 := 0 if 81 < len ( data ) { v 81 = data [ 81 ] } v 82 := 0 if 82 < len ( data ) { v 82 = data [ 82 ] } v 83 := 0 if 83 < len ( data ) { v 83 = data [ 83 ] } v 84 := 0 if 84 < len ( data ) { v 84 = data [ 84 ] } v 85 := 0 if 85 < len ( data ) { v 85 = data [ 85 ] } v 86 := 0 if 86 < len ( data ) { v 86 = data [ 86 ] } v 87 := 0 if 87 < len ( data ) { v 87 = data [ 87 ] } v 88 := 0 if 88 < len ( data ) { v 88 = data [ 88 ] } v 89 := 0 if 89 < len ( data ) { v 89 = data [ 89 ] } v 90 := 0 if 90 < len ( data ) { v 90 = data [ 90 ] } v 91 := 0 if 91 < len ( data ) { v 91 = data [ 91 ] } v 92 := 0 if 92 < len ( data ) { v 92 = data [ 92 ] } v 93 := 0 if 93 < len ( data ) { v 93 = data [ 93 ] } v 94 := 0 if 94 < len ( data ) { v 94 = data [ 94 ] } v 95 := 0 if 95 < len ( data ) { v 95 = data [ 95 ] } v 96 := 0 if 96 < len ( data ) { v 96 = data [ 96 ] } v 97 := 0 if 97 < len ( data ) { v 97 = data [ 97 ] } v 98 := 0 if 98 < len ( data ) { v 98 = data [ 98 ] } v 99 := 0 if 99 < len ( data ) { v 99 = data [ 99 ]"
  },
  {
-    "aliases": null,
    "block_ids": [
      "5d269745b2e5dbdcbef0c09ba54b0bd6"
    ],
@@ -207,7 +198,6 @@
    "tokenized_korean_text": "} v 100 := 0 if 100 < len ( data ) { v 100 = data [ 100 ] } v 101 := 0 if 101 < len ( data ) { v 101 = data [ 101 ] } v 102 := 0 if 102 < len ( data ) { v 102 = data [ 102 ] } v 103 := 0 if 103 < len ( data ) { v 103 = data [ 103 ] } v 104 := 0 if 104 < len ( data ) { v 104 = data [ 104 ] } v 105 := 0 if 105 < len ( data ) { v 105 = data [ 105 ] } v 106 := 0 if 106 < len ( data ) { v 106 = data [ 106 ] } v 107 := 0 if 107 < len ( data ) { v 107 = data [ 107 ] } v 108 := 0 if 108 < len ( data ) { v 108 = data [ 108 ] } v 109 := 0 if 109 < len ( data ) { v 109 = data [ 109 ] } v 110 := 0 if 110 < len ( data ) { v 110 = data [ 110 ] } v 111 := 0 if 111 < len ( data ) { v 111 = data [ 111 ] } v 112 := 0 if 112 < len ( data ) { v 112 = data [ 112 ] } v 113 := 0 if 113 < len ( data ) { v 113 = data [ 113 ] } v 114 := 0 if 114 < len ( data ) { v 114 = data [ 114 ] } v 115 := 0 if 115 < len ( data ) { v 115 = data [ 115 ] } v 116 := 0 if 116 < len ( data ) { v 116 = data [ 116 ] } v 117 := 0 if 117 < len ( data ) { v 117 = data [ 117 ] } v 118 := 0 if 118 < len ( data ) { v 118 = data [ 118 ] } v 119 := 0 if 119 < len ( data ) { v 119 = data [ 119 ] } v 120 := 0 if 120 < len ( data ) { v 120 = data [ 120 ] } v 121 := 0 if 121 < len ( data ) { v 121 = data [ 121 ] } v 122 := 0 if 122 < len ( data ) { v 122 = data [ 122 ] } v 123 := 0 if 123 < len ( data ) { v 123 = data [ 123 ] } v 124 := 0 if 124 < len ( data ) { v 124 = data [ 124 ] } v 125 := 0 if 125 < len ( data ) { v 125 = data [ 125 ] } v 126 := 0 if 126 < len ( data ) { v 126 = data [ 126 ] } v 127 := 0 if 127 < len ( data ) { v 127 = data [ 127 ] } v 128 := 0 if 128 < len ( data ) { v 128 = data [ 128 ] } v 129 := 0 if 129 < len ( data ) { v 129 = data [ 129 ] } v 130 := 0 if 130 < len ( data ) { v 130 = data [ 130 ] } v 131 := 0 if 131 < len ( data ) { v 131 = data [ 131 ] } v 132 := 0 if 132 < len ( data ) { v 132 = data [ 132 ] } v 133 := 0 if 133 < len ( data ) { v 133 = data [ 133 ] } v 134 := 0 if 134 < len ( data ) { v 134 = data [ 134 ] } v 135 := 0 if 135 < len ( data ) { v 135 = data [ 135 ] } v 136 := 0 if 136 < len ( data ) { v 136 = data [ 136 ] } v 137 := 0 if 137 < len ( data ) { v 137 = data [ 137 ] } v 138 := 0 if 138 < len ( data ) { v 138 = data [ 138 ] } v 139 := 0 if 139 < len ( data ) { v 139 = data [ 139 ] } v 140 := 0 if 140 < len ( data ) { v 140 = data [ 140 ] } v 141 := 0 if 141 < len ( data ) { v 141 = data [ 141 ] } v 142 := 0 if 142 < len ( data ) { v 142 = data [ 142 ] } v 143 := 0 if 143 < len ( data ) { v 143 = data [ 143 ] } v 144 := 0 if 144 < len ( data ) { v 144 = data [ 144 ] } v 145 := 0 if 145 < len ( data ) { v 145 = data [ 145 ] } v 146 := 0 if 146 < len ( data ) { v 146 = data [ 146 ] } v 147 := 0 if 147 < len ( data ) { v 147 = data [ 147 ] } v 148 := 0 if 148 < len ( data ) { v 148 = data [ 148 ] } v 149 := 0 if 149 < len ( data ) { v 149 = data [ 149 ]"
  },
  {
-    "aliases": null,
    "block_ids": [
      "5d269745b2e5dbdcbef0c09ba54b0bd6"
    ],
@@ -230,7 +220,6 @@
    "tokenized_korean_text": "} v 150 := 0 if 150 < len ( data ) { v 150 = data [ 150 ] } v 151 := 0 if 151 < len ( data ) { v 151 = data [ 151 ] } v 152 := 0 if 152 < len ( data ) { v 152 = data [ 152 ] } v 153 := 0 if 153 < len ( data ) { v 153 = data [ 153 ] } v 154 := 0 if 154 < len ( data ) { v 154 = data [ 154 ] } v 155 := 0 if 155 < len ( data ) { v 155 = data [ 155 ] } v 156 := 0 if 156 < len ( data ) { v 156 = data [ 156 ] } v 157 := 0 if 157 < len ( data ) { v 157 = data [ 157 ] } v 158 := 0 if 158 < len ( data ) { v 158 = data [ 158 ] } v 159 := 0 if 159 < len ( data ) { v 159 = data [ 159 ] } v 160 := 0 if 160 < len ( data ) { v 160 = data [ 160 ] } v 161 := 0 if 161 < len ( data ) { v 161 = data [ 161 ] } v 162 := 0 if 162 < len ( data ) { v 162 = data [ 162 ] } v 163 := 0 if 163 < len ( data ) { v 163 = data [ 163 ] } v 164 := 0 if 164 < len ( data ) { v 164 = data [ 164 ] } v 165 := 0 if 165 < len ( data ) { v 165 = data [ 165 ] } v 166 := 0 if 166 < len ( data ) { v 166 = data [ 166 ] } v 167 := 0 if 167 < len ( data ) { v 167 = data [ 167 ] } v 168 := 0 if 168 < len ( data ) { v 168 = data [ 168 ] } v 169 := 0 if 169 < len ( data ) { v 169 = data [ 169 ] } v 170 := 0 if 170 < len ( data ) { v 170 = data [ 170 ] } v 171 := 0 if 171 < len ( data ) { v 171 = data [ 171 ] } v 172 := 0 if 172 < len ( data ) { v 172 = data [ 172 ] } v 173 := 0 if 173 < len ( data ) { v 173 = data [ 173 ] } v 174 := 0 if 174 < len ( data ) { v 174 = data [ 174 ] } v 175 := 0 if 175 < len ( data ) { v 175 = data [ 175 ] } v 176 := 0 if 176 < len ( data ) { v 176 = data [ 176 ] } v 177 := 0 if 177 < len ( data ) { v 177 = data [ 177 ] } v 178 := 0 if 178 < len ( data ) { v 178 = data [ 178 ] } v 179 := 0 if 179 < len ( data ) { v 179 = data [ 179 ] } v 180 := 0 if 180 < len ( data ) { v 180 = data [ 180 ] } v 181 := 0 if 181 < len ( data ) { v 181 = data [ 181 ] } v 182 := 0 if 182 < len ( data ) { v 182 = data [ 182 ] } v 183 := 0 if 183 < len ( data ) { v 183 = data [ 183 ] } v 184 := 0 if 184 < len ( data ) { v 184 = data [ 184 ] } v 185 := 0 if 185 < len ( data ) { v 185 = data [ 185 ] } v 186 := 0 if 186 < len ( data ) { v 186 = data [ 186 ] } v 187 := 0 if 187 < len ( data ) { v 187 = data [ 187 ] } v 188 := 0 if 188 < len ( data ) { v 188 = data [ 188 ] } v 189 := 0 if 189 < len ( data ) { v 189 = data [ 189 ] } v 190 := 0 if 190 < len ( data ) { v 190 = data [ 190 ] } v 191 := 0 if 191 < len ( data ) { v 191 = data [ 191 ] } v 192 := 0 if 192 < len ( data ) { v 192 = data [ 192 ] } v 193 := 0 if 193 < len ( data ) { v 193 = data [ 193 ] } v 194 := 0 if 194 < len ( data ) { v 194 = data [ 194 ] } v 195 := 0 if 195 < len ( data ) { v 195 = data [ 195 ] } v 196 := 0 if 196 < len ( data ) { v 196 = data [ 196 ] } v 197 := 0 if 197 < len ( data ) { v 197 = data [ 197 ] } v 198 := 0 if 198 < len ( data ) { v 198 = data [ 198 ] } v 199 := 0 if 199 < len ( data ) { v 199 = data [ 199 ]"
  },
  {
-    "aliases": null,
    "block_ids": [
      "5d269745b2e5dbdcbef0c09ba54b0bd6"
    ],
--- a/crates/kebab-chunk/tests/fixtures/code-sample.java.chunks.snapshot.json
+++ b/crates/kebab-chunk/tests/fixtures/code-sample.java.chunks.snapshot.json
--- a/crates/kebab-chunk/tests/fixtures/code-sample.js.chunks.snapshot.json
+++ b/crates/kebab-chunk/tests/fixtures/code-sample.js.chunks.snapshot.json
--- a/crates/kebab-chunk/tests/fixtures/code-sample.kt.chunks.snapshot.json
+++ b/crates/kebab-chunk/tests/fixtures/code-sample.kt.chunks.snapshot.json
--- a/crates/kebab-chunk/tests/fixtures/code-sample.py.chunks.snapshot.json
+++ b/crates/kebab-chunk/tests/fixtures/code-sample.py.chunks.snapshot.json
--- a/crates/kebab-chunk/tests/fixtures/code-sample.ts.chunks.snapshot.json
+++ b/crates/kebab-chunk/tests/fixtures/code-sample.ts.chunks.snapshot.json
--- a/crates/kebab-cli/src/main.rs
+++ b/crates/kebab-cli/src/main.rs
@@ -632,6 +632,24 @@ fn run(cli: &Cli) -> anyhow::Result<()> {
                .map(|v| v.eq_ignore_ascii_case("plain"))
                .unwrap_or(false);
            let mode = progress::ProgressMode::from_flags(cli.json, cli.quiet, plain_env);
+
+            // Surface the active embedding backend/device on the terminal so the
+            // user sees it without grepping kb.log (the per-device tracing line
+            // only lands in the log file at --verbose). Suppressed under
+            // --json/--quiet. The Metal note reflects the build (`embed_metal`);
+            // the confirmed runtime device is in kb.log (`candle device = ...`).
+            if !cli.json && !cli.quiet {
+                let backend = match cfg.models.embedding.provider.as_str() {
+                    "candle" if cfg!(feature = "embed_metal") => "candle (Metal/GPU 빌드)",
+                    "candle" => "candle (CPU, 순수 Rust)",
+                    "fastembed" | "onnx" | "" => "fastembed (onnxruntime)",
+                    "none" => "비활성 (lexical-only)",
+                    other => other,
+                };
+                eprintln!("임베딩 백엔드: {backend} · 모델 {} ({}-dim)",
+                    cfg.models.embedding.model, cfg.models.embedding.dimensions);
+            }
+
            let (tx, rx) = std::sync::mpsc::channel::<kebab_app::IngestEvent>();
            let display_handle =
                std::thread::spawn(move || progress::ProgressDisplay::new(mode).run(rx));
--- a/crates/kebab-cli/src/progress.rs
+++ b/crates/kebab-cli/src/progress.rs
@@ -19,16 +19,23 @@
 //! `Sender` end is dropped (i.e. when `ingest_with_config_progress`
 //! returns).

+use std::collections::HashMap;
 use std::io::{IsTerminal, Write};
 use std::sync::mpsc::Receiver;
+use std::sync::{Arc, Mutex};
+use std::time::Instant;

-use indicatif::{ProgressBar, ProgressDrawTarget, ProgressStyle};
+use indicatif::{ProgressBar, ProgressDrawTarget, ProgressState, ProgressStyle};
 use kebab_app::IngestEvent;
 use time::OffsetDateTime;
 use time::format_description::well_known::Rfc3339;

 use crate::wire;

+/// v0.26.1: number of slowest assets surfaced in the end-of-run summary.
+/// Constant for now (spec defers the config knob).
+const SLOWEST_TOP_N: usize = 5;
+
 /// Rendering mode for `ProgressDisplay`. The mode is fixed at
 /// construction — each `kebab ingest` invocation is a single mode
 /// (chosen from `--json` plus `IsTerminal` detection).
@@ -65,11 +72,33 @@ impl ProgressMode {
 pub struct ProgressDisplay {
    mode: ProgressMode,
    bar: Option<ProgressBar>,
+    /// v0.26.1 heartbeat: start `Instant` of the asset currently in
+    /// flight, shared with the bar's steady-tick custom template key so
+    /// the `(Ns)` elapsed counter advances *between* events (the drain
+    /// loop blocks on `recv()`, so without the ticker the counter would
+    /// freeze). `None` while scanning / between assets / after completion.
+    asset_start: Arc<Mutex<Option<Instant>>>,
+    /// v0.26.1: workspace path of the asset currently in flight — set on
+    /// `AssetStarted`, reused by `AssetPhase` to render `{path} · {phase}…`.
+    current_path: Option<String>,
+    /// v0.26.1 slowest summary: idx → path, captured from `AssetStarted`
+    /// so `AssetTimings` (which only carries `idx`) can name the asset.
+    asset_paths: HashMap<u32, String>,
+    /// v0.26.1 slowest summary: (path, total_ms) per asset that reported
+    /// `AssetTimings`. Sorted + truncated to top-N on `Completed`.
+    timings: Vec<(String, u64)>,
 }

 impl ProgressDisplay {
    pub fn new(mode: ProgressMode) -> Self {
-        Self { mode, bar: None }
+        Self {
+            mode,
+            bar: None,
+            asset_start: Arc::new(Mutex::new(None)),
+            current_path: None,
+            asset_paths: HashMap::new(),
+            timings: Vec::new(),
+        }
    }

    /// Block until `rx` returns `Err` (sender dropped). Renders one
@@ -120,15 +149,43 @@ impl ProgressDisplay {
            }
            IngestEvent::ScanCompleted { total } => {
                if let Some(bar) = self.bar.as_mut() {
-                    bar.disable_steady_tick();
                    bar.set_length(u64::from(*total));
                    bar.set_position(0);
+                    // v0.26.1: a custom `{asset_elapsed}` key reads the shared
+                    // per-asset start `Instant` and appends ` (Ns)`. Combined
+                    // with the steady tick below, the elapsed counter advances
+                    // even while the drain loop is blocked on `recv()` waiting
+                    // for the next (possibly very slow) phase event.
+                    let asset_start = Arc::clone(&self.asset_start);
                    bar.set_style(
-                        ProgressStyle::with_template("ingest [{bar:30}] {pos}/{len} {wide_msg}")
-                            .unwrap()
-                            .progress_chars("=> "),
+                        ProgressStyle::with_template(
+                            "ingest [{bar:30}] {pos}/{len} {wide_msg}{asset_elapsed}",
+                        )
+                        .unwrap()
+                        .with_key(
+                            "asset_elapsed",
+                            move |_: &ProgressState, w: &mut dyn std::fmt::Write| {
+                                if let Ok(guard) = asset_start.lock()
+                                    && let Some(started) = *guard
+                                {
+                                    let secs = started.elapsed().as_secs();
+                                    // Only show once the asset has been running
+                                    // a moment — avoids `(0s)` flicker on fast
+                                    // assets.
+                                    if secs >= 1 {
+                                        let _ = write!(w, " ({secs}s)");
+                                    }
+                                }
+                            },
+                        )
+                        .progress_chars("=> "),
                    );
                    bar.set_message("");
+                    if tty && !quiet {
+                        bar.enable_steady_tick(std::time::Duration::from_secs(1));
+                    } else {
+                        bar.disable_steady_tick();
+                    }
                }
                if !tty && !quiet {
                    let mut err = std::io::stderr().lock();
@@ -141,11 +198,22 @@ impl ProgressDisplay {
                path,
                media,
            } => {
+                // v0.26.1: remember the path so AssetPhase can render it and
+                // the slowest summary (keyed by idx in AssetTimings) can name
+                // the asset.
+                self.current_path = Some(path.clone());
+                self.asset_paths.insert(*idx, path.clone());
+                // v0.26.1: (re)start the per-asset heartbeat clock.
+                if let Ok(mut guard) = self.asset_start.lock() {
+                    *guard = Some(Instant::now());
+                }
                if let Some(bar) = self.bar.as_ref() {
-                    // One draw per file: position only. set_message() would
-                    // trigger a second independent draw and pollute TTY scrollback.
-                    // Filename is visible in the non-TTY plain-line path below.
                    bar.set_position(u64::from(idx.saturating_sub(1)));
+                    // v0.26.1: show the current filename on the bar (TTY).
+                    // Previously position-only — the interactive user couldn't
+                    // tell which file was in flight. The steady tick redraws
+                    // in place, so this no longer pollutes scrollback.
+                    bar.set_message(abbreviate_path(path));
                }
                if !tty && !quiet {
                    let mut err = std::io::stderr().lock();
@@ -154,13 +222,95 @@ impl ProgressDisplay {
            }
            IngestEvent::AssetFinished { .. } => {
                // Position is advanced in AssetStarted; bar.finish_and_clear()
-                // in Completed handles the final state. No per-asset bar update
-                // here avoids the duplicate-frame artifact in TTY scrollback.
+                // in Completed handles the final state. v0.26.1: stop the
+                // heartbeat clock so the bar doesn't show a stale `(Ns)` in the
+                // gap before the next AssetStarted.
+                if let Ok(mut guard) = self.asset_start.lock() {
+                    *guard = None;
+                }
+                self.current_path = None;
+            }
+            // v0.26.1: an asset entered a slow internal phase (ocr / caption /
+            // embed). Surface which phase + model is running so a multi-second
+            // vision-model call no longer looks frozen.
+            IngestEvent::AssetPhase {
+                idx,
+                total,
+                phase,
+                model,
+            } => {
+                let label = match model {
+                    Some(m) => format!("{phase}({m})"),
+                    None => phase.clone(),
+                };
+                if let Some(bar) = self.bar.as_ref() {
+                    let path = self.current_path.as_deref().unwrap_or("");
+                    bar.set_message(format!("{} · {label}…", abbreviate_path(path)));
+                }
+                if !tty && !quiet {
+                    let mut err = std::io::stderr().lock();
+                    let _ = writeln!(err, "ingest: {idx}/{total} · {label}…");
+                }
+            }
+            // v0.24.0: asset-internal phase visibility. AssetChunked uses the
+            // bar *message* (live sub-progress for the current asset) —
+            // distinct from the per-file position draw, so a single large
+            // document no longer looks frozen. AssetTimings prints a one-line
+            // breakdown when the asset finishes.
+            IngestEvent::AssetChunked { idx, total, chunks } => {
+                if let Some(bar) = self.bar.as_ref() {
+                    bar.set_message(format!("→ {chunks} chunks"));
+                }
+                if !tty && !quiet {
+                    let mut err = std::io::stderr().lock();
+                    let _ = writeln!(err, "ingest: {idx}/{total} → {chunks} chunks");
+                }
+            }
+            IngestEvent::AssetTimings {
+                idx,
+                parse_ms,
+                chunk_ms,
+                embed_ms,
+                store_ms,
+                ocr_ms,
+                caption_ms,
+                ..
+            } => {
+                // v0.26.1: accumulate (path, total_ms) for the slowest summary.
+                // total = every measured phase (expansion_ms is always 0).
+                let total_ms = parse_ms + chunk_ms + embed_ms + store_ms + ocr_ms + caption_ms;
+                if let Some(path) = self.asset_paths.get(idx) {
+                    self.timings.push((path.clone(), total_ms));
+                }
+                if let Some(bar) = self.bar.as_ref() {
+                    bar.set_message("");
+                }
+                if !quiet {
+                    let mut err = std::io::stderr().lock();
+                    // v0.26.1: only print ocr / caption when they actually ran
+                    // (markdown leaves them 0) so the text path stays uncluttered.
+                    let mut parts = vec![
+                        format!("parse {}", fmt_ms(*parse_ms)),
+                        format!("chunk {}", fmt_ms(*chunk_ms)),
+                    ];
+                    if *ocr_ms > 0 {
+                        parts.push(format!("ocr {}", fmt_ms(*ocr_ms)));
+                    }
+                    if *caption_ms > 0 {
+                        parts.push(format!("caption {}", fmt_ms(*caption_ms)));
+                    }
+                    parts.push(format!("embed {}", fmt_ms(*embed_ms)));
+                    parts.push(format!("store {}", fmt_ms(*store_ms)));
+                    let _ = writeln!(err, "  ⏱ {}", parts.join(" · "));
+                }
            }
            IngestEvent::Completed { counts } => {
                if let Some(bar) = self.bar.take() {
                    bar.finish_and_clear();
                }
+                if let Ok(mut guard) = self.asset_start.lock() {
+                    *guard = None;
+                }
                // Always emit summary in both TTY and non-TTY (unless quiet).
                // Bug fix: previously TTY had no summary line after bar.finish_and_clear().
                if !quiet {
@@ -170,6 +320,10 @@ impl ProgressDisplay {
                        "ingest: complete (scanned={} new={} updated={} skipped={} errors={})",
                        counts.scanned, counts.new, counts.updated, counts.skipped, counts.errors,
                    );
+                    // v0.26.1: slowest-asset summary. Useful in both TTY and
+                    // non-TTY (it pinpoints the bottleneck file), so it prints
+                    // unless --quiet. --json mode never reaches here (emit_json).
+                    let _ = write_slowest_summary(&mut err, &self.timings, SLOWEST_TOP_N);
                }
            }
            IngestEvent::Aborted { counts } => {
@@ -239,6 +393,59 @@ fn emit_json(event: &IngestEvent) -> anyhow::Result<()> {
    Ok(())
 }

+/// Render a phase duration (milliseconds) compactly for the human-mode
+/// `AssetTimings` line: `< 1000ms` stays in `ms`, larger spans collapse to
+/// one-decimal seconds so a 45-second embed reads `45.0s`, not `45000ms`.
+fn fmt_ms(ms: u64) -> String {
+    if ms >= 1000 {
+        format!("{:.1}s", ms as f64 / 1000.0)
+    } else {
+        format!("{ms}ms")
+    }
+}
+
+/// v0.26.1: shorten an over-long workspace path for the progress-bar
+/// message so the live `(Ns)` heartbeat suffix stays visible on a narrow
+/// terminal. Keeps the tail (filename + a couple of parents) — that's the
+/// distinguishing part — and prefixes `…` when truncated. Paths up to the
+/// budget pass through verbatim.
+fn abbreviate_path(path: &str) -> String {
+    const MAX: usize = 48;
+    let char_count = path.chars().count();
+    if char_count <= MAX {
+        return path.to_string();
+    }
+    // Keep the last MAX-1 chars (1 reserved for the leading ellipsis).
+    let tail: String = path
+        .chars()
+        .skip(char_count - (MAX - 1))
+        .collect::<String>();
+    format!("…{tail}")
+}
+
+/// v0.26.1: render the end-of-run "slowest assets" summary. Sorts
+/// `(path, total_ms)` descending by time, takes the top `n`, and writes a
+/// compact table to `w`. No-op (writes nothing) when `timings` is empty so
+/// a run with no per-asset timing (e.g. all-skipped) prints no stray header.
+fn write_slowest_summary(
+    w: &mut impl Write,
+    timings: &[(String, u64)],
+    n: usize,
+) -> std::io::Result<()> {
+    if timings.is_empty() {
+        return Ok(());
+    }
+    let mut sorted: Vec<&(String, u64)> = timings.iter().collect();
+    // desc by ms; ties broken by path for deterministic output.
+    sorted.sort_by(|a, b| b.1.cmp(&a.1).then_with(|| a.0.cmp(&b.0)));
+    let top = &sorted[..sorted.len().min(n)];
+    writeln!(w, "⏱ 최장 소요 top-{}:", top.len())?;
+    for (rank, (path, ms)) in top.iter().enumerate() {
+        writeln!(w, "  {}. {} — {}", rank + 1, path, fmt_ms(*ms))?;
+    }
+    Ok(())
+}
+
 /// Format the current wall-clock as RFC 3339 — used by `wire_ingest_progress`
 /// so every emitted event carries an `ts` field per §2.4a / the wire schema.
 pub(crate) fn now_rfc3339() -> anyhow::Result<String> {
@@ -285,6 +492,15 @@ mod tests {
        }
    }

+    #[test]
+    fn fmt_ms_switches_unit_at_one_second() {
+        assert_eq!(fmt_ms(0), "0ms");
+        assert_eq!(fmt_ms(999), "999ms");
+        assert_eq!(fmt_ms(1000), "1.0s");
+        assert_eq!(fmt_ms(45_000), "45.0s");
+        assert_eq!(fmt_ms(1500), "1.5s");
+    }
+
    #[test]
    fn now_rfc3339_parses_back() {
        let s = now_rfc3339().unwrap();
@@ -292,4 +508,61 @@ mod tests {
        // well-formed RFC 3339 string.
        OffsetDateTime::parse(&s, &Rfc3339).expect("RFC 3339 round-trip");
    }
+
+    #[test]
+    fn abbreviate_path_passes_short_paths_through() {
+        assert_eq!(abbreviate_path("notes/foo.md"), "notes/foo.md");
+    }
+
+    #[test]
+    fn abbreviate_path_keeps_tail_with_ellipsis() {
+        let long = "a/very/deeply/nested/directory/structure/that/exceeds/the/budget/file.md";
+        let out = abbreviate_path(long);
+        assert!(out.starts_with('…'), "should be prefixed with ellipsis: {out}");
+        assert!(out.ends_with("file.md"), "should keep the filename tail: {out}");
+        // 48-char budget: 1 ellipsis + 47 tail chars.
+        assert_eq!(out.chars().count(), 48);
+    }
+
+    #[test]
+    fn write_slowest_summary_empty_writes_nothing() {
+        let mut buf = Vec::new();
+        write_slowest_summary(&mut buf, &[], 5).unwrap();
+        assert!(buf.is_empty());
+    }
+
+    #[test]
+    fn write_slowest_summary_sorts_desc_and_truncates() {
+        let timings = vec![
+            ("a.md".to_string(), 100),
+            ("b.png".to_string(), 5_000),
+            ("c.pdf".to_string(), 2_000),
+            ("d.md".to_string(), 50),
+        ];
+        let mut buf = Vec::new();
+        write_slowest_summary(&mut buf, &timings, 2).unwrap();
+        let out = String::from_utf8(buf).unwrap();
+        assert!(out.contains("top-2:"), "{out}");
+        // b (5s) ranks first, c (2s) second; a/d excluded.
+        let b_pos = out.find("b.png").expect("b.png present");
+        let c_pos = out.find("c.pdf").expect("c.pdf present");
+        assert!(b_pos < c_pos, "b before c: {out}");
+        assert!(!out.contains("a.md"), "a.md excluded by top-2: {out}");
+        assert!(out.contains("5.0s"), "b renders as 5.0s: {out}");
+    }
+
+    #[test]
+    fn write_slowest_summary_tie_breaks_by_path() {
+        let timings = vec![
+            ("z.md".to_string(), 1_000),
+            ("a.md".to_string(), 1_000),
+        ];
+        let mut buf = Vec::new();
+        write_slowest_summary(&mut buf, &timings, 5).unwrap();
+        let out = String::from_utf8(buf).unwrap();
+        assert!(
+            out.find("a.md").unwrap() < out.find("z.md").unwrap(),
+            "equal ms ties break alphabetically: {out}"
+        );
+    }
 }
--- a/crates/kebab-config/src/lib.rs
+++ b/crates/kebab-config/src/lib.rs
@@ -155,9 +155,10 @@ impl NliCfg {

 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct EmbeddingModelCfg {
-    /// `fastembed` (default, onnxruntime) or `candle` (pure-Rust,
-    /// NUMA-safe). `none` disables embeddings (lexical-only). Unknown
-    /// values error at embedder construction.
+    /// `fastembed` (default, onnxruntime), `candle` (pure-Rust, NUMA-safe),
+    /// or `ollama` (remote HTTP embedding endpoint). `none` disables
+    /// embeddings (lexical-only). Unknown values error at embedder
+    /// construction.
    pub provider: String,
    pub model: String,
    pub version: String,
@@ -170,6 +171,13 @@ pub struct EmbeddingModelCfg {
    /// provider. Defaulted on load so pre-0.22 config files still parse.
    #[serde(default)]
    pub num_threads: u32,
+    /// HTTP endpoint for the `ollama` embedding provider (e.g.
+    /// `"http://127.0.0.1:11434"`). `None` (or a missing key in TOML) means
+    /// "fall back to `models.llm.endpoint`" — same convention as the OCR /
+    /// vision endpoints. Ignored by the `fastembed` / `candle` providers.
+    /// Defaulted on load so pre-0.26 config files still parse.
+    #[serde(default)]
+    pub endpoint: Option<String>,
 }

 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -369,6 +377,36 @@ pub struct OcrCfg {
    /// `86400`).
    #[serde(default = "default_ocr_request_timeout_secs")]
    pub request_timeout_secs: u64,
+
+    // ── paddle-onnx engine overrides (v0.27.0) ──────────────────────────
+    // Only consulted when `engine == "paddle-onnx"`; the ollama-vision
+    // engine ignores them. All `#[serde(default)]` so pre-v0.27 config
+    // files load unchanged.
+    /// Override path to the detection ONNX model. `None` → bundled
+    /// `assets/paddleocr-onnx/ppocrv5_mobile_det.onnx` (or the directory
+    /// named by `KEBAB_IMAGE_OCR_MODEL_DIR`).
+    #[serde(default)]
+    pub det_model: Option<String>,
+    /// Override path to the recognition ONNX model. `None` → bundled
+    /// `assets/paddleocr-onnx/korean_ppocrv5_mobile_rec.onnx`.
+    #[serde(default)]
+    pub rec_model: Option<String>,
+    /// Override path to the character dictionary. `None` → bundled
+    /// `assets/paddleocr-onnx/korean_dict.txt`.
+    #[serde(default)]
+    pub dict: Option<String>,
+    /// DBNet detection box score threshold (0.0..=1.0). Boxes whose mean
+    /// probability is below this are dropped. Default `0.3`.
+    #[serde(default = "default_ocr_score_thresh")]
+    pub score_thresh: f32,
+    /// Polygon unclip ratio applied to each detected box before crop.
+    /// Larger = more padding around the text. Default `1.5`.
+    #[serde(default = "default_ocr_unclip_ratio")]
+    pub unclip_ratio: f32,
+    /// Hard cap on detected boxes per image (runaway guard). Extra boxes
+    /// past this count are truncated with a warning. Default `1000`.
+    #[serde(default = "default_ocr_max_boxes")]
+    pub max_boxes: usize,
 }

 impl OcrCfg {
@@ -381,10 +419,29 @@ impl OcrCfg {
            languages: vec!["eng".to_string(), "kor".to_string()],
            max_pixels: 1600,
            request_timeout_secs: default_ocr_request_timeout_secs(),
+            det_model: None,
+            rec_model: None,
+            dict: None,
+            score_thresh: default_ocr_score_thresh(),
+            unclip_ratio: default_ocr_unclip_ratio(),
+            max_boxes: default_ocr_max_boxes(),
        }
    }
 }

+/// paddle-onnx DBNet box score threshold default. See [`OcrCfg::score_thresh`].
+fn default_ocr_score_thresh() -> f32 {
+    0.3
+}
+/// paddle-onnx unclip ratio default. See [`OcrCfg::unclip_ratio`].
+fn default_ocr_unclip_ratio() -> f32 {
+    1.5
+}
+/// paddle-onnx box-count cap default. See [`OcrCfg::max_boxes`].
+fn default_ocr_max_boxes() -> usize {
+    1000
+}
+
 /// v0.17.2 post-dogfood: matches the legacy hard-coded ceiling so
 /// existing configs that omit the field keep behaving identically.
 /// Overridable per config / `KEBAB_IMAGE_OCR_REQUEST_TIMEOUT_SECS`.
@@ -606,8 +663,6 @@ impl UiCfg {
 #[serde(default)]
 pub struct IngestCfg {
    pub code: IngestCodeCfg,
-    #[serde(default)]
-    pub expansion: IngestExpansionCfg,
 }

 /// p10-1A-1: settings for the code ingest pipeline. All fields have
@@ -648,34 +703,6 @@ impl Default for IngestCodeCfg {
    }
 }

-/// doc-side expansion config. Default: disabled (requires explicit opt-in).
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[serde(default)]
-pub struct IngestExpansionCfg {
-    /// Whether doc-side alias expansion is enabled during ingest.
-    pub enabled: bool,
-    /// Ollama model used for alias generation (empty = use LLM default).
-    pub model: String,
-    /// Maximum aliases generated per chunk.
-    pub max_aliases_per_chunk: usize,
-    /// Prompt template version tag.
-    pub prompt_version: String,
-    /// Whether alias embeddings are stored as separate dense vectors.
-    pub embed_aliases: bool,
-}
-
-impl Default for IngestExpansionCfg {
-    fn default() -> Self {
-        Self {
-            enabled: false,
-            model: String::new(),
-            max_aliases_per_chunk: 8,
-            prompt_version: "expansion-v1".to_string(),
-            embed_aliases: false,
-        }
-    }
-}
-
 impl Config {
    /// Defaults per design §6.4.
    pub fn defaults() -> Self {
@@ -718,6 +745,7 @@ impl Config {
                    dimensions: 1024,
                    batch_size: 64,
                    num_threads: 0,
+                    endpoint: None,
                },
                llm: LlmCfg {
                    provider: "ollama".to_string(),
@@ -980,6 +1008,12 @@ impl Config {
                        self.models.embedding.num_threads = n;
                    }
                }
+                "KEBAB_MODELS_EMBEDDING_ENDPOINT" => {
+                    // Empty value → None (= fall back to models.llm.endpoint),
+                    // mirroring the OCR endpoint override semantics.
+                    self.models.embedding.endpoint =
+                        if v.is_empty() { None } else { Some(v.clone()) };
+                }

                // models.llm
                "KEBAB_MODELS_LLM_PROVIDER" => self.models.llm.provider = v.clone(),
@@ -1113,6 +1147,34 @@ impl Config {
                        self.image.ocr.request_timeout_secs = n;
                    }
                }
+                // paddle-onnx engine overrides (v0.27.0). Empty string → None
+                // (fall back to bundled / KEBAB_IMAGE_OCR_MODEL_DIR).
+                "KEBAB_IMAGE_OCR_DET_MODEL" => {
+                    self.image.ocr.det_model =
+                        if v.is_empty() { None } else { Some(v.clone()) };
+                }
+                "KEBAB_IMAGE_OCR_REC_MODEL" => {
+                    self.image.ocr.rec_model =
+                        if v.is_empty() { None } else { Some(v.clone()) };
+                }
+                "KEBAB_IMAGE_OCR_DICT" => {
+                    self.image.ocr.dict = if v.is_empty() { None } else { Some(v.clone()) };
+                }
+                "KEBAB_IMAGE_OCR_SCORE_THRESH" => {
+                    if let Ok(f) = v.parse::<f32>() {
+                        self.image.ocr.score_thresh = f;
+                    }
+                }
+                "KEBAB_IMAGE_OCR_UNCLIP_RATIO" => {
+                    if let Ok(f) = v.parse::<f32>() {
+                        self.image.ocr.unclip_ratio = f;
+                    }
+                }
+                "KEBAB_IMAGE_OCR_MAX_BOXES" => {
+                    if let Ok(n) = v.parse::<usize>() {
+                        self.image.ocr.max_boxes = n;
+                    }
+                }

                // image.caption (P6-3)
                "KEBAB_IMAGE_CAPTION_ENABLED" => {
@@ -1166,25 +1228,6 @@ impl Config {
                    self.pdf.ocr.lang_hint = if v.is_empty() { None } else { Some(v.clone()) };
                }

-                // ingest.expansion
-                "KEBAB_INGEST_EXPANSION_ENABLED" => {
-                    self.ingest.expansion.enabled = parse_bool(v);
-                }
-                "KEBAB_INGEST_EXPANSION_MODEL" => {
-                    self.ingest.expansion.model = v.clone();
-                }
-                "KEBAB_INGEST_EXPANSION_MAX_ALIASES" => {
-                    if let Ok(n) = v.parse::<usize>() {
-                        self.ingest.expansion.max_aliases_per_chunk = n;
-                    }
-                }
-                "KEBAB_INGEST_EXPANSION_PROMPT_VERSION" => {
-                    self.ingest.expansion.prompt_version = v.clone();
-                }
-                "KEBAB_INGEST_EXPANSION_EMBED_ALIASES" => {
-                    self.ingest.expansion.embed_aliases = parse_bool(v);
-                }
-
                // Unknown KEBAB_* keys are silently ignored — see
                // `env_unknown_key_is_ignored` test.
                _ => {}
@@ -1913,41 +1956,6 @@ max_context_tokens = 8000
        assert_eq!(cfg.ingest.code.max_file_bytes, 524_288);
    }

-    #[test]
-    fn expansion_defaults_off() {
-        let cfg = Config::defaults();
-        assert!(!cfg.ingest.expansion.enabled);
-        assert_eq!(cfg.ingest.expansion.max_aliases_per_chunk, 8);
-        assert_eq!(cfg.ingest.expansion.prompt_version, "expansion-v1");
-    }
-
-    #[test]
-    fn expansion_env_override() {
-        let mut env = HashMap::new();
-        env.insert("KEBAB_INGEST_EXPANSION_ENABLED".into(), "true".into());
-        env.insert("KEBAB_INGEST_EXPANSION_MODEL".into(), "gemma3:4b".into());
-        env.insert("KEBAB_INGEST_EXPANSION_MAX_ALIASES".into(), "12".into());
-        env.insert("KEBAB_INGEST_EXPANSION_PROMPT_VERSION".into(), "expansion-v2".into());
-        let c = Config::defaults().apply_env(&env);
-        assert!(c.ingest.expansion.enabled);
-        assert_eq!(c.ingest.expansion.model, "gemma3:4b");
-        assert_eq!(c.ingest.expansion.max_aliases_per_chunk, 12);
-        assert_eq!(c.ingest.expansion.prompt_version, "expansion-v2");
-    }
-
-    #[test]
-    fn embed_aliases_defaults_off() {
-        let cfg = Config::defaults();
-        assert!(!cfg.ingest.expansion.embed_aliases);
-    }
-
-    #[test]
-    fn embed_aliases_env_override() {
-        let mut env = HashMap::new();
-        env.insert("KEBAB_INGEST_EXPANSION_EMBED_ALIASES".into(), "true".into());
-        let c = Config::defaults().apply_env(&env);
-        assert!(c.ingest.expansion.embed_aliases);
-    }
 }

 #[cfg(test)]
--- a/crates/kebab-config/src/migrate.rs
+++ b/crates/kebab-config/src/migrate.rs
@@ -15,7 +15,7 @@ pub const CURRENT_SCHEMA_VERSION: u32 = 2;
 #[derive(Clone, Debug, PartialEq, serde::Serialize)]
 pub struct MigrationChange {
    pub kind: ChangeKind,
-    /// dotted path, 예: `ingest.expansion`, `workspace.include`.
+    /// dotted path, 예: `ingest.code`, `workspace.include`.
    pub path: String,
    /// 사람·wire 용 한 줄 설명.
    pub detail: String,
@@ -83,7 +83,6 @@ fn section_comment(path: &str) -> Option<&'static str> {
        "ui" => "# TUI 팔레트·role 스타일.",
        "ingest" => "# ingest 정책(code skip 등).",
        "ingest.code" => "# code ingest skip 정책(.gitignore 자동 honor).",
-        "ingest.expansion" => "# doc-side 별칭 확장(기본 off). 패러프레이즈 강건성↑, LLM 비용 큼.",
        "pdf" => "# PDF ingest. scanned PDF OCR 은 기본 off(page 당 cost).",
        "pdf.ocr" => "# scanned PDF page-단위 OCR(기본 off).",
        "logging" => "# ingest 로그(기본 on, ~/.local/state/kebab/logs).",
@@ -259,7 +258,7 @@ mod tests {
        // `[pdf]` 등은 안 나오고 `[pdf.ocr]` 같은 하위 테이블만 직렬화된다.
        for section in [
            "[workspace]",
-            "[ingest.expansion]",
+            "[ingest.code]",
            "[pdf.ocr]",
            "[logging]",
            "[ui]",
@@ -273,8 +272,8 @@ mod tests {

    #[test]
    fn reconcile_adds_missing_section_preserving_user_values_and_comments() {
-        // ingest 는 code 만 있고 expansion 누락(v0.21.0 동기 시나리오),
-        // logging 통째 누락, score 는 사용자가 바꿈, 주석 보유.
+        // ingest 통째 누락(→ ingest.code 추가), logging 통째 누락,
+        // default_k 는 사용자가 바꿈, 주석 보유.
        let user_text = "\
 schema_version = 1

@@ -283,9 +282,6 @@ root = \"/my/notes\"   # 내 워크스페이스

 [search]
 default_k = 25
-
-[ingest.code]
-skip_generated_header = true
 ";
        let mut user: DocumentMut = user_text.parse().unwrap();
        let reference = annotated_default_document();
@@ -294,25 +290,22 @@ skip_generated_header = true
        reconcile(&ref_tbl, user.as_table_mut(), "", &mut changes);
        let out = user.to_string();

-        // 부분 존재하는 [ingest] 에 expansion 만 주석과 함께 추가.
-        assert!(out.contains("[ingest.expansion]"), "expansion not added:\n{out}");
+        // 누락된 [ingest.code] 가 주석과 함께 추가.
+        assert!(out.contains("[ingest.code]"), "ingest.code not added:\n{out}");
        // 통째 누락된 logging 추가.
        assert!(out.contains("[logging]"), "logging not added");
        // 사용자 값/주석/기존 섹션 보존.
        assert!(out.contains("root = \"/my/notes\""));
        assert!(out.contains("# 내 워크스페이스"));
        assert!(out.contains("default_k = 25"));
-        assert!(out.contains("skip_generated_header = true"));
        // 새 섹션 주석 부착.
-        assert!(out.contains("doc-side 별칭"));
-        // 부분 존재 부모로 재귀해 leaf 경로를 기록.
+        assert!(out.contains("code ingest skip 정책"));
+        // 통째 누락 부모는 부모 경로로 한 번 기록.
        assert!(
            changes
                .iter()
-                .any(|c| c.kind == ChangeKind::AddedSection && c.path == "ingest.expansion"),
-            "changes: {changes:?}"
+                .any(|c| c.kind == ChangeKind::AddedSection && c.path == "ingest")
        );
-        // 통째 누락 부모는 부모 경로로 한 번 기록.
        assert!(
            changes
                .iter()
@@ -381,7 +374,7 @@ include = [\"*.md\"]
        assert_eq!(outcome.to_schema_version, CURRENT_SCHEMA_VERSION);
        assert!(outcome.changed());
        assert!(!outcome.new_text.contains("include"));
-        assert!(outcome.new_text.contains("[ingest.expansion]"));
+        assert!(outcome.new_text.contains("[ingest.code]"));
        assert_eq!(read_schema_version(&outcome.new_text), CURRENT_SCHEMA_VERSION);

        let again = migrate_document(&outcome.new_text);
--- a/crates/kebab-core/src/chunk.rs
+++ b/crates/kebab-core/src/chunk.rs
@@ -28,13 +28,6 @@ pub struct Chunk {
    /// Bug #8 (한국어 2자 query) 해결을 위한 V009 cascade.
    #[serde(default)]
    pub tokenized_korean_text: Option<String>,
-    /// 색인시 doc-side expansion (Phase 2) 으로 생성된 "검색용 별칭"
-    /// (같은언어 paraphrase + 한↔영 번역, 개행 join). `[ingest.expansion]`
-    /// flag off 또는 미생성이면 None — 별도 FTS5 테이블 `chunk_aliases_fts`
-    /// 에만 색인되고 본문 매칭/dense 임베딩에는 영향 없음. 설계 spec
-    /// `2026-05-30-doc-side-expansion-design.md` §3.3.
-    #[serde(default)]
-    pub aliases: Option<String>,
 }

 #[cfg(test)]
@@ -42,8 +35,8 @@ mod tests {
    use super::*;

    #[test]
-    fn aliases_defaults_to_none_on_deserialize() {
-        // aliases 필드가 없는 과거 JSON 도 파싱되어야 한다 (#[serde(default)]).
+    fn tokenized_korean_text_defaults_to_none_on_deserialize() {
+        // tokenized_korean_text 필드가 없는 과거 JSON 도 파싱되어야 한다 (#[serde(default)]).
        let json = r#"{
            "chunk_id": "c1",
            "doc_id": "d1",
@@ -56,7 +49,6 @@ mod tests {
            "policy_hash": "abc"
        }"#;
        let c: Chunk = serde_json::from_str(json).unwrap();
-        assert_eq!(c.aliases, None);
        assert_eq!(c.tokenized_korean_text, None);
    }
 }
--- a/crates/kebab-embed-candle/Cargo.toml
+++ b/crates/kebab-embed-candle/Cargo.toml
@@ -38,6 +38,9 @@ metal = ["candle-core/metal", "candle-nn/metal", "candle-transformers/metal"]
 # not the library's own (non-dev) dependencies — so rayon/kebab-config/kebab-core
 # are repeated here for tests/parity.rs and tests/thread_cap.rs.
 kebab-embed-local = { path = "../kebab-embed-local" }
+# arctic↔Ollama parity test drives the real Ollama adapter for the reference
+# vectors (tests/arctic_ollama_parity.rs, `#[ignore]` — live Ollama).
+kebab-embed-ollama = { path = "../kebab-embed-ollama" }
 kebab-config = { path = "../kebab-config" }
 kebab-core = { path = "../kebab-core" }
 rayon = "1"
--- a/crates/kebab-embed-candle/src/lib.rs
+++ b/crates/kebab-embed-candle/src/lib.rs
@@ -1,31 +1,44 @@
 //! `kebab-embed-candle` — [`CandleEmbedder`], a pure-Rust (candle)
 //! implementation of [`Embedder`](kebab_core::Embedder).
 //!
-//! Runs the same `intfloat/multilingual-e5-large` model as the default
-//! [`FastembedEmbedder`](kebab_embed_local) but through `candle`
-//! (`candle-transformers`' XLM-RoBERTa) instead of onnxruntime. Motivation:
-//! fastembed 4.9's onnxruntime hard-codes 48 intra-op threads, which corrupts
-//! the heap (double-free) on dual-socket NUMA hosts. candle's CPU backend
-//! sizes its threads off the global rayon pool, so a one-shot
-//! [`rayon::ThreadPoolBuilder`] cap (config `num_threads` / env
-//! `KEBAB_EMBED_THREADS`) keeps the worker count NUMA-safe.
+//! Runs an XLM-RoBERTa-large embedding model through `candle`
+//! (`candle-transformers`' XLM-RoBERTa) instead of onnxruntime. Two models
+//! are wired through a small **registry** ([`MODEL_REGISTRY`]):
 //!
-//! Output parity with the onnxruntime path was proven by the Phase 0 spike
-//! (cosine 1.000000); this crate absorbs that pipeline verbatim:
+//! * `multilingual-e5-large` — the same weights the default
+//!   [`FastembedEmbedder`](kebab_embed_local) uses (mean pooling,
+//!   `query: `/`passage: ` prefixes). candle is the NUMA-safe drop-in:
+//!   fastembed 4.9's onnxruntime hard-codes 48 intra-op threads, which
+//!   corrupts the heap (double-free) on dual-socket NUMA hosts. candle's
+//!   CPU backend sizes its threads off the global rayon pool, so a one-shot
+//!   [`rayon::ThreadPoolBuilder`] cap (config `num_threads` / env
+//!   `KEBAB_EMBED_THREADS`) keeps the worker count NUMA-safe.
+//! * `snowflake-arctic-embed-l-v2.0` — Snowflake's arctic-embed v2.0
+//!   (CLS pooling, `query: ` on queries / no prefix on documents). Same
+//!   XLM-RoBERTa-large architecture, dim 1024, so it rides the exact same
+//!   tokenize → forward → L2 pipeline; only the pooling step and prefixes
+//!   differ (both keyed off the per-model [`EmbedModelSpec`]).
 //!
-//! 1. e5 prefix (`passage: ` for documents, `query: ` for queries — the same
-//!    convention as `kebab-embed-local`'s `prefix_input`);
+//! Output parity with the onnxruntime path (for e5) was proven by the
+//! Phase 0 spike (cosine 1.000000); the arctic path's pooling/prefix
+//! correctness is pinned by an `#[ignore]`d cosine>0.99 cross-check against
+//! Ollama's `snowflake-arctic-embed2` (see `tests/arctic_ollama_parity.rs`).
+//! The shared pipeline:
+//!
+//! 1. instruction prefix per [`EmbedModelSpec`] (query/doc);
 //! 2. tokenize (max_len 512, batch-longest padding, special tokens);
-//! 3. XLM-RoBERTa forward on `Device::Cpu`;
-//! 4. attention-mask-weighted mean pooling;
+//! 3. XLM-RoBERTa forward on the selected [`Device`];
+//! 4. pooling — mean (attention-mask-weighted) or CLS (first token);
 //! 5. L2 normalization.
 //!
 //! Model files (`config.json`, `tokenizer.json`, `model.safetensors`) are
-//! fetched via `hf-hub` into `{config.storage.model_dir}/candle/`.
+//! fetched via `hf-hub` into `{config.storage.model_dir}/candle/` (hf-hub's
+//! cache layout namespaces by repo, so e5 and arctic never collide).
 //!
 //! This crate is **opt-in** (`config.models.embedding.provider = "candle"`);
 //! the default provider stays `fastembed`. See
-//! `docs/superpowers/specs/2026-06-01-embed-candle-track-spec.md`.
+//! `docs/superpowers/specs/2026-06-01-embed-candle-track-spec.md` and
+//! `docs/superpowers/specs/2026-06-03-arctic-embedder-spec.md`.

 use std::sync::Mutex;

@@ -42,22 +55,95 @@ use tokenizers::{PaddingParams, PaddingStrategy, Tokenizer, TruncationParams};
 /// `fastembed/` subdir so the two backends never collide.
 const CANDLE_CACHE_SUBDIR: &str = "candle";

-/// HuggingFace repo id for the multilingual e5 large model. Same weights the
-/// onnxruntime path uses, just the safetensors variant candle can read.
-const HF_MODEL: &str = "intfloat/multilingual-e5-large";
-
-/// The only `config.models.embedding.model` value the candle adapter accepts
-/// (the e5-large weights `HF_MODEL` resolves to). Guards against silently
-/// downloading e5-large while `model_id()` reports a different name.
-const SUPPORTED_MODEL: &str = "multilingual-e5-large";
-
-/// Token truncation length (e5 was trained at 512).
+/// Token truncation length (both e5 and arctic-embed-l-v2.0 train at 512).
 const MAX_LEN: usize = 512;

 /// Env var that overrides `config.models.embedding.num_threads`. Read once in
 /// [`CandleEmbedder::new`]; `0`/unset/unparseable means "leave rayon default".
 const ENV_EMBED_THREADS: &str = "KEBAB_EMBED_THREADS";

+/// Pooling strategy over the model's last hidden state. Keyed per-model by
+/// [`EmbedModelSpec::pooling`] — e5 is mean, arctic is CLS.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Pooling {
+    /// Attention-mask-weighted mean over all tokens (e5 / sentence-transformers
+    /// `pooling_mode_mean_tokens`).
+    Mean,
+    /// First token (`<s>`/`[CLS]`) hidden state (arctic-embed v2.0 —
+    /// `1_Pooling/config.json` has `pooling_mode_cls_token: true`).
+    Cls,
+}
+
+/// One supported embedding model: the HF repo candle downloads, the pooling
+/// strategy, and the e5-style instruction prefixes. [`MODEL_REGISTRY`] maps a
+/// `config.models.embedding.model` value to one of these.
+#[derive(Clone, Copy, Debug)]
+pub struct EmbedModelSpec {
+    /// The short `config.models.embedding.model` value that selects this spec.
+    pub name: &'static str,
+    /// HuggingFace repo id candle fetches `config.json` / `tokenizer.json` /
+    /// `model.safetensors` from.
+    pub hf_repo: &'static str,
+    /// Pooling over the last hidden state.
+    pub pooling: Pooling,
+    /// Prefix prepended to **query** inputs before tokenization.
+    pub query_prefix: &'static str,
+    /// Prefix prepended to **document** inputs before tokenization (arctic
+    /// uses `""` — documents are embedded raw).
+    pub doc_prefix: &'static str,
+    /// Expected embedding dimension (model hidden size).
+    pub dim: usize,
+    /// Suffix folded into `model_version` so switching **to** this model
+    /// triggers the `embedding_version` cascade even if the operator forgets
+    /// to bump `config.version`. `None` keeps the bare `config.version` — used
+    /// by e5 so candle-e5 and fastembed-e5 report the *same* version and stay
+    /// interchangeable (the NUMA drop-in invariant — Phase 0 cosine 1.0).
+    pub version_tag: Option<&'static str>,
+}
+
+/// The models the candle adapter can load. Adding a model = one entry here
+/// (plus, for a non-XLM-R architecture, a new forward path — both current
+/// entries are XLM-RoBERTa-large so they share everything but pooling/prefix).
+static MODEL_REGISTRY: &[EmbedModelSpec] = &[
+    EmbedModelSpec {
+        name: "multilingual-e5-large",
+        hf_repo: "intfloat/multilingual-e5-large",
+        pooling: Pooling::Mean,
+        query_prefix: "query: ",
+        doc_prefix: "passage: ",
+        dim: 1024,
+        version_tag: None,
+    },
+    EmbedModelSpec {
+        name: "snowflake-arctic-embed-l-v2.0",
+        hf_repo: "Snowflake/snowflake-arctic-embed-l-v2.0",
+        pooling: Pooling::Cls,
+        query_prefix: "query: ",
+        doc_prefix: "",
+        dim: 1024,
+        version_tag: Some("arctic-cls"),
+    },
+];
+
+/// Look up a model spec by `config.models.embedding.model`. Accepts either the
+/// short `name` or the full `hf_repo` id (mirrors the old e5 guard, which
+/// accepted both `multilingual-e5-large` and `intfloat/multilingual-e5-large`).
+pub(crate) fn lookup_spec(model: &str) -> Option<&'static EmbedModelSpec> {
+    MODEL_REGISTRY
+        .iter()
+        .find(|s| s.name == model || s.hf_repo == model)
+}
+
+/// Comma-separated list of supported model names, for the
+/// unsupported-model error message.
+fn supported_models() -> String {
+    MODEL_REGISTRY
+        .iter()
+        .map(|s| s.name)
+        .collect::<Vec<_>>()
+        .join("`, `")
+}
+
 /// Pure-Rust candle adapter. Construct via [`CandleEmbedder::new`]; the
 /// constructor downloads the model on first use, so share one instance.
 pub struct CandleEmbedder {
@@ -68,6 +154,9 @@ pub struct CandleEmbedder {
    model: Mutex<XLMRobertaModel>,
    tokenizer: Tokenizer,
    device: Device,
+    /// The resolved model spec (pooling + prefixes) — drives `embed` and
+    /// `embed_batch`.
+    spec: &'static EmbedModelSpec,
    model_id: EmbeddingModelId,
    version: EmbeddingVersion,
    dimensions: usize,
@@ -75,7 +164,8 @@ pub struct CandleEmbedder {
 }

 impl CandleEmbedder {
-    /// Build an embedder from `Config`. Applies the NUMA thread cap, fetches
+    /// Build an embedder from `Config`. Resolves the model spec from
+    /// `config.models.embedding.model`, applies the NUMA thread cap, fetches
    /// the model into `{model_dir}/candle/`, and validates that the model's
    /// hidden size matches `config.models.embedding.dimensions` before
    /// returning.
@@ -104,21 +194,20 @@ impl CandleEmbedder {
            }
        }

-        // 1b. Model guard. `HF_MODEL` is hard-coded (candle currently only wires
-        //     e5-large), so if the operator configured a *different* model name
-        //     we must NOT silently download e5-large and then label its vectors
-        //     with the configured name via `model_id()` — that would mislabel
-        //     `embedding_version` and corrupt a mixed index. Fail fast, before
-        //     the ~2GB download.
+        // 1b. Model registry lookup. If the operator configured a model the
+        //     candle adapter doesn't know, fail fast (BEFORE the ~2GB
+        //     download) — never silently download one model and then label its
+        //     vectors with another name via `model_id()`, which would mislabel
+        //     `embedding_version` and corrupt a mixed index.
        let want = config.models.embedding.model.as_str();
-        if want != SUPPORTED_MODEL && want != HF_MODEL {
-            anyhow::bail!(
-                "candle provider currently supports only '{SUPPORTED_MODEL}' (or \
-                 the HF id '{HF_MODEL}'), but config.models.embedding.model = \
-                 '{want}'. Use provider=fastembed for other models, or set \
-                 model = \"{SUPPORTED_MODEL}\"."
-            );
-        }
+        let spec = lookup_spec(want).ok_or_else(|| {
+            anyhow::anyhow!(
+                "candle provider supports the models `{}`, but \
+                 config.models.embedding.model = '{want}'. Use provider=fastembed \
+                 for other models, or pick a supported one.",
+                supported_models()
+            )
+        })?;

        // 2. Resolve `{data_dir}/models/candle/` exactly like the fastembed
        //    adapter resolves its own subdir.
@@ -134,14 +223,15 @@ impl CandleEmbedder {
        tracing::info!(
            target: "kebab-embed-candle",
            cache_dir = %cache_dir.display(),
-            model = HF_MODEL,
+            model = spec.hf_repo,
+            pooling = ?spec.pooling,
            "loading candle embedding model (first run downloads ~2GB safetensors)"
        );
        let api = hf_hub::api::sync::ApiBuilder::new()
            .with_cache_dir(cache_dir.clone())
            .build()
            .context("kb-embed-candle: build hf-hub api")?;
-        let repo = api.model(HF_MODEL.to_string());
+        let repo = api.model(spec.hf_repo.to_string());
        let config_path = repo.get("config.json").context("download config.json")?;
        let tokenizer_path = repo
            .get("tokenizer.json")
@@ -180,10 +270,21 @@ impl CandleEmbedder {
            }))
            .map_err(|e| anyhow::anyhow!("kb-embed-candle: set truncation: {e}"))?;

+        // model_version: fold the model tag in for non-e5 models so a switch
+        // triggers the embedding_version cascade; e5 keeps the bare
+        // config.version to stay interchangeable with fastembed-e5.
+        let version = match spec.version_tag {
+            Some(tag) => {
+                EmbeddingVersion(format!("{}+{}", config.models.embedding.version, tag))
+            }
+            None => EmbeddingVersion(config.models.embedding.version.clone()),
+        };
+
        tracing::info!(
            target: "kebab-embed-candle",
            dimensions = cfg.hidden_size,
            layers = cfg.num_hidden_layers,
+            model = spec.name,
            "candle embedding model loaded"
        );

@@ -191,16 +292,17 @@ impl CandleEmbedder {
            model: Mutex::new(model),
            tokenizer,
            device,
+            spec,
            model_id: EmbeddingModelId(config.models.embedding.model.clone()),
-            version: EmbeddingVersion(config.models.embedding.version.clone()),
+            version,
            dimensions: cfg.hidden_size,
            batch_size: config.models.embedding.batch_size.max(1),
        })
    }

-    /// Embed one batch of **already-prefixed** strings (the e5 `query:`/
-    /// `passage:` prefix is applied by the caller [`CandleEmbedder::embed`])
-    /// through the candle pipeline: tokenize → forward → masked mean pool → L2.
+    /// Embed one batch of **already-prefixed** strings (the per-model prefix
+    /// is applied by the caller [`CandleEmbedder::embed`]) through the candle
+    /// pipeline: tokenize → forward → pool (mean|CLS) → L2.
    fn embed_batch(&self, prefixed: &[String]) -> Result<Vec<Vec<f32>>> {
        let encodings = self
            .tokenizer
@@ -237,18 +339,30 @@ impl CandleEmbedder {
            guard.forward(&input_ids, &attn_f32, &token_type_ids, None, None, None)?
        };

-        // attention-mask-weighted mean pooling
-        let mask3 = attn_f32.unsqueeze(2)?; // (b, seq, 1)
-        let summed = hidden.broadcast_mul(&mask3)?.sum(1)?; // (b, hidden)
-        // counts ≥ 1 always: every input is e5-prefixed AND special tokens are
-        // added (encode_batch(_, true)), so no row has an all-zero mask. If that
-        // invariant ever breaks, broadcast_div would emit NaN vectors.
-        let counts = mask3.sum(1)?; // (b, 1)
-        let mean = summed.broadcast_div(&counts)?;
+        // Pooling — per the model spec.
+        let pooled = match self.spec.pooling {
+            Pooling::Mean => {
+                // attention-mask-weighted mean pooling
+                let mask3 = attn_f32.unsqueeze(2)?; // (b, seq, 1)
+                let summed = hidden.broadcast_mul(&mask3)?.sum(1)?; // (b, hidden)
+                // counts ≥ 1 always: every input is prefixed AND special
+                // tokens are added (encode_batch(_, true)), so no row has an
+                // all-zero mask. If that invariant ever breaks, broadcast_div
+                // would emit NaN vectors.
+                let counts = mask3.sum(1)?; // (b, 1)
+                summed.broadcast_div(&counts)?
+            }
+            Pooling::Cls => {
+                // CLS pooling: the first token's hidden state. arctic-embed
+                // v2.0 prepends `<s>` (the XLM-R BOS/CLS) at index 0, so
+                // `hidden[:, 0, :]` is the sentence embedding.
+                hidden.narrow(1, 0, 1)?.squeeze(1)? // (b, hidden)
+            }
+        };

        // L2 normalize
-        let norm = mean.sqr()?.sum_keepdim(1)?.sqrt()?;
-        let normalized = mean.broadcast_div(&norm)?;
+        let norm = pooled.sqr()?.sum_keepdim(1)?.sqrt()?;
+        let normalized = pooled.broadcast_div(&norm)?;

        // `.contiguous()` before host copy: broadcast ops can leave a strided
        // view, which `to_vec2` rejects on the Metal backend (CPU tolerates it).
@@ -274,9 +388,9 @@ impl Embedder for CandleEmbedder {
            return Ok(Vec::new());
        }

-        // e5 prefix per §11.3 BEFORE tokenization (same convention as
-        // FastembedEmbedder so the two backends produce comparable vectors).
-        let prefixed: Vec<String> = inputs.iter().map(prefix_input).collect();
+        // Per-model instruction prefix BEFORE tokenization (same convention as
+        // FastembedEmbedder for e5; arctic uses `query: `/no-prefix).
+        let prefixed: Vec<String> = inputs.iter().map(|i| prefix_input(self.spec, i)).collect();

        let mut out: Vec<Vec<f32>> = Vec::with_capacity(prefixed.len());
        for chunk in prefixed.chunks(self.batch_size) {
@@ -298,22 +412,22 @@ impl Embedder for CandleEmbedder {
    }
 }

-/// Build the e5-prefixed string for one [`EmbeddingInput`]. Free function so
-/// a unit test can pin the format without loading the model. Byte-identical to
-/// `kebab-embed-local`'s `prefix_input` — the two backends MUST agree here or
-/// their vectors diverge.
-fn prefix_input(input: &EmbeddingInput<'_>) -> String {
+/// Build the prefixed string for one [`EmbeddingInput`] using the model spec.
+/// Free function so a unit test can pin the format without loading the model.
+/// For e5 this is byte-identical to `kebab-embed-local`'s `prefix_input` — the
+/// two backends MUST agree there or their vectors diverge.
+fn prefix_input(spec: &EmbedModelSpec, input: &EmbeddingInput<'_>) -> String {
    match input.kind {
-        EmbeddingKind::Document => format!("passage: {}", input.text),
-        EmbeddingKind::Query => format!("query: {}", input.text),
+        EmbeddingKind::Document => format!("{}{}", spec.doc_prefix, input.text),
+        EmbeddingKind::Query => format!("{}{}", spec.query_prefix, input.text),
    }
 }

 /// Select the compute device. Built with the `metal` feature (Apple Silicon
 /// GPU), try Metal and fall back to CPU on failure; otherwise CPU. Metal only
-/// compiles/runs on macOS — the Linux server builds the CPU path. e5-large
-/// vectors are model-defined, so Metal-produced and CPU-produced embeddings are
-/// cross-compatible (a Mac can ingest on GPU, the server query on CPU).
+/// compiles/runs on macOS — the Linux server builds the CPU path. Embedding
+/// vectors are model-defined, so Metal-produced and CPU-produced embeddings
+/// are cross-compatible (a Mac can ingest on GPU, the server query on CPU).
 fn select_device() -> Device {
    #[cfg(feature = "metal")]
    {
@@ -367,26 +481,85 @@ pub(crate) fn check_dim(model_dim: usize, cfg_dim: usize) -> Result<()> {
 mod tests {
    use super::*;

-    // ── prefix_input ─────────────────────────────────────────────────
-    // Pin the exact e5 prefix strings; these MUST match
-    // kebab-embed-local::prefix_input or candle vs fastembed parity breaks.
+    fn e5_spec() -> &'static EmbedModelSpec {
+        lookup_spec("multilingual-e5-large").expect("e5 in registry")
+    }
+
+    fn arctic_spec() -> &'static EmbedModelSpec {
+        lookup_spec("snowflake-arctic-embed-l-v2.0").expect("arctic in registry")
+    }
+
+    // ── registry ─────────────────────────────────────────────────────

    #[test]
-    fn prefix_document_uses_passage() {
+    fn registry_resolves_e5_by_name_and_hf_repo() {
+        assert_eq!(
+            lookup_spec("multilingual-e5-large").map(|s| s.name),
+            Some("multilingual-e5-large")
+        );
+        assert_eq!(
+            lookup_spec("intfloat/multilingual-e5-large").map(|s| s.name),
+            Some("multilingual-e5-large")
+        );
+    }
+
+    #[test]
+    fn registry_resolves_arctic_and_its_pooling_is_cls() {
+        let s = arctic_spec();
+        assert_eq!(s.name, "snowflake-arctic-embed-l-v2.0");
+        assert_eq!(s.hf_repo, "Snowflake/snowflake-arctic-embed-l-v2.0");
+        assert_eq!(s.pooling, Pooling::Cls);
+        assert_eq!(s.dim, 1024);
+        assert_eq!(s.version_tag, Some("arctic-cls"));
+    }
+
+    #[test]
+    fn registry_e5_is_mean_pooling_no_version_tag() {
+        let s = e5_spec();
+        assert_eq!(s.pooling, Pooling::Mean);
+        assert_eq!(s.version_tag, None);
+    }
+
+    #[test]
+    fn registry_rejects_unknown_model() {
+        assert!(lookup_spec("multilingual-e5-small").is_none());
+    }
+
+    // ── prefix_input ─────────────────────────────────────────────────
+    // e5 prefixes MUST match kebab-embed-local::prefix_input or candle vs
+    // fastembed parity breaks; arctic uses query-only prefixing.
+
+    #[test]
+    fn e5_prefix_document_uses_passage() {
        let input = EmbeddingInput {
            text: "hello world",
            kind: EmbeddingKind::Document,
        };
-        assert_eq!(prefix_input(&input), "passage: hello world");
+        assert_eq!(prefix_input(e5_spec(), &input), "passage: hello world");
    }

    #[test]
-    fn prefix_query_uses_query() {
+    fn e5_prefix_query_uses_query() {
        let input = EmbeddingInput {
            text: "hello world",
            kind: EmbeddingKind::Query,
        };
-        assert_eq!(prefix_input(&input), "query: hello world");
+        assert_eq!(prefix_input(e5_spec(), &input), "query: hello world");
+    }
+
+    #[test]
+    fn arctic_prefix_query_uses_query_doc_is_bare() {
+        let doc = EmbeddingInput {
+            text: "후입선출 자료구조",
+            kind: EmbeddingKind::Document,
+        };
+        let qry = EmbeddingInput {
+            text: "스택 자료구조",
+            kind: EmbeddingKind::Query,
+        };
+        // arctic: documents are embedded raw, queries get `query: `.
+        assert_eq!(prefix_input(arctic_spec(), &doc), "후입선출 자료구조");
+        assert_eq!(prefix_input(arctic_spec(), &qry), "query: 스택 자료구조");
    }

    #[test]
@@ -399,8 +572,10 @@ mod tests {
            text: "",
            kind: EmbeddingKind::Query,
        };
-        assert_eq!(prefix_input(&doc), "passage: ");
-        assert_eq!(prefix_input(&qry), "query: ");
+        assert_eq!(prefix_input(e5_spec(), &doc), "passage: ");
+        assert_eq!(prefix_input(e5_spec(), &qry), "query: ");
+        assert_eq!(prefix_input(arctic_spec(), &doc), "");
+        assert_eq!(prefix_input(arctic_spec(), &qry), "query: ");
    }

    // ── check_dim ────────────────────────────────────────────────────
@@ -421,9 +596,9 @@ mod tests {
    }

    // ── model guard ──────────────────────────────────────────────────
-    // A non-e5-large model name must fail fast (BEFORE the ~2GB download),
-    // so we never download e5-large yet label its vectors with another name
-    // via model_id() — which would mislabel embedding_version.
+    // A model name not in the registry must fail fast (BEFORE the ~2GB
+    // download), so we never download one model yet label its vectors with
+    // another name via model_id() — which would mislabel embedding_version.

    #[test]
    fn new_rejects_unsupported_model() {
@@ -437,8 +612,8 @@ mod tests {
            .expect("unsupported model must error");
        let msg = format!("{err:#}");
        assert!(
-            msg.contains("candle provider currently supports only"),
-            "expected model-guard error, got: {msg}"
+            msg.contains("candle provider supports the models"),
+            "expected model-registry error, got: {msg}"
        );
    }
 }
--- a/crates/kebab-embed-candle/tests/arctic_ollama_parity.rs
+++ b/crates/kebab-embed-candle/tests/arctic_ollama_parity.rs
@@ -0,0 +1,128 @@
+//! arctic-embed-l-v2.0 correctness gate (`#[ignore]` — needs the ~2GB candle
+//! model + a live Ollama serving `snowflake-arctic-embed2`).
+//!
+//! This is the load-bearing pooling/prefix check for the arctic integration.
+//! The recall measurement that justified adopting arctic (recall@10 130/132)
+//! went through Ollama's `snowflake-arctic-embed2`. The candle path
+//! re-implements the model (XLM-RoBERTa-large + **CLS** pooling + `query: ` on
+//! queries / no prefix on documents). If candle's pooling or prefix is wrong,
+//! its vectors silently diverge from the measured route and the 130 number
+//! does NOT carry over. This test pins them together: per-sentence cosine
+//! between the candle vector and the Ollama vector must be **> 0.99**.
+//!
+//! `#[ignore]` because it depends on an external Ollama daemon (CI is
+//! headless/offline). The leader MUST run it once before merge.
+//!
+//! ## Manual run
+//!
+//! 1. Confirm Ollama is reachable and has the model:
+//!    ```sh
+//!    curl -s http://192.168.0.47:11434/api/tags        # should list snowflake-arctic-embed2
+//!    ```
+//! 2. Run (downloads the ~2GB candle safetensors on first run):
+//!    ```sh
+//!    CARGO_TARGET_DIR=/build/out/cargo-target \
+//!    KEBAB_ARCTIC_OLLAMA_ENDPOINT=http://192.168.0.47:11434 \
+//!    cargo test -p kebab-embed-candle --test arctic_ollama_parity -- --ignored --nocapture
+//!    ```
+//!    The endpoint defaults to `http://192.168.0.47:11434` if the env is unset.
+//!
+//! Record the printed `ARCTIC_PARITY_SUMMARY cosine_min=...` in
+//! `/tmp/arctic-result.md` + `tasks/HOTFIXES.md`.
+
+use kebab_config::Config;
+use kebab_core::{Embedder, EmbeddingInput, EmbeddingKind};
+use kebab_embed_candle::CandleEmbedder;
+use kebab_embed_ollama::OllamaEmbedder;
+
+const DOGFOOD_CONFIG: &str = "/build/dogfood/config.toml";
+const DEFAULT_OLLAMA_ENDPOINT: &str = "http://192.168.0.47:11434";
+
+/// Mixed Korean / English + the descriptive-recall shapes arctic was adopted
+/// for (synonym / abbreviation / English term). Covers both prefix paths.
+const SENTENCES: &[&str] = &[
+    "스택 자료구조",
+    "후입선출 방식으로 동작하는 자료구조",
+    "큐는 선입선출 자료구조이다",
+    "Rust ownership and the borrow checker",
+    "소유권과 빌림 검사기는 메모리 안전성을 보장한다",
+    "SVM 은 support vector machine 의 약자이다",
+    "정렬 알고리즘의 시간 복잡도",
+    "The capital of France is Paris.",
+];
+
+fn cosine(a: &[f32], b: &[f32]) -> f32 {
+    let dot: f32 = a.iter().zip(b).map(|(x, y)| x * y).sum();
+    let na: f32 = a.iter().map(|x| x * x).sum::<f32>().sqrt();
+    let nb: f32 = b.iter().map(|x| x * x).sum::<f32>().sqrt();
+    dot / (na * nb)
+}
+
+/// Base config: prefer the canonical dogfood config (for storage/cache roots),
+/// fall back to `Config::defaults()` so the test still runs on a bare clone.
+fn base_config() -> Config {
+    Config::load(Some(std::path::Path::new(DOGFOOD_CONFIG))).unwrap_or_else(|_| Config::defaults())
+}
+
+#[test]
+#[ignore = "needs ~2GB candle model + live Ollama (snowflake-arctic-embed2); run manually before merge"]
+fn candle_arctic_matches_ollama_arctic() {
+    let endpoint = std::env::var("KEBAB_ARCTIC_OLLAMA_ENDPOINT")
+        .unwrap_or_else(|_| DEFAULT_OLLAMA_ENDPOINT.to_string());
+
+    // candle side: the in-process arctic model.
+    let mut candle_cfg = base_config();
+    candle_cfg.models.embedding.provider = "candle".to_string();
+    candle_cfg.models.embedding.model = "snowflake-arctic-embed-l-v2.0".to_string();
+    candle_cfg.models.embedding.dimensions = 1024;
+
+    // Ollama side: the reference route the recall numbers came from.
+    let mut ollama_cfg = base_config();
+    ollama_cfg.models.embedding.provider = "ollama".to_string();
+    ollama_cfg.models.embedding.model = "snowflake-arctic-embed2".to_string();
+    ollama_cfg.models.embedding.dimensions = 1024;
+    ollama_cfg.models.embedding.endpoint = Some(endpoint.clone());
+
+    let candle = CandleEmbedder::new(&candle_cfg).expect("build candle arctic embedder");
+    let ollama = OllamaEmbedder::new(&ollama_cfg).expect("build ollama arctic embedder");
+
+    // Exercise BOTH prefix paths so a query-side divergence can't hide.
+    let inputs: Vec<EmbeddingInput> = SENTENCES
+        .iter()
+        .flat_map(|s| {
+            [EmbeddingKind::Document, EmbeddingKind::Query]
+                .into_iter()
+                .map(move |kind| EmbeddingInput { text: s, kind })
+        })
+        .collect();
+
+    let cv = candle.embed(&inputs).expect("candle embed");
+    let ov = ollama
+        .embed(&inputs)
+        .expect("ollama embed (is snowflake-arctic-embed2 pulled @ the endpoint?)");
+
+    assert_eq!(cv.len(), ov.len(), "embedding counts must match");
+    assert_eq!(cv.len(), inputs.len(), "one vector per input");
+    assert_eq!(candle.dimensions(), 1024);
+
+    let mut min_cos = f32::INFINITY;
+    for (i, inp) in inputs.iter().enumerate() {
+        assert_eq!(cv[i].len(), 1024, "candle dim");
+        assert_eq!(ov[i].len(), 1024, "ollama dim");
+        let c = cosine(&cv[i], &ov[i]);
+        min_cos = min_cos.min(c);
+        let kind = match inp.kind {
+            EmbeddingKind::Document => "doc",
+            EmbeddingKind::Query => "qry",
+        };
+        let preview: String = inp.text.chars().take(36).collect();
+        println!("[{i:>2}] {kind} cos={c:.6}  {preview}");
+    }
+
+    println!("ARCTIC_PARITY_SUMMARY cosine_min={min_cos:.6} endpoint={endpoint}");
+    assert!(
+        min_cos > 0.99,
+        "candle arctic vs Ollama arctic cosine_min={min_cos:.6} ≤ 0.99 — \
+         pooling/prefix mismatch; the recall=130 measurement will NOT reproduce"
+    );
+}
--- a/crates/kebab-embed-ollama/Cargo.toml
+++ b/crates/kebab-embed-ollama/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "kebab-embed-ollama"
+version       = { workspace = true }
+edition       = { workspace = true }
+rust-version  = { workspace = true }
+license       = { workspace = true }
+repository    = { workspace = true }
+description   = "Ollama HTTP adapter implementing kebab_core::Embedder (POST /api/embed, L2-normalized, batched + fail-soft)"
+
+[dependencies]
+kebab-core = { path = "../kebab-core" }
+kebab-config = { path = "../kebab-config" }
+# `default-features = false` drops native-tls (system OpenSSL); we pin rustls.
+# reqwest 0.12's `blocking` feature wraps a private current-thread tokio
+# runtime — this crate exposes NO async surface (no `async`/`await`/`tokio::*`
+# symbols), matching the kebab-llm-local invariant.
+reqwest    = { version = "0.12", default-features = false, features = ["blocking", "json", "rustls-tls"] }
+serde      = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+tracing    = { workspace = true }
+anyhow     = { workspace = true }
+
+[dev-dependencies]
+# wiremock hosts the mock /api/embed server (needs a tokio runtime); tokio is
+# also pulled transitively at runtime by reqwest's `blocking` feature.
+wiremock   = { workspace = true }
+tokio      = { workspace = true, features = ["macros", "rt"] }
+
+[lints]
+workspace = true
--- a/crates/kebab-embed-ollama/src/lib.rs
+++ b/crates/kebab-embed-ollama/src/lib.rs
@@ -0,0 +1,310 @@
+//! `kebab-embed-ollama` — [`OllamaEmbedder`], a `reqwest::blocking` adapter
+//! implementing [`Embedder`](kebab_core::Embedder) over Ollama's
+//! `POST /api/embed` endpoint.
+//!
+//! ## Why this exists
+//!
+//! The candle backend ([`kebab-embed-candle`]) runs arctic-embed-l-v2.0
+//! in-process (pure Rust, NUMA-safe). This crate is the **fallback** path:
+//! it offloads embedding to a local/remote Ollama daemon (`snowflake-arctic-embed2`),
+//! which is exactly the route the recall measurements used — so it reproduces
+//! the measured numbers (recall@10 130/132) byte-for-route. Opt-in via
+//! `config.models.embedding.provider = "ollama"`.
+//!
+//! ## Wire shape
+//!
+//! Request (`POST {endpoint}/api/embed`):
+//!
+//! ```json
+//! { "model": "snowflake-arctic-embed2", "input": ["query: 스택", "후입선출 ..."] }
+//! ```
+//!
+//! Response:
+//!
+//! ```json
+//! { "model": "...", "embeddings": [[0.01, ...], [0.02, ...]] }
+//! ```
+//!
+//! ## Pipeline
+//!
+//! 1. instruction prefix per model ([`prefixes_for`] — arctic: `query: ` on
+//!    queries, no prefix on documents; e5: `query: `/`passage: `);
+//! 2. batch into `BATCH` (48) inputs per request;
+//! 3. `POST /api/embed`, with fail-soft retry (`MAX_RETRIES`);
+//! 4. **L2 normalize** each returned vector — Ollama returns raw (un-normalized)
+//!    embeddings, so we normalize for cosine consistency with the candle path;
+//! 5. dim check against `config.models.embedding.dimensions`.
+//!
+//! ## Send-safety
+//!
+//! `reqwest::blocking::Client: Send + Sync`; the adapter holds only the client,
+//! an endpoint string, and small config scalars, so it is trivially `Send + Sync`
+//! as the [`Embedder`] trait requires.
+
+use std::time::Duration;
+
+use anyhow::{Context, Result};
+use kebab_core::{Embedder, EmbeddingInput, EmbeddingKind, EmbeddingModelId, EmbeddingVersion};
+use serde::{Deserialize, Serialize};
+
+/// Inputs per `/api/embed` request. Ollama handles arbitrary batch sizes, but
+/// a cap keeps a single HTTP body bounded and lets a partial failure retry a
+/// smaller unit.
+const BATCH: usize = 48;
+
+/// Fail-soft retry attempts per batch before the error propagates. Cold model
+/// load on the Ollama side can transiently 500/timeout; a couple of retries
+/// smooth that over without masking a hard misconfiguration.
+const MAX_RETRIES: u32 = 3;
+
+/// Default per-request HTTP timeout (seconds). Cold-loading an embedding model
+/// on first call can take tens of seconds; this matches the generous default
+/// used by the LLM adapter.
+const REQUEST_TIMEOUT_SECS: u64 = 300;
+
+/// Resolve the (query_prefix, doc_prefix) for an Ollama embedding model tag.
+///
+/// Mirrors `kebab-embed-candle`'s `MODEL_REGISTRY`, but keyed on the **Ollama
+/// model tag** (which differs from the HF id — e.g. `snowflake-arctic-embed2`
+/// vs `Snowflake/snowflake-arctic-embed-l-v2.0`). Kept here rather than shared
+/// so this crate does not depend on the candle backend.
+///
+/// An unrecognized model gets no prefix (`("", "")`): many embedding models
+/// are not instruction-tuned, so embedding the raw text is the correct default
+/// — and a misspelled known model surfaces as a recall regression, not a silent
+/// wrong-prefix, because the dim check still passes either way.
+fn prefixes_for(model: &str) -> (&'static str, &'static str) {
+    let m = model.to_ascii_lowercase();
+    if m.contains("arctic-embed") {
+        // arctic-embed v2.0: `query: ` on queries, documents embedded raw.
+        ("query: ", "")
+    } else if m.contains("e5") {
+        // multilingual-e5: `query: ` / `passage: `.
+        ("query: ", "passage: ")
+    } else {
+        ("", "")
+    }
+}
+
+/// `reqwest::blocking` adapter implementing [`Embedder`] over Ollama's
+/// `/api/embed`. Construction is offline; the first network call happens in
+/// [`Embedder::embed`].
+pub struct OllamaEmbedder {
+    client: reqwest::blocking::Client,
+    /// Validated endpoint base (e.g. `"http://127.0.0.1:11434"`).
+    endpoint: String,
+    /// Ollama model tag (e.g. `"snowflake-arctic-embed2"`).
+    model: String,
+    query_prefix: &'static str,
+    doc_prefix: &'static str,
+    model_id: EmbeddingModelId,
+    version: EmbeddingVersion,
+    dimensions: usize,
+}
+
+impl OllamaEmbedder {
+    /// Build from a workspace [`kebab_config::Config`]. Reads
+    /// `config.models.embedding.{model, dimensions}` and resolves the endpoint
+    /// as `models.embedding.endpoint` → fallback `models.llm.endpoint`.
+    ///
+    /// Does NOT touch the network. The caller (app layer) is expected to have
+    /// validated `provider == "ollama"`.
+    pub fn new(config: &kebab_config::Config) -> Result<Self> {
+        let emb = &config.models.embedding;
+        let endpoint = emb
+            .endpoint
+            .clone()
+            .filter(|e| !e.is_empty())
+            .unwrap_or_else(|| config.models.llm.endpoint.clone());
+        if endpoint.is_empty() {
+            anyhow::bail!(
+                "ollama embedding provider needs an endpoint: set \
+                 `models.embedding.endpoint` (or `models.llm.endpoint`)"
+            );
+        }
+        let client = reqwest::blocking::Client::builder()
+            .timeout(Duration::from_secs(REQUEST_TIMEOUT_SECS))
+            .build()
+            .context("kb-embed-ollama: build reqwest client")?;
+        let (query_prefix, doc_prefix) = prefixes_for(&emb.model);
+        Ok(Self {
+            client,
+            endpoint,
+            model: emb.model.clone(),
+            query_prefix,
+            doc_prefix,
+            model_id: EmbeddingModelId(emb.model.clone()),
+            // model_version = `ollama:{model}` so a provider/model switch
+            // triggers the embedding_version cascade and never collides with
+            // the candle path's version string for the same model.
+            version: EmbeddingVersion(format!("ollama:{}", emb.model)),
+            dimensions: emb.dimensions,
+        })
+    }
+
+    /// Embed one already-prefixed batch via `/api/embed`, with fail-soft retry.
+    fn embed_batch(&self, prefixed: &[String]) -> Result<Vec<Vec<f32>>> {
+        let url = format!("{}/api/embed", self.endpoint.trim_end_matches('/'));
+        let body = EmbedRequest {
+            model: &self.model,
+            input: prefixed,
+        };
+
+        let mut last_err: Option<anyhow::Error> = None;
+        for attempt in 1..=MAX_RETRIES {
+            match self.try_once(&url, &body) {
+                Ok(resp) => return self.finalize(resp, prefixed.len()),
+                Err(e) => {
+                    tracing::warn!(
+                        target: "kebab-embed-ollama",
+                        attempt,
+                        max = MAX_RETRIES,
+                        error = %e,
+                        "ollama /api/embed attempt failed; retrying"
+                    );
+                    last_err = Some(e);
+                }
+            }
+        }
+        Err(last_err.unwrap_or_else(|| {
+            anyhow::anyhow!("kb-embed-ollama: all {MAX_RETRIES} attempts failed")
+        }))
+    }
+
+    /// One HTTP round-trip. Network / non-2xx / decode errors all map to
+    /// `Err` so the retry loop can decide.
+    fn try_once(&self, url: &str, body: &EmbedRequest<'_>) -> Result<EmbedResponse> {
+        let resp = self
+            .client
+            .post(url)
+            .json(body)
+            .send()
+            .with_context(|| format!("kb-embed-ollama: POST {url}"))?;
+        let status = resp.status();
+        if !status.is_success() {
+            let text = resp.text().unwrap_or_default();
+            anyhow::bail!("kb-embed-ollama: /api/embed returned {status}: {text}");
+        }
+        resp.json::<EmbedResponse>()
+            .context("kb-embed-ollama: decode /api/embed response")
+    }
+
+    /// Validate count + dim, then L2-normalize each vector.
+    fn finalize(&self, resp: EmbedResponse, expected: usize) -> Result<Vec<Vec<f32>>> {
+        if resp.embeddings.len() != expected {
+            anyhow::bail!(
+                "kb-embed-ollama: expected {expected} embeddings, got {}",
+                resp.embeddings.len()
+            );
+        }
+        let mut out = Vec::with_capacity(resp.embeddings.len());
+        for v in resp.embeddings {
+            if v.len() != self.dimensions {
+                anyhow::bail!(
+                    "kb-embed-ollama: model returned dim {} but config expects {} \
+                     (check models.embedding.dimensions vs the Ollama model)",
+                    v.len(),
+                    self.dimensions
+                );
+            }
+            out.push(l2_normalize(v));
+        }
+        Ok(out)
+    }
+}
+
+impl Embedder for OllamaEmbedder {
+    fn model_id(&self) -> EmbeddingModelId {
+        self.model_id.clone()
+    }
+
+    fn model_version(&self) -> EmbeddingVersion {
+        self.version.clone()
+    }
+
+    fn dimensions(&self) -> usize {
+        self.dimensions
+    }
+
+    fn embed(&self, inputs: &[EmbeddingInput<'_>]) -> Result<Vec<Vec<f32>>> {
+        if inputs.is_empty() {
+            return Ok(Vec::new());
+        }
+        let prefixed: Vec<String> = inputs.iter().map(|i| self.prefix(i)).collect();
+        let mut out = Vec::with_capacity(prefixed.len());
+        for chunk in prefixed.chunks(BATCH) {
+            out.extend(self.embed_batch(chunk)?);
+        }
+        debug_assert_eq!(out.len(), inputs.len());
+        Ok(out)
+    }
+}
+
+impl OllamaEmbedder {
+    /// Prefix one input per the resolved model prefixes.
+    fn prefix(&self, input: &EmbeddingInput<'_>) -> String {
+        match input.kind {
+            EmbeddingKind::Document => format!("{}{}", self.doc_prefix, input.text),
+            EmbeddingKind::Query => format!("{}{}", self.query_prefix, input.text),
+        }
+    }
+}
+
+/// L2-normalize a vector in place-ish (consumes + returns). A zero vector is
+/// returned unchanged (norm 0 → no division) so a degenerate embedding can
+/// never produce NaNs.
+fn l2_normalize(mut v: Vec<f32>) -> Vec<f32> {
+    let norm = v.iter().map(|x| x * x).sum::<f32>().sqrt();
+    if norm > 0.0 {
+        for x in &mut v {
+            *x /= norm;
+        }
+    }
+    v
+}
+
+// ── Wire types ──────────────────────────────────────────────────────────────
+
+#[derive(Serialize)]
+struct EmbedRequest<'a> {
+    model: &'a str,
+    input: &'a [String],
+}
+
+#[derive(Deserialize)]
+struct EmbedResponse {
+    embeddings: Vec<Vec<f32>>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn prefixes_for_arctic_is_query_only() {
+        assert_eq!(prefixes_for("snowflake-arctic-embed2"), ("query: ", ""));
+        assert_eq!(prefixes_for("snowflake-arctic-embed2:latest"), ("query: ", ""));
+    }
+
+    #[test]
+    fn prefixes_for_e5_is_query_passage() {
+        assert_eq!(prefixes_for("multilingual-e5-large"), ("query: ", "passage: "));
+    }
+
+    #[test]
+    fn prefixes_for_unknown_is_bare() {
+        assert_eq!(prefixes_for("nomic-embed-text"), ("", ""));
+    }
+
+    #[test]
+    fn l2_normalize_unit_length() {
+        let v = l2_normalize(vec![3.0, 4.0]);
+        let norm = (v[0] * v[0] + v[1] * v[1]).sqrt();
+        assert!((norm - 1.0).abs() < 1e-6, "norm = {norm}");
+    }
+
+    #[test]
+    fn l2_normalize_zero_vector_is_unchanged() {
+        assert_eq!(l2_normalize(vec![0.0, 0.0, 0.0]), vec![0.0, 0.0, 0.0]);
+    }
+}
--- a/crates/kebab-embed-ollama/tests/embed_mock.rs
+++ b/crates/kebab-embed-ollama/tests/embed_mock.rs
@@ -0,0 +1,99 @@
+//! `/api/embed` behavior against a `wiremock`-hosted mock server.
+//!
+//! `wiremock` is async, so the tests are `#[tokio::test]`; the sync
+//! [`OllamaEmbedder`] is driven from `spawn_blocking` to keep `reqwest::blocking`
+//! off the async runtime (same pattern as `kebab-llm-local`'s streaming tests).
+//! tokio is a `dev-dependency` only.
+
+use kebab_config::Config;
+use kebab_core::{Embedder, EmbeddingInput, EmbeddingKind};
+use kebab_embed_ollama::OllamaEmbedder;
+use wiremock::matchers::{method, path};
+use wiremock::{Mock, MockServer, ResponseTemplate};
+
+/// Config pointing at the mock server, with a small dim so the mock body is
+/// tiny. `model` is an arctic tag so prefix resolution is exercised.
+fn cfg_for(endpoint: &str, dim: usize) -> Config {
+    let mut cfg = Config::defaults();
+    cfg.models.embedding.provider = "ollama".to_string();
+    cfg.models.embedding.model = "snowflake-arctic-embed2".to_string();
+    cfg.models.embedding.dimensions = dim;
+    cfg.models.embedding.endpoint = Some(endpoint.to_string());
+    cfg
+}
+
+async fn embed_blocking(
+    cfg: Config,
+    inputs: Vec<(String, EmbeddingKind)>,
+) -> anyhow::Result<Vec<Vec<f32>>> {
+    tokio::task::spawn_blocking(move || -> anyhow::Result<Vec<Vec<f32>>> {
+        let emb = OllamaEmbedder::new(&cfg)?;
+        let refs: Vec<EmbeddingInput<'_>> = inputs
+            .iter()
+            .map(|(t, k)| EmbeddingInput { text: t, kind: *k })
+            .collect();
+        emb.embed(&refs)
+    })
+    .await
+    .expect("blocking task panicked")
+}
+
+#[tokio::test]
+async fn embed_returns_l2_normalized_vectors() {
+    let server = MockServer::start().await;
+    // Two raw (un-normalized) vectors of dim 2; the adapter must L2-normalize.
+    let body = r#"{"model":"snowflake-arctic-embed2","embeddings":[[3.0,4.0],[0.0,5.0]]}"#;
+    Mock::given(method("POST"))
+        .and(path("/api/embed"))
+        .respond_with(ResponseTemplate::new(200).set_body_string(body))
+        .mount(&server)
+        .await;
+
+    let out = embed_blocking(
+        cfg_for(&server.uri(), 2),
+        vec![
+            ("스택 자료구조".to_string(), EmbeddingKind::Query),
+            ("후입선출".to_string(), EmbeddingKind::Document),
+        ],
+    )
+    .await
+    .expect("embed should succeed");
+
+    assert_eq!(out.len(), 2);
+    for v in &out {
+        let norm = v.iter().map(|x| x * x).sum::<f32>().sqrt();
+        assert!((norm - 1.0).abs() < 1e-5, "expected unit norm, got {norm}");
+    }
+    // [3,4] → [0.6, 0.8].
+    assert!((out[0][0] - 0.6).abs() < 1e-5 && (out[0][1] - 0.8).abs() < 1e-5);
+}
+
+#[tokio::test]
+async fn embed_rejects_dim_mismatch() {
+    let server = MockServer::start().await;
+    // Server returns dim 3, config expects dim 2 → hard error.
+    let body = r#"{"model":"snowflake-arctic-embed2","embeddings":[[1.0,2.0,3.0]]}"#;
+    Mock::given(method("POST"))
+        .and(path("/api/embed"))
+        .respond_with(ResponseTemplate::new(200).set_body_string(body))
+        .mount(&server)
+        .await;
+
+    let err = embed_blocking(
+        cfg_for(&server.uri(), 2),
+        vec![("q".to_string(), EmbeddingKind::Query)],
+    )
+    .await
+    .expect_err("dim mismatch must error");
+    let msg = format!("{err:#}");
+    assert!(msg.contains("dim"), "expected dim error, got: {msg}");
+}
+
+#[tokio::test]
+async fn embed_empty_input_is_noop() {
+    // No mock needed — empty input must never hit the network.
+    let out = embed_blocking(cfg_for("http://127.0.0.1:1", 2), vec![])
+        .await
+        .expect("empty embed should be Ok(empty)");
+    assert!(out.is_empty());
+}
--- a/crates/kebab-parse-image/Cargo.toml
+++ b/crates/kebab-parse-image/Cargo.toml
@@ -35,6 +35,24 @@ kamadak-exif = "0.6"
 # transitive tokio runtime is brought in once.
 reqwest      = { version = "0.12", default-features = false, features = ["blocking", "json", "rustls-tls"] }
 base64       = { workspace = true }
+thiserror    = { workspace = true }
+# paddle-onnx OCR engine (PP-OCRv5, in-process). We reuse the workspace ort
+# pin (=2.0.0-rc.9) so the ONNX Runtime native lib stays single-versioned with
+# fastembed / kebab-nli (oar-ocr is intentionally NOT a dep — it would pull
+# ort rc.12 + ndarray 0.17, splitting the native `links` and threatening the
+# embedding stack). `download-binaries` extends the pin the same way
+# `kebab-nli/Cargo.toml:23` does: this crate isn't in fastembed's build graph,
+# so a standalone `cargo test -p kebab-parse-image` needs it to link onnxruntime.
+ort          = { workspace = true, features = ["ndarray", "download-binaries"] }
+ndarray      = { workspace = true }
+# blake3: engine_version hash over the bundled det/rec/dict assets (computed
+# once at OnnxPaddleOcr construction, cached — `ingest_config_signature` calls
+# engine_version() per asset).
+blake3       = { workspace = true }
+# imageproc: connected-components / contours for DBNet det post-processing.
+# min-area rotated-rect (rotating calipers) and polygon unclip are implemented
+# in pure Rust (clipper2 is C++ FFI — would break the single-binary guarantee).
+imageproc    = "0.25"

 [dev-dependencies]
 tempfile     = { workspace = true }
--- a/crates/kebab-parse-image/assets/paddleocr-onnx/NOTICE
+++ b/crates/kebab-parse-image/assets/paddleocr-onnx/NOTICE
@@ -0,0 +1,33 @@
+PP-OCRv5 mobile ONNX models bundled with kebab (paddle-onnx OCR engine)
+=======================================================================
+
+These model weights and the recognition dictionary are derived from
+PaddleOCR (https://github.com/PaddlePaddle/PaddleOCR), licensed under the
+Apache License, Version 2.0.
+
+  Copyright (c) PaddlePaddle Authors.
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use these files except in compliance with the License.
+  You may obtain a copy of the License at
+      http://www.apache.org/licenses/LICENSE-2.0
+
+Files
+-----
+  ppocrv5_mobile_det.onnx          PP-OCRv5_mobile detection model (DBNet)
+  korean_ppocrv5_mobile_rec.onnx   korean_PP-OCRv5_mobile recognition model (CTC)
+  korean_dict.txt                  recognition dictionary (11,945 chars: KR + Latin + digits + symbols)
+
+These were converted from the official PaddlePaddle inference models to ONNX
+via paddle2onnx for in-process execution with onnxruntime (`ort`). No model
+architecture or weights were modified; only the serialization format changed.
+
+The recognition CTC class layout (empirically confirmed, see
+tests/golden/ctc_rec_golden.json):
+  index 0          = CTC blank
+  index 1..11945   = korean_dict.txt line N -> class N (dict[N-1])
+  index 11946      = space ' '
+  total classes    = 11947 (= 11945 dict + blank + space)
+
+If any post-processing source (min-area-rect / polygon unclip) is later
+ported verbatim from oar-ocr (Apache-2.0), record the per-file provenance
+here as required by the Apache-2.0 attribution clause.
--- a/crates/kebab-parse-image/assets/paddleocr-onnx/korean_dict.txt
+++ b/crates/kebab-parse-image/assets/paddleocr-onnx/korean_dict.txt
--- a/crates/kebab-parse-image/assets/paddleocr-onnx/korean_ppocrv5_mobile_rec.onnx
+++ b/crates/kebab-parse-image/assets/paddleocr-onnx/korean_ppocrv5_mobile_rec.onnx
--- a/crates/kebab-parse-image/assets/paddleocr-onnx/ppocrv5_mobile_det.onnx
+++ b/crates/kebab-parse-image/assets/paddleocr-onnx/ppocrv5_mobile_det.onnx
--- a/crates/kebab-parse-image/src/lib.rs
+++ b/crates/kebab-parse-image/src/lib.rs
@@ -30,9 +30,11 @@ mod dims;
 mod exif_extract;
 mod image_prep;
 pub mod ocr;
+pub mod paddle_onnx;

 pub use caption::{apply_caption, caption_image};
-pub use ocr::{OcrEngine, OllamaVisionOcr, apply_ocr};
+pub use ocr::{OLLAMA_VISION_ENGINE, OcrEngine, OllamaVisionOcr, apply_ocr};
+pub use paddle_onnx::{ModelPaths, OnnxPaddleOcr, PADDLE_ONNX_ENGINE, engine_version_for_config};

 use anyhow::{Context, Result};
 use kebab_core::{
--- a/crates/kebab-parse-image/src/ocr.rs
+++ b/crates/kebab-parse-image/src/ocr.rs
@@ -65,6 +65,13 @@ pub trait OcrEngine: Send + Sync {
    /// through to engines that benefit from it (Tesseract languages,
    /// LLM prompt steering); ignore otherwise.
    fn recognize(&self, image_bytes: &[u8], lang_hint: Option<&Lang>) -> Result<OcrText>;
+
+    /// Human-facing model label for the ingest progress display
+    /// (`AssetPhase{phase:"ocr", model}`). Distinct from
+    /// [`engine_version`](Self::engine_version), which is the cache-key
+    /// hash. E.g. `"gemma4:e4b"` (ollama-vision) or `"ppocrv5-mobile-kor"`
+    /// (paddle-onnx).
+    fn model(&self) -> &str;
 }

 /// Mutate `block.ocr` in place by running `engine` over `image_bytes`,
@@ -240,6 +247,10 @@ impl OcrEngine for OllamaVisionOcr {
        format!("ollama/{}", self.model)
    }

+    fn model(&self) -> &str {
+        &self.model
+    }
+
    fn recognize(&self, image_bytes: &[u8], lang_hint: Option<&Lang>) -> Result<OcrText> {
        let (prepared, w, h) = image_prep::downscale_to_png(image_bytes, self.max_pixels)
            .context("preparing image for OCR")?;
--- a/crates/kebab-parse-image/src/paddle_onnx.rs
+++ b/crates/kebab-parse-image/src/paddle_onnx.rs
@@ -0,0 +1,902 @@
+//! PP-OCRv5 ONNX OCR engine — in-process detection + recognition on the
+//! workspace-pinned `ort` (=2.0.0-rc.9), no Python runtime, no oar-ocr
+//! production dependency (see crate-level rationale + `assets/paddleocr-onnx/NOTICE`).
+//!
+//! Pipeline (`recognize`):
+//! 1. decode (RGB) + downscale long edge to `max_pixels`
+//! 2. det: ImageNet-normalized NCHW → DBNet prob map `[1,1,H,W]` → threshold
+//!    0.3 → contours → min-area rect (rotating calipers, pure Rust) →
+//!    unclip(ratio 1.5, pure Rust) → boxes
+//! 3. crop+rectify: perspective warp each rotated box to a horizontal strip
+//! 4. rec: 48×W normalized `(x-0.5)/0.5` → `[1,T,11947]` → CTC greedy decode
+//! 5. assemble reading-order `OcrText`
+//!
+//! ## Confirmed CTC facts (empirically derived in T0a, see
+//! `tests/golden/ctc_rec_golden.json` — do NOT re-derive):
+//!   * rec classes = 11947 = dict(11945) + blank + space
+//!   * index 0       = CTC blank
+//!   * index 1..=11945 = `korean_dict.txt` line N → class N (i.e. `dict[N-1]`)
+//!   * index 11946   = space ' '
+//!
+//! ## rc.9 API notes (differ from rc.12):
+//!   * `try_extract_tensor::<f32>()` → `ArrayViewD<f32>` (`.shape()` / indexing).
+//!   * `Session::run` is called through a `Mutex` guard so the engine is
+//!     `Send + Sync` regardless of `Session`'s own auto-trait status (ingest
+//!     is serial today; the lock is uncontended).
+
+use std::path::{Path, PathBuf};
+use std::sync::Mutex;
+
+use anyhow::{Context, Result};
+use kebab_core::{Lang, OcrRegion, OcrText};
+use ndarray::Array4;
+use ort::session::Session;
+use ort::value::Value;
+
+use crate::ocr::OcrEngine;
+
+/// Engine name written into `OcrText.engine`.
+pub const PADDLE_ONNX_ENGINE: &str = "paddle-onnx";
+
+/// CTC blank class index (confirmed in T0a).
+const CTC_BLANK: usize = 0;
+/// Space class index (confirmed in T0a). `1..=DICT_LINES` map to dict entries.
+const CTC_SPACE: usize = 11946;
+/// `korean_dict.txt` line count (confirmed in T0a).
+const DICT_LINES: usize = 11945;
+/// rec output class count = dict + blank + space (confirmed in T0a).
+const REC_CLASSES: usize = 11947;
+
+/// det long-edge cap before rounding to a multiple of 32 (PaddleOCR default).
+const DET_LIMIT_SIDE_LEN: u32 = 960;
+/// rec input height (PP-OCRv5 mobile).
+const REC_HEIGHT: u32 = 48;
+
+/// ImageNet normalization (det preprocessing — RGB).
+const IMAGENET_MEAN: [f32; 3] = [0.485, 0.456, 0.406];
+const IMAGENET_STD: [f32; 3] = [0.229, 0.224, 0.225];
+
+/// PP-OCRv5 ONNX engine. Holds the two ONNX sessions (loaded once) and the
+/// dict. `engine_version` is computed once at construction (blake3 over the
+/// three model assets) and cached — `ingest_config_signature` calls
+/// `engine_version()` per asset, so re-hashing there would be O(assets).
+pub struct OnnxPaddleOcr {
+    det: Mutex<Session>,
+    rec: Mutex<Session>,
+    det_input_name: String,
+    rec_input_name: String,
+    dict: Vec<String>,
+    engine_version: String,
+    score_thresh: f32,
+    unclip_ratio: f32,
+    max_boxes: usize,
+    max_pixels: u32,
+}
+
+impl std::fmt::Debug for OnnxPaddleOcr {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("OnnxPaddleOcr")
+            .field("engine_version", &self.engine_version)
+            .field("dict_lines", &self.dict.len())
+            .field("score_thresh", &self.score_thresh)
+            .field("unclip_ratio", &self.unclip_ratio)
+            .field("max_boxes", &self.max_boxes)
+            .field("max_pixels", &self.max_pixels)
+            .finish_non_exhaustive()
+    }
+}
+
+/// Resolved model-asset paths. Construction is decoupled from `kebab-config`
+/// (T7 adds the `det_model`/`rec_model`/`dict` overrides) so the engine can be
+/// built directly in tests.
+#[derive(Clone, Debug)]
+pub struct ModelPaths {
+    pub det: PathBuf,
+    pub rec: PathBuf,
+    pub dict: PathBuf,
+}
+
+impl ModelPaths {
+    /// Default bundled-asset directory: `KEBAB_IMAGE_OCR_MODEL_DIR` if set,
+    /// else the crate's `assets/paddleocr-onnx/`.
+    pub fn from_default_dir() -> Self {
+        let dir = std::env::var("KEBAB_IMAGE_OCR_MODEL_DIR").map_or_else(
+            |_| Path::new(env!("CARGO_MANIFEST_DIR")).join("assets/paddleocr-onnx"),
+            PathBuf::from,
+        );
+        Self {
+            det: dir.join("ppocrv5_mobile_det.onnx"),
+            rec: dir.join("korean_ppocrv5_mobile_rec.onnx"),
+            dict: dir.join("korean_dict.txt"),
+        }
+    }
+
+    /// Resolve model paths from the `image.ocr` config (T7). Each of
+    /// `det_model` / `rec_model` / `dict` overrides the corresponding bundled
+    /// path when set; unset fields fall back to [`from_default_dir`], so a
+    /// caller can override just one asset.
+    ///
+    /// [`from_default_dir`]: ModelPaths::from_default_dir
+    pub fn from_config(config: &kebab_config::Config) -> Self {
+        let defaults = Self::from_default_dir();
+        let ocr = &config.image.ocr;
+        Self {
+            det: ocr.det_model.as_ref().map(PathBuf::from).unwrap_or(defaults.det),
+            rec: ocr.rec_model.as_ref().map(PathBuf::from).unwrap_or(defaults.rec),
+            dict: ocr.dict.as_ref().map(PathBuf::from).unwrap_or(defaults.dict),
+        }
+    }
+}
+
+impl OnnxPaddleOcr {
+    /// Build from a workspace [`kebab_config::Config`]. Resolves model paths
+    /// from the default bundled directory (T7 will thread config overrides).
+    /// Construction loads both ONNX sessions and hashes the assets — failures
+    /// here are fail-fast (matches the Ollama adapter's construction contract).
+    pub fn new(config: &kebab_config::Config) -> Result<Self> {
+        let paths = ModelPaths::from_config(config);
+        let ocr = &config.image.ocr;
+        Self::from_paths(
+            &paths,
+            ocr.score_thresh,
+            ocr.unclip_ratio,
+            ocr.max_boxes,
+            ocr.max_pixels,
+        )
+    }
+
+    /// Build from explicit asset paths + tuning knobs. Used by tests and by
+    /// `new` after path resolution.
+    pub fn from_paths(
+        paths: &ModelPaths,
+        score_thresh: f32,
+        unclip_ratio: f32,
+        max_boxes: usize,
+        max_pixels: u32,
+    ) -> Result<Self> {
+        let dict = load_dict(&paths.dict)
+            .with_context(|| format!("loading OCR dict from {}", paths.dict.display()))?;
+        // bounds-check: dict length must match the rec class layout
+        // (dict + blank + space). A mismatch means a wrong dict file —
+        // fail at construction rather than mis-decoding silently.
+        if dict.len() != DICT_LINES {
+            anyhow::bail!(
+                "OnnxPaddleOcr: dict has {} lines, expected {DICT_LINES} \
+                 (rec classes {REC_CLASSES} = dict + blank + space)",
+                dict.len()
+            );
+        }
+
+        let engine_version = compute_engine_version(paths)
+            .context("hashing OCR model assets for engine_version")?;
+
+        let det = Session::builder()
+            .context("ort Session::builder (det)")?
+            .commit_from_file(&paths.det)
+            .with_context(|| format!("loading det model {}", paths.det.display()))?;
+        let rec = Session::builder()
+            .context("ort Session::builder (rec)")?
+            .commit_from_file(&paths.rec)
+            .with_context(|| format!("loading rec model {}", paths.rec.display()))?;
+
+        let det_input_name = det
+            .inputs
+            .first()
+            .map(|i| i.name.clone())
+            .context("det model has no inputs")?;
+        let rec_input_name = rec
+            .inputs
+            .first()
+            .map(|i| i.name.clone())
+            .context("rec model has no inputs")?;
+
+        Ok(Self {
+            det: Mutex::new(det),
+            rec: Mutex::new(rec),
+            det_input_name,
+            rec_input_name,
+            dict,
+            engine_version,
+            score_thresh,
+            unclip_ratio,
+            max_boxes,
+            max_pixels: max_pixels.clamp(256, 4096),
+        })
+    }
+
+    /// Map a CTC class index to its output string. `None` for blank.
+    /// `index 0 = blank`, `1..=11945 = dict[index-1]`, `11946 = space`.
+    fn class_to_str(&self, idx: usize) -> Option<&str> {
+        match idx {
+            CTC_BLANK => None,
+            CTC_SPACE => Some(" "),
+            i if (1..=DICT_LINES).contains(&i) => Some(self.dict[i - 1].as_str()),
+            _ => None, // out-of-range guard (should not happen for 11947 classes)
+        }
+    }
+}
+
+impl OcrEngine for OnnxPaddleOcr {
+    fn engine_name(&self) -> &'static str {
+        PADDLE_ONNX_ENGINE
+    }
+
+    fn engine_version(&self) -> String {
+        self.engine_version.clone()
+    }
+
+    // The trait method's elided lifetime ties the return to `&self`; the body
+    // returns a literal, but the signature must match the trait, so allow the
+    // `'static`-narrowing lint here.
+    #[allow(clippy::unnecessary_literal_bound)]
+    fn model(&self) -> &str {
+        // Static label for the progress display; the per-asset hash lives
+        // in `engine_version`.
+        "ppocrv5-mobile-kor"
+    }
+
+    fn recognize(&self, image_bytes: &[u8], _lang_hint: Option<&Lang>) -> Result<OcrText> {
+        let img = image::load_from_memory(image_bytes)
+            .context("decoding image for OCR")?
+            .to_rgb8();
+        let (orig_w, orig_h) = (img.width(), img.height());
+        if orig_w == 0 || orig_h == 0 {
+            return Ok(empty_ocr(self));
+        }
+
+        // ── det ────────────────────────────────────────────────────────
+        let (det_w, det_h) = det_target_dims(orig_w, orig_h, self.max_pixels);
+        let det_img = image::imageops::resize(
+            &img,
+            det_w,
+            det_h,
+            image::imageops::FilterType::Triangle,
+        );
+        let prob = self.run_det(&det_img)?; // (det_h, det_w) prob map
+        let scale_x = orig_w as f32 / det_w as f32;
+        let scale_y = orig_h as f32 / det_h as f32;
+        let mut boxes = det_postprocess(
+            &prob,
+            prob.w,
+            prob.h,
+            self.score_thresh,
+            self.unclip_ratio,
+        );
+        if boxes.len() > self.max_boxes {
+            tracing::warn!(
+                target: "kebab-parse-image",
+                "paddle-onnx: {} boxes exceeds max_boxes {} — truncating",
+                boxes.len(),
+                self.max_boxes
+            );
+            boxes.truncate(self.max_boxes);
+        }
+        // scale box corners back to original image coordinates
+        for b in &mut boxes {
+            for p in &mut b.corners {
+                p.0 *= scale_x;
+                p.1 *= scale_y;
+            }
+        }
+
+        if boxes.is_empty() {
+            return Ok(empty_ocr(self));
+        }
+
+        // ── rec per box (reading order: top→bottom, left→right) ─────────
+        boxes.sort_by(|a, b| {
+            let ay = a.center_y();
+            let by = b.center_y();
+            // group into rough rows by 0.5*box height tolerance via y then x
+            ay.partial_cmp(&by)
+                .unwrap_or(std::cmp::Ordering::Equal)
+                .then_with(|| {
+                    a.center_x()
+                        .partial_cmp(&b.center_x())
+                        .unwrap_or(std::cmp::Ordering::Equal)
+                })
+        });
+
+        let mut regions: Vec<OcrRegion> = Vec::with_capacity(boxes.len());
+        for b in &boxes {
+            let crop = rectify_crop(&img, &b.corners);
+            if crop.width() == 0 || crop.height() == 0 {
+                continue;
+            }
+            let (text, conf) = self.run_rec(&crop)?;
+            if text.is_empty() {
+                continue; // rec empty → skip this box, keep the rest
+            }
+            let (x, y, w, h) = b.aabb();
+            regions.push(OcrRegion {
+                bbox: (x, y, w, h),
+                text,
+                confidence: conf,
+            });
+        }
+
+        let joined = regions
+            .iter()
+            .map(|r| r.text.as_str())
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        Ok(OcrText {
+            joined,
+            regions,
+            engine: PADDLE_ONNX_ENGINE.to_string(),
+            engine_version: self.engine_version.clone(),
+        })
+    }
+}
+
+impl OnnxPaddleOcr {
+    /// Run det session → `(det_h, det_w)` probability map as a row-major Vec.
+    fn run_det(&self, det_img: &image::RgbImage) -> Result<ProbMap> {
+        let (w, h) = (det_img.width() as usize, det_img.height() as usize);
+        let mut arr = Array4::<f32>::zeros((1, 3, h, w));
+        for (x, y, px) in det_img.enumerate_pixels() {
+            let (xi, yi) = (x as usize, y as usize);
+            for c in 0..3 {
+                let v = f32::from(px[c]) / 255.0;
+                arr[[0, c, yi, xi]] = (v - IMAGENET_MEAN[c]) / IMAGENET_STD[c];
+            }
+        }
+        let input = Value::from_array(arr).context("det Value::from_array")?;
+        let sess = self.det.lock().expect("det session mutex poisoned");
+        let outputs = sess
+            .run(ort::inputs![self.det_input_name.as_str() => input]?)
+            .context("det session run")?;
+        let out_name = sess.outputs[0].name.clone();
+        let view = outputs[out_name.as_str()]
+            .try_extract_tensor::<f32>()
+            .context("det output extract")?;
+        // shape [1,1,H,W]
+        let shape = view.shape();
+        let (oh, ow) = (shape[shape.len() - 2], shape[shape.len() - 1]);
+        let data: Vec<f32> = view.iter().copied().collect();
+        Ok(ProbMap { w: ow, h: oh, data })
+    }
+
+    /// Run rec session on a rectified crop → (decoded string, mean confidence).
+    fn run_rec(&self, crop: &image::RgbImage) -> Result<(String, f32)> {
+        // resize keep-aspect to height 48, then this single crop is its own batch
+        let (cw, ch) = (crop.width().max(1), crop.height().max(1));
+        let new_w = ((REC_HEIGHT as f32 / ch as f32) * cw as f32).round().max(1.0) as u32;
+        let resized = image::imageops::resize(
+            crop,
+            new_w,
+            REC_HEIGHT,
+            image::imageops::FilterType::Triangle,
+        );
+        let w = new_w as usize;
+        let h = REC_HEIGHT as usize;
+        let mut arr = Array4::<f32>::zeros((1, 3, h, w));
+        for (x, y, px) in resized.enumerate_pixels() {
+            let (xi, yi) = (x as usize, y as usize);
+            for c in 0..3 {
+                let v = f32::from(px[c]) / 255.0;
+                arr[[0, c, yi, xi]] = (v - 0.5) / 0.5; // [-1, 1]
+            }
+        }
+        let input = Value::from_array(arr).context("rec Value::from_array")?;
+        let sess = self.rec.lock().expect("rec session mutex poisoned");
+        let outputs = sess
+            .run(ort::inputs![self.rec_input_name.as_str() => input]?)
+            .context("rec session run")?;
+        let out_name = sess.outputs[0].name.clone();
+        let view = outputs[out_name.as_str()]
+            .try_extract_tensor::<f32>()
+            .context("rec output extract")?;
+        // shape [1, T, C]
+        let shape = view.shape();
+        let (t, c) = (shape[shape.len() - 2], shape[shape.len() - 1]);
+        if c != REC_CLASSES {
+            anyhow::bail!(
+                "rec output has {c} classes, expected {REC_CLASSES} \
+                 (dict {DICT_LINES} + blank + space)"
+            );
+        }
+        let data: Vec<f32> = view.iter().copied().collect();
+        Ok(self.ctc_greedy_decode(&data, t, c))
+    }
+
+    /// CTC greedy decode over `[T, C]` logits/probs (row-major). Per timestep
+    /// argmax → collapse consecutive duplicates → drop blank → map class→str.
+    fn ctc_greedy_decode(&self, data: &[f32], t: usize, c: usize) -> (String, f32) {
+        let mut out = String::new();
+        let mut confs: Vec<f32> = Vec::new();
+        let mut prev = usize::MAX;
+        for ti in 0..t {
+            let row = &data[ti * c..(ti + 1) * c];
+            let mut best = 0usize;
+            let mut best_v = f32::MIN;
+            for (i, &v) in row.iter().enumerate() {
+                if v > best_v {
+                    best_v = v;
+                    best = i;
+                }
+            }
+            if best != prev && best != CTC_BLANK {
+                if let Some(s) = self.class_to_str(best) {
+                    out.push_str(s);
+                    confs.push(best_v);
+                }
+            }
+            prev = best;
+        }
+        let conf = if confs.is_empty() {
+            0.0
+        } else {
+            confs.iter().sum::<f32>() / confs.len() as f32
+        };
+        (out, conf)
+    }
+}
+
+fn empty_ocr(e: &OnnxPaddleOcr) -> OcrText {
+    OcrText {
+        joined: String::new(),
+        regions: Vec::new(),
+        engine: PADDLE_ONNX_ENGINE.to_string(),
+        engine_version: e.engine_version.clone(),
+    }
+}
+
+/// Load the dict file: one token per line, trailing newline tolerated.
+/// Empty lines are preserved as empty tokens (PaddleOCR dicts may carry a
+/// blank-looking line; index integrity matters more than trimming).
+fn load_dict(path: &Path) -> Result<Vec<String>> {
+    let raw = std::fs::read_to_string(path)?;
+    // split on '\n'; drop a single trailing empty element from the final newline
+    let mut lines: Vec<String> = raw.split('\n').map(|s| s.trim_end_matches('\r').to_string()).collect();
+    if lines.last().is_some_and(String::is_empty) {
+        lines.pop();
+    }
+    Ok(lines)
+}
+
+/// Resolve the paddle-onnx `engine_version` for `config` without loading the
+/// ONNX sessions (T9). This is the same blake3-over-assets string that a
+/// constructed [`OnnxPaddleOcr`] exposes via [`OcrEngine::engine_version`], so
+/// the ingest config signature can include it. Reads ~17 MB of model bytes —
+/// callers MUST memoize per (det,rec,dict) triple (m3: never re-hash per asset).
+pub fn engine_version_for_config(config: &kebab_config::Config) -> Result<String> {
+    compute_engine_version(&ModelPaths::from_config(config))
+}
+
+/// blake3 over det + rec + dict bytes → stable `engine_version`.
+fn compute_engine_version(paths: &ModelPaths) -> Result<String> {
+    let mut hasher = blake3::Hasher::new();
+    for p in [&paths.det, &paths.rec, &paths.dict] {
+        let bytes = std::fs::read(p).with_context(|| format!("reading {}", p.display()))?;
+        hasher.update(&bytes);
+    }
+    let hash = hasher.finalize();
+    let hex = hash.to_hex();
+    Ok(format!("ppocrv5-mobile-kor-{}", &hex.as_str()[..12]))
+}
+
+/// det resize target: keep aspect, cap long edge at `min(max_pixels, 960)`,
+/// then round each dim to a multiple of 32 (DBNet stride). Reproduces the T0a
+/// golden (192×900 → 192×896).
+fn det_target_dims(w: u32, h: u32, max_pixels: u32) -> (u32, u32) {
+    let limit = DET_LIMIT_SIDE_LEN.min(max_pixels.max(32));
+    let long = w.max(h);
+    let ratio = if long > limit {
+        limit as f32 / long as f32
+    } else {
+        1.0
+    };
+    let rw = (w as f32 * ratio).round().max(1.0);
+    let rh = (h as f32 * ratio).round().max(1.0);
+    let round32 = |v: f32| -> u32 {
+        let r = (v / 32.0).round() as u32 * 32;
+        r.max(32)
+    };
+    (round32(rw), round32(rh))
+}
+
+// ── det postprocessing ──────────────────────────────────────────────────────
+
+struct ProbMap {
+    w: usize,
+    h: usize,
+    data: Vec<f32>,
+}
+
+impl ProbMap {
+    #[inline]
+    fn at(&self, x: usize, y: usize) -> f32 {
+        self.data[y * self.w + x]
+    }
+}
+
+/// A detected text box: 4 corners (clockwise from top-left) in det-image
+/// coordinates (later scaled to original).
+#[derive(Clone, Debug)]
+struct DetBox {
+    corners: [(f32, f32); 4],
+    #[allow(dead_code)]
+    score: f32,
+}
+
+impl DetBox {
+    fn center_x(&self) -> f32 {
+        self.corners.iter().map(|p| p.0).sum::<f32>() / 4.0
+    }
+    fn center_y(&self) -> f32 {
+        self.corners.iter().map(|p| p.1).sum::<f32>() / 4.0
+    }
+    /// Axis-aligned bounding box (x, y, w, h) clamped to non-negative.
+    fn aabb(&self) -> (u32, u32, u32, u32) {
+        let xs = self.corners.iter().map(|p| p.0);
+        let ys = self.corners.iter().map(|p| p.1);
+        let minx = xs.clone().fold(f32::MAX, f32::min).max(0.0);
+        let maxx = xs.fold(f32::MIN, f32::max).max(0.0);
+        let miny = ys.clone().fold(f32::MAX, f32::min).max(0.0);
+        let maxy = ys.fold(f32::MIN, f32::max).max(0.0);
+        (
+            minx.round() as u32,
+            miny.round() as u32,
+            (maxx - minx).round().max(0.0) as u32,
+            (maxy - miny).round().max(0.0) as u32,
+        )
+    }
+}
+
+/// DBNet-style postprocess: threshold → connected components → contour →
+/// min-area rect (rotating calipers) → box-score filter → unclip → boxes.
+/// Pinned by `tests/golden/det_boxes_clean_paragraph.json` (3 boxes).
+fn det_postprocess(
+    prob: &ProbMap,
+    w: usize,
+    h: usize,
+    score_thresh: f32,
+    unclip_ratio: f32,
+) -> Vec<DetBox> {
+    use image::{GrayImage, Luma};
+
+    // binarize at the detection threshold
+    let mut bin = GrayImage::new(w as u32, h as u32);
+    for y in 0..h {
+        for x in 0..w {
+            let v = if prob.at(x, y) > 0.3 { 255u8 } else { 0u8 };
+            bin.put_pixel(x as u32, y as u32, Luma([v]));
+        }
+    }
+
+    let contours = imageproc::contours::find_contours::<u32>(&bin);
+    let mut boxes = Vec::new();
+    for contour in &contours {
+        if contour.points.len() < 4 {
+            continue;
+        }
+        let pts: Vec<(f32, f32)> = contour
+            .points
+            .iter()
+            .map(|p| (p.x as f32, p.y as f32))
+            .collect();
+        let Some(rect) = min_area_rect(&pts) else {
+            continue;
+        };
+        // mean-prob box score over the AABB of the rotated rect
+        let score = box_score(prob, &rect.corners);
+        if score < score_thresh {
+            continue;
+        }
+        let unclipped = unclip_rect(&rect, unclip_ratio);
+        boxes.push(DetBox {
+            corners: unclipped,
+            score,
+        });
+    }
+    boxes
+}
+
+/// Mean probability inside the axis-aligned bbox of the rect — the
+/// `box_thresh` mean-prob filter used by the golden harness.
+fn box_score(prob: &ProbMap, corners: &[(f32, f32); 4]) -> f32 {
+    let minx = corners.iter().map(|p| p.0).fold(f32::MAX, f32::min).max(0.0) as usize;
+    let maxx = (corners.iter().map(|p| p.0).fold(f32::MIN, f32::max).max(0.0) as usize)
+        .min(prob.w.saturating_sub(1));
+    let miny = corners.iter().map(|p| p.1).fold(f32::MAX, f32::min).max(0.0) as usize;
+    let maxy = (corners.iter().map(|p| p.1).fold(f32::MIN, f32::max).max(0.0) as usize)
+        .min(prob.h.saturating_sub(1));
+    if maxx <= minx || maxy <= miny {
+        return 0.0;
+    }
+    let mut sum = 0.0f32;
+    let mut n = 0usize;
+    for y in miny..=maxy {
+        for x in minx..=maxx {
+            sum += prob.at(x, y);
+            n += 1;
+        }
+    }
+    if n == 0 { 0.0 } else { sum / n as f32 }
+}
+
+/// Rotated rect described by its 4 corners + box dims.
+#[derive(Clone, Debug)]
+struct RotRect {
+    corners: [(f32, f32); 4],
+    width: f32,
+    height: f32,
+}
+
+/// Minimum-area enclosing rectangle of a point set via rotating calipers on
+/// the convex hull (pure Rust — no OpenCV / clipper2).
+fn min_area_rect(points: &[(f32, f32)]) -> Option<RotRect> {
+    let hull = convex_hull(points);
+    if hull.len() < 3 {
+        return None;
+    }
+    let n = hull.len();
+    let mut best_area = f32::MAX;
+    let mut best: Option<RotRect> = None;
+    for i in 0..n {
+        let p0 = hull[i];
+        let p1 = hull[(i + 1) % n];
+        let edge = (p1.0 - p0.0, p1.1 - p0.1);
+        let len = (edge.0 * edge.0 + edge.1 * edge.1).sqrt();
+        if len < 1e-6 {
+            continue;
+        }
+        let ux = (edge.0 / len, edge.1 / len); // edge direction
+        let uy = (-ux.1, ux.0); // normal
+        let (mut min_u, mut max_u) = (f32::MAX, f32::MIN);
+        let (mut min_v, mut max_v) = (f32::MAX, f32::MIN);
+        for &p in &hull {
+            let du = p.0 * ux.0 + p.1 * ux.1;
+            let dv = p.0 * uy.0 + p.1 * uy.1;
+            min_u = min_u.min(du);
+            max_u = max_u.max(du);
+            min_v = min_v.min(dv);
+            max_v = max_v.max(dv);
+        }
+        let area = (max_u - min_u) * (max_v - min_v);
+        if area < best_area {
+            best_area = area;
+            // reconstruct corners in (u,v) basis → world
+            let to_world = |u: f32, v: f32| (u * ux.0 + v * uy.0, u * ux.1 + v * uy.1);
+            let corners = [
+                to_world(min_u, min_v),
+                to_world(max_u, min_v),
+                to_world(max_u, max_v),
+                to_world(min_u, max_v),
+            ];
+            best = Some(RotRect {
+                corners,
+                width: max_u - min_u,
+                height: max_v - min_v,
+            });
+        }
+    }
+    best
+}
+
+/// Andrew's monotone chain convex hull. Returns CCW hull without duplicates.
+fn convex_hull(points: &[(f32, f32)]) -> Vec<(f32, f32)> {
+    let mut pts: Vec<(f32, f32)> = points.to_vec();
+    pts.sort_by(|a, b| {
+        a.0.partial_cmp(&b.0)
+            .unwrap_or(std::cmp::Ordering::Equal)
+            .then(a.1.partial_cmp(&b.1).unwrap_or(std::cmp::Ordering::Equal))
+    });
+    pts.dedup();
+    if pts.len() < 3 {
+        return pts;
+    }
+    let cross = |o: (f32, f32), a: (f32, f32), b: (f32, f32)| {
+        (a.0 - o.0) * (b.1 - o.1) - (a.1 - o.1) * (b.0 - o.0)
+    };
+    let mut lower: Vec<(f32, f32)> = Vec::new();
+    for &p in &pts {
+        while lower.len() >= 2 && cross(lower[lower.len() - 2], lower[lower.len() - 1], p) <= 0.0 {
+            lower.pop();
+        }
+        lower.push(p);
+    }
+    let mut upper: Vec<(f32, f32)> = Vec::new();
+    for &p in pts.iter().rev() {
+        while upper.len() >= 2 && cross(upper[upper.len() - 2], upper[upper.len() - 1], p) <= 0.0 {
+            upper.pop();
+        }
+        upper.push(p);
+    }
+    lower.pop();
+    upper.pop();
+    lower.extend(upper);
+    lower
+}
+
+/// Unclip a rotated rect by `ratio` (PaddleOCR `distance = area*ratio/perimeter`),
+/// expanding width + height by `2*distance`. For a rectangle this matches the
+/// general polygon offset PaddleOCR uses (pyclipper) — pure Rust here.
+fn unclip_rect(rect: &RotRect, ratio: f32) -> [(f32, f32); 4] {
+    let area = rect.width * rect.height;
+    let perimeter = 2.0 * (rect.width + rect.height);
+    if perimeter < 1e-6 {
+        return rect.corners;
+    }
+    let distance = area * ratio / perimeter;
+    // Offset every EDGE outward by `distance` (PaddleOCR pyclipper polygon
+    // offset): width and height each grow by 2*distance. A naive radial
+    // push-from-centroid is WRONG for text boxes — a wide/short box has an
+    // almost-horizontal diagonal, so radial expansion barely grows the height
+    // and clips character tops/bottoms (ㄷ→ㄴ, ascenders lost). We instead
+    // expand along the rect's own (u, v) axes recovered from its ordered
+    // corners (c0=min_u,min_v; c1=max_u,min_v; c2=max_u,max_v; c3=min_u,max_v).
+    let c = &rect.corners;
+    let unit = |dx: f32, dy: f32| -> (f32, f32) {
+        let len = (dx * dx + dy * dy).sqrt();
+        if len > 1e-6 { (dx / len, dy / len) } else { (0.0, 0.0) }
+    };
+    let u = unit(c[1].0 - c[0].0, c[1].1 - c[0].1); // +u (along width)
+    let v = unit(c[3].0 - c[0].0, c[3].1 - c[0].1); // +v (along height)
+    let off = |p: (f32, f32), su: f32, sv: f32| -> (f32, f32) {
+        (
+            p.0 + su * distance * u.0 + sv * distance * v.0,
+            p.1 + su * distance * u.1 + sv * distance * v.1,
+        )
+    };
+    [
+        off(c[0], -1.0, -1.0),
+        off(c[1], 1.0, -1.0),
+        off(c[2], 1.0, 1.0),
+        off(c[3], -1.0, 1.0),
+    ]
+}
+
+// ── crop + rectify ───────────────────────────────────────────────────────────
+
+/// Perspective-warp the quadrilateral `corners` (clockwise from top-left) into
+/// a horizontal strip. Output size derives from the box edge lengths.
+fn rectify_crop(img: &image::RgbImage, corners: &[(f32, f32); 4]) -> image::RgbImage {
+    // order corners: top-left, top-right, bottom-right, bottom-left
+    let ordered = order_corners(corners);
+    let dist = |a: (f32, f32), b: (f32, f32)| ((a.0 - b.0).powi(2) + (a.1 - b.1).powi(2)).sqrt();
+    let w = dist(ordered[0], ordered[1]).max(dist(ordered[3], ordered[2]));
+    let h = dist(ordered[0], ordered[3]).max(dist(ordered[1], ordered[2]));
+    let out_w = w.round().max(1.0) as u32;
+    let out_h = h.round().max(1.0) as u32;
+    let mut out = image::RgbImage::new(out_w, out_h);
+    let (iw, ih) = (img.width() as f32, img.height() as f32);
+    // bilinear map from output grid back to the source quad (inverse via
+    // bilinear interpolation of the four corners — adequate for near-affine
+    // text boxes).
+    for oy in 0..out_h {
+        let fy = oy as f32 / (out_h.max(1) as f32 - 1.0).max(1.0);
+        for ox in 0..out_w {
+            let fx = ox as f32 / (out_w.max(1) as f32 - 1.0).max(1.0);
+            // bilinear blend of the four source corners
+            let top = (
+                ordered[0].0 + (ordered[1].0 - ordered[0].0) * fx,
+                ordered[0].1 + (ordered[1].1 - ordered[0].1) * fx,
+            );
+            let bot = (
+                ordered[3].0 + (ordered[2].0 - ordered[3].0) * fx,
+                ordered[3].1 + (ordered[2].1 - ordered[3].1) * fx,
+            );
+            let sx = (top.0 + (bot.0 - top.0) * fy).clamp(0.0, iw - 1.0);
+            let sy = (top.1 + (bot.1 - top.1) * fy).clamp(0.0, ih - 1.0);
+            let px = img.get_pixel(sx.round() as u32, sy.round() as u32);
+            out.put_pixel(ox, oy, *px);
+        }
+    }
+    out
+}
+
+/// Order 4 corners as [top-left, top-right, bottom-right, bottom-left] using
+/// coordinate sums/diffs (standard PaddleOCR ordering).
+fn order_corners(corners: &[(f32, f32); 4]) -> [(f32, f32); 4] {
+    // top-left has smallest x+y, bottom-right largest x+y;
+    // top-right smallest y-x, bottom-left largest y-x.
+    let mut tl = corners[0];
+    let mut br = corners[0];
+    let mut tr = corners[0];
+    let mut bl = corners[0];
+    let (mut min_sum, mut max_sum) = (f32::MAX, f32::MIN);
+    let (mut min_diff, mut max_diff) = (f32::MAX, f32::MIN);
+    for &p in corners {
+        let sum = p.0 + p.1;
+        let diff = p.1 - p.0;
+        if sum < min_sum {
+            min_sum = sum;
+            tl = p;
+        }
+        if sum > max_sum {
+            max_sum = sum;
+            br = p;
+        }
+        if diff < min_diff {
+            min_diff = diff;
+            tr = p;
+        }
+        if diff > max_diff {
+            max_diff = diff;
+            bl = p;
+        }
+    }
+    [tl, tr, br, bl]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn det_target_dims_matches_golden() {
+        // T0a golden: clean_paragraph 192×900 → det input 192×896.
+        assert_eq!(det_target_dims(900, 192, 1600), (896, 192));
+    }
+
+    #[test]
+    fn convex_hull_square() {
+        let pts = vec![(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0), (5.0, 5.0)];
+        let hull = convex_hull(&pts);
+        assert_eq!(hull.len(), 4);
+    }
+
+    #[test]
+    fn min_area_rect_axis_aligned() {
+        let pts = vec![(0.0, 0.0), (20.0, 0.0), (20.0, 5.0), (0.0, 5.0)];
+        let r = min_area_rect(&pts).expect("rect");
+        let (lo, hi) = (r.width.min(r.height), r.width.max(r.height));
+        assert!((lo - 5.0).abs() < 1e-3, "short side {lo}");
+        assert!((hi - 20.0).abs() < 1e-3, "long side {hi}");
+    }
+
+    #[test]
+    fn dict_length_mismatch_is_construction_error() {
+        // T10: a dict whose line count != DICT_LINES must fail at construction
+        // (before loading the ONNX sessions) rather than mis-decoding silently.
+        use std::io::Write;
+        let dir = tempfile::tempdir().unwrap();
+        let dict_path = dir.path().join("bad_dict.txt");
+        let mut f = std::fs::File::create(&dict_path).unwrap();
+        writeln!(f, "a\nb\nc").unwrap(); // 3 lines, not DICT_LINES
+        let paths = ModelPaths {
+            det: dir.path().join("unused_det.onnx"),
+            rec: dir.path().join("unused_rec.onnx"),
+            dict: dict_path,
+        };
+        let err = OnnxPaddleOcr::from_paths(&paths, 0.3, 1.5, 1000, 1600)
+            .expect_err("dict mismatch must error");
+        let msg = format!("{err:#}");
+        assert!(msg.contains("dict has 3 lines"), "unexpected error: {msg}");
+    }
+
+    #[test]
+    fn model_paths_from_config_uses_overrides() {
+        // T7: unset overrides → bundled default asset paths.
+        let mut cfg = kebab_config::Config::defaults();
+        let def = ModelPaths::from_config(&cfg);
+        assert!(def.det.ends_with("ppocrv5_mobile_det.onnx"), "{:?}", def.det);
+        assert!(def.rec.ends_with("korean_ppocrv5_mobile_rec.onnx"), "{:?}", def.rec);
+        assert!(def.dict.ends_with("korean_dict.txt"), "{:?}", def.dict);
+
+        // Override det + dict; rec stays bundled (partial override allowed).
+        cfg.image.ocr.det_model = Some("/custom/det.onnx".to_string());
+        cfg.image.ocr.dict = Some("/custom/dict.txt".to_string());
+        let ov = ModelPaths::from_config(&cfg);
+        assert_eq!(ov.det, PathBuf::from("/custom/det.onnx"));
+        assert_eq!(ov.dict, PathBuf::from("/custom/dict.txt"));
+        assert!(ov.rec.ends_with("korean_ppocrv5_mobile_rec.onnx"), "{:?}", ov.rec);
+    }
+
+    #[test]
+    fn unclip_expands_box() {
+        let rect = RotRect {
+            corners: [(0.0, 0.0), (20.0, 0.0), (20.0, 5.0), (0.0, 5.0)],
+            width: 20.0,
+            height: 5.0,
+        };
+        let out = unclip_rect(&rect, 1.5);
+        // unclipped box must be strictly larger than the original
+        let orig_minx = 0.0;
+        let new_minx = out.iter().map(|p| p.0).fold(f32::MAX, f32::min);
+        assert!(new_minx < orig_minx, "expected expansion, got {new_minx}");
+    }
+}
--- a/crates/kebab-parse-image/tests/golden/ctc_rec_golden.json
+++ b/crates/kebab-parse-image/tests/golden/ctc_rec_golden.json
@@ -0,0 +1,516 @@
+{
+  "dict_lines": 11945,
+  "rec_classes": 11947,
+  "blank_index": 0,
+  "space_index": 11946,
+  "mapping": "idx0=blank; idx 1..N=dict[idx-1]; idx N+1=space; classes=dict+2",
+  "rec_norm": "RGB, /255 then (x-0.5)/0.5 => [-1,1], height=48 keep-aspect pad",
+  "det_norm": "RGB, ImageNet mean/std *255 then /std, NCHW",
+  "rec_cases": [
+    {
+      "text": "RAG 시스템 검색 결과",
+      "decoded": "RAG시스템 검색 결과",
+      "cer": 0.0769,
+      "cer_nospace": 0.0,
+      "mapping_ok": true,
+      "T": 40,
+      "C": 11947,
+      "argmax_idx": [
+        0,
+        0,
+        11553,
+        0,
+        11536,
+        0,
+        0,
+        11542,
+        0,
+        0,
+        0,
+        6185,
+        0,
+        0,
+        6129,
+        0,
+        0,
+        9897,
+        0,
+        0,
+        11946,
+        0,
+        461,
+        0,
+        0,
+        0,
+        5654,
+        0,
+        11946,
+        0,
+        509,
+        0,
+        0,
+        0,
+        585,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      "collapsed_idx": [
+        11553,
+        11536,
+        11542,
+        6185,
+        6129,
+        9897,
+        11946,
+        461,
+        5654,
+        11946,
+        509,
+        585
+      ],
+      "collapsed_conf": [
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002
+      ],
+      "fired_timesteps": [
+        2,
+        4,
+        7,
+        11,
+        14,
+        17,
+        20,
+        22,
+        26,
+        28,
+        30,
+        34
+      ],
+      "fired_logit_top5": [
+        {
+          "t": 2,
+          "top5_idx": [
+            11553,
+            11583,
+            11551,
+            0,
+            11541
+          ],
+          "top5_val": [
+            0.9998,
+            0.0001,
+            0.0,
+            0.0,
+            0.0
+          ]
+        },
+        {
+          "t": 4,
+          "top5_idx": [
+            11536,
+            11566,
+            0,
+            11748,
+            11551
+          ],
+          "top5_val": [
+            0.9998,
+            0.0001,
+            0.0,
+            0.0,
+            0.0
+          ]
+        },
+        {
+          "t": 7,
+          "top5_idx": [
+            11542,
+            0,
+            11572,
+            11946,
+            11585
+          ],
+          "top5_val": [
+            0.9994,
+            0.0004,
+            0.0001,
+            0.0001,
+            0.0
+          ]
+        },
+        {
+          "t": 11,
+          "top5_idx": [
+            6185,
+            0,
+            11946,
+            7949,
+            11518
+          ],
+          "top5_val": [
+            0.9993,
+            0.0003,
+            0.0001,
+            0.0001,
+            0.0
+          ]
+        },
+        {
+          "t": 14,
+          "top5_idx": [
+            6129,
+            7893,
+            0,
+            9069,
+            11536
+          ],
+          "top5_val": [
+            0.9997,
+            0.0002,
+            0.0,
+            0.0,
+            0.0
+          ]
+        },
+        {
+          "t": 17,
+          "top5_idx": [
+            9897,
+            9882,
+            9889,
+            9785,
+            3429
+          ],
+          "top5_val": [
+            0.9999,
+            0.0,
+            0.0,
+            0.0,
+            0.0
+          ]
+        },
+        {
+          "t": 20,
+          "top5_idx": [
+            11946,
+            0,
+            11516,
+            11518,
+            11579
+          ],
+          "top5_val": [
+            0.9026,
+            0.0971,
+            0.0002,
+            0.0001,
+            0.0
+          ]
+        },
+        {
+          "t": 22,
+          "top5_idx": [
+            461,
+            462,
+            9281,
+            349,
+            0
+          ],
+          "top5_val": [
+            0.9995,
+            0.0003,
+            0.0001,
+            0.0,
+            0.0
+          ]
+        },
+        {
+          "t": 26,
+          "top5_idx": [
+            5654,
+            0,
+            5766,
+            8594,
+            6830
+          ],
+          "top5_val": [
+            1.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0
+          ]
+        },
+        {
+          "t": 28,
+          "top5_idx": [
+            11946,
+            0,
+            11516,
+            11549,
+            11564
+          ],
+          "top5_val": [
+            0.9422,
+            0.0576,
+            0.0001,
+            0.0,
+            0.0
+          ]
+        },
+        {
+          "t": 30,
+          "top5_idx": [
+            509,
+            0,
+            453,
+            11946,
+            505
+          ],
+          "top5_val": [
+            0.9994,
+            0.0004,
+            0.0001,
+            0.0,
+            0.0
+          ]
+        },
+        {
+          "t": 34,
+          "top5_idx": [
+            585,
+            641,
+            0,
+            10329,
+            589
+          ],
+          "top5_val": [
+            0.9999,
+            0.0,
+            0.0,
+            0.0,
+            0.0
+          ]
+        }
+      ]
+    },
+    {
+      "text": "Embedding vector 0123",
+      "decoded": "Embedding vector 0123",
+      "cer": 0.0,
+      "cer_nospace": 0.0,
+      "mapping_ok": true,
+      "T": 41,
+      "C": 11947,
+      "argmax_idx": [
+        0,
+        11540,
+        0,
+        0,
+        11578,
+        0,
+        0,
+        11567,
+        0,
+        11570,
+        0,
+        11569,
+        0,
+        11569,
+        0,
+        11574,
+        0,
+        11579,
+        11572,
+        11572,
+        11946,
+        0,
+        11587,
+        11570,
+        0,
+        11568,
+        0,
+        11585,
+        11580,
+        0,
+        11583,
+        11946,
+        11946,
+        11520,
+        0,
+        11521,
+        0,
+        11522,
+        0,
+        11523,
+        0
+      ],
+      "collapsed_idx": [
+        11540,
+        11578,
+        11567,
+        11570,
+        11569,
+        11569,
+        11574,
+        11579,
+        11572,
+        11946,
+        11587,
+        11570,
+        11568,
+        11585,
+        11580,
+        11583,
+        11946,
+        11520,
+        11521,
+        11522,
+        11523
+      ],
+      "collapsed_conf": [
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0001,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002
+      ]
+    },
+    {
+      "text": "한글 OCR 정확도 테스트",
+      "decoded": "한글 OCR 정확도 테스트",
+      "cer": 0.0,
+      "cer_nospace": 0.0,
+      "mapping_ok": true,
+      "T": 41,
+      "C": 11947,
+      "argmax_idx": [
+        0,
+        0,
+        10921,
+        0,
+        0,
+        0,
+        845,
+        0,
+        11946,
+        0,
+        11550,
+        0,
+        0,
+        11538,
+        0,
+        11553,
+        0,
+        11946,
+        0,
+        7522,
+        0,
+        0,
+        11170,
+        0,
+        0,
+        0,
+        2321,
+        0,
+        11946,
+        11946,
+        9881,
+        0,
+        0,
+        0,
+        6129,
+        0,
+        0,
+        0,
+        10245,
+        0,
+        0
+      ],
+      "collapsed_idx": [
+        10921,
+        845,
+        11946,
+        11550,
+        11538,
+        11553,
+        11946,
+        7522,
+        11170,
+        2321,
+        11946,
+        9881,
+        6129,
+        10245
+      ],
+      "collapsed_conf": [
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002,
+        0.0002
+      ]
+    }
+  ],
+  "det_cases": [
+    {
+      "fixture": "clean_paragraph.png",
+      "orig_hw": [
+        192,
+        900
+      ],
+      "det_input_hw": [
+        192,
+        896
+      ],
+      "prob_shape": [
+        192,
+        896
+      ],
+      "prob_max": 1.0,
+      "prob_mean": 0.1139,
+      "positives_at_0.3": 19682,
+      "positive_frac": 0.1144,
+      "box_count": 3,
+      "postproc": "thresh=0.3 -> findContours -> minAreaRect -> unclip(ratio=1.5, area*r/peri); box_thresh=0.5 mean-prob filter; coords scaled back to orig hw"
+    }
+  ],
+  "blank_index_confirmed_by_gt": true
+}
--- a/crates/kebab-parse-image/tests/golden/det_boxes_clean_paragraph.json
+++ b/crates/kebab-parse-image/tests/golden/det_boxes_clean_paragraph.json
@@ -0,0 +1,78 @@
+{
+  "fixture": "clean_paragraph.png",
+  "orig_hw": [
+    192,
+    900
+  ],
+  "det_input_hw": [
+    192,
+    896
+  ],
+  "thresh": 0.3,
+  "unclip_ratio": 1.5,
+  "boxes": [
+    {
+      "poly": [
+        [
+          29,
+          135
+        ],
+        [
+          615,
+          134
+        ],
+        [
+          615,
+          149
+        ],
+        [
+          29,
+          150
+        ]
+      ],
+      "score": 0.8724
+    },
+    {
+      "poly": [
+        [
+          30,
+          92
+        ],
+        [
+          597,
+          92
+        ],
+        [
+          597,
+          105
+        ],
+        [
+          30,
+          105
+        ]
+      ],
+      "score": 0.9627
+    },
+    {
+      "poly": [
+        [
+          30,
+          47
+        ],
+        [
+          509,
+          47
+        ],
+        [
+          509,
+          60
+        ],
+        [
+          30,
+          60
+        ]
+      ],
+      "score": 0.9304
+    }
+  ]
+}
--- a/crates/kebab-parse-image/tests/paddle_e2e.rs
+++ b/crates/kebab-parse-image/tests/paddle_e2e.rs
@@ -0,0 +1,145 @@
+//! T11 e2e accuracy gate for the paddle-onnx OCR engine.
+//!
+//! Runs the full `OnnxPaddleOcr` pipeline (det → rectify → rec → CTC) over the
+//! synthetic OCR benchmark fixtures and asserts the mean character error rate
+//! (CER) over the clean text set is `<= 0.05`, matching the spec gate.
+//!
+//! Model assets come from `KEBAB_TEST_OCR_MODEL_DIR` (default: the crate's
+//! bundled `assets/paddleocr-onnx/`). Fixtures come from
+//! `KEBAB_TEST_OCR_FIXTURE_DIR` (default: the dogfood corpus). If either is
+//! absent the test skips with a warning rather than failing — CI without the
+//! large models / fixtures stays green (plan T0/M4).
+
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+use kebab_parse_image::{ModelPaths, OcrEngine, OnnxPaddleOcr};
+
+/// Collapse all whitespace runs to a single space + trim — matches the Python
+/// `score_lib.norm` so the Rust gate and the bench harness agree.
+fn norm(s: &str) -> String {
+    s.split_whitespace().collect::<Vec<_>>().join(" ")
+}
+
+/// Character error rate = Levenshtein(gt, pred) / len(gt), both normalized.
+fn cer(gt: &str, pred: &str) -> f64 {
+    let g: Vec<char> = norm(gt).chars().collect();
+    let p: Vec<char> = norm(pred).chars().collect();
+    if g.is_empty() {
+        return if p.is_empty() { 0.0 } else { 1.0 };
+    }
+    let (m, n) = (g.len(), p.len());
+    let mut prev: Vec<usize> = (0..=n).collect();
+    for i in 1..=m {
+        let mut cur = vec![i; n + 1];
+        for j in 1..=n {
+            let cost = usize::from(g[i - 1] != p[j - 1]);
+            cur[j] = (prev[j] + 1).min(cur[j - 1] + 1).min(prev[j - 1] + cost);
+        }
+        prev = cur;
+    }
+    prev[n] as f64 / m as f64
+}
+
+fn fixture_dir() -> PathBuf {
+    std::env::var("KEBAB_TEST_OCR_FIXTURE_DIR").map_or_else(
+        |_| PathBuf::from("/build/dogfood/corpus/images/synthetic-ocr-bench"),
+        PathBuf::from,
+    )
+}
+
+/// T10: undecodable image bytes must surface as an error (the kebab-app caller
+/// then skips the asset + records provenance), not panic or return garbage.
+#[test]
+fn paddle_onnx_decode_failure_is_error() {
+    let paths = ModelPaths::from_default_dir();
+    if !paths.det.exists() || !paths.rec.exists() || !paths.dict.exists() {
+        eprintln!("SKIP paddle_onnx_decode_failure_is_error: model assets not found");
+        return;
+    }
+    let engine = OnnxPaddleOcr::from_paths(&paths, 0.3, 1.5, 1000, 1600).unwrap();
+    let err = engine
+        .recognize(b"not a real image", None)
+        .expect_err("garbage bytes must fail to decode");
+    let msg = format!("{err:#}");
+    assert!(msg.contains("decoding image"), "unexpected error: {msg}");
+}
+
+#[test]
+fn paddle_onnx_cer_gate() {
+    let paths = ModelPaths::from_default_dir();
+    if !paths.det.exists() || !paths.rec.exists() || !paths.dict.exists() {
+        eprintln!(
+            "SKIP paddle_onnx_cer_gate: model assets not found (det={}). \
+             Set KEBAB_TEST_OCR_MODEL_DIR or place assets/paddleocr-onnx/.",
+            paths.det.display()
+        );
+        return;
+    }
+    let fdir = fixture_dir();
+    let gt_path = fdir.join("gt.json");
+    if !gt_path.exists() {
+        eprintln!(
+            "SKIP paddle_onnx_cer_gate: fixtures not found at {}",
+            fdir.display()
+        );
+        return;
+    }
+
+    let gt: HashMap<String, String> =
+        serde_json::from_str(&std::fs::read_to_string(&gt_path).unwrap()).unwrap();
+
+    let engine = OnnxPaddleOcr::from_paths(&paths, 0.3, 1.5, 1000, 1600)
+        .expect("build OnnxPaddleOcr from bundled assets");
+
+    // "clean" set used for the gate — the standard, well-formed text fixtures.
+    // low_contrast / small_dense are intentionally hard and tracked but not
+    // part of the hard gate.
+    let gate_set = [
+        "clean_paragraph.png",
+        "title_body.png",
+        "tech_terms.png",
+        "korean_heavy.png",
+        "numbers_table.png",
+    ];
+
+    let mut gate_cers = Vec::new();
+    let mut names: Vec<&String> = gt.keys().collect();
+    names.sort();
+    println!("\n=== paddle-onnx CER per fixture ===");
+    for name in names {
+        let img_path = fdir.join(name);
+        if !img_path.exists() {
+            continue;
+        }
+        let bytes = std::fs::read(&img_path).unwrap();
+        let t0 = std::time::Instant::now();
+        let out = engine.recognize(&bytes, None).expect("recognize");
+        let dt = t0.elapsed();
+        let c = cer(&gt[name], &out.joined);
+        if std::env::var("KEBAB_OCR_DUMP").is_ok() {
+            println!("  GT  [{name}]: {:?}", norm(&gt[name]));
+            println!("  OUT [{name}]: {:?}", norm(&out.joined));
+        }
+        let gated = gate_set.contains(&name.as_str());
+        println!(
+            "{:<22} CER={:.4} {} ({} regions, {} ms)",
+            name,
+            c,
+            if gated { "[gate]" } else { "      " },
+            out.regions.len(),
+            dt.as_millis()
+        );
+        if gated {
+            gate_cers.push(c);
+        }
+    }
+
+    assert!(!gate_cers.is_empty(), "no gate fixtures were scored");
+    let mean = gate_cers.iter().sum::<f64>() / gate_cers.len() as f64;
+    println!("=== mean gate CER = {mean:.4} (threshold 0.05) ===\n");
+    assert!(
+        mean <= 0.05,
+        "paddle-onnx mean CER {mean:.4} exceeds 0.05 gate"
+    );
+}
--- a/crates/kebab-search/src/lexical.rs
+++ b/crates/kebab-search/src/lexical.rs
@@ -123,29 +123,7 @@ impl Retriever for LexicalRetriever {
        };

        let conn = self.store.read_conn();
-        let body_rows = run_query(&conn, &match_str, self.snippet_words, filters, fetch_limit)?;
-        // doc-side expansion (V010): re-run the same query against the
-        // `aliases` column of `chunk_aliases_fts`. Empty table → 0 rows →
-        // `body_rows` unchanged (regression-safe). body wins; alias-only
-        // chunks are appended so a term present only in a chunk's aliases
-        // still enters the pool.
-        //
-        // Raw mode (`'...'`) is a body-FTS5 escape hatch and may reference
-        // body-only columns (e.g. `heading_path : ...`) that don't exist on
-        // `chunk_aliases_fts`. Running such an expression against the alias
-        // table is a hard FTS5 error, so we skip the alias channel for raw
-        // queries — they target the body intentionally.
-        let alias_rows = if strip_single_quotes(query.text.trim()).is_some() {
-            Vec::new()
-        } else {
-            match build_match_string_for_column(&query.text, "aliases") {
-                Some(alias_match) => {
-                    run_alias_query(&conn, &alias_match, self.snippet_chars, fetch_limit)?
-                }
-                None => Vec::new(),
-            }
-        };
-        let raw_rows = merge_body_alias(body_rows, alias_rows, fetch_limit);
+        let raw_rows = run_query(&conn, &match_str, self.snippet_words, filters, fetch_limit)?;

        let mut hits: Vec<SearchHit> = Vec::with_capacity(raw_rows.len().min(k));
        let mut rank: u32 = 0;
@@ -228,16 +206,6 @@ impl Retriever for LexicalRetriever {
 ///   match is scoped to the body column. FTS5's column-filter syntax
 ///   accepts an arbitrary OR/AND sub-expression inside the parens.
 fn build_match_string(text: &str) -> Option<String> {
-    build_match_string_for_column(text, "text")
-}
-
-/// Column-parameterized variant of [`build_match_string`]. `column` is the
-/// FTS5 column-filter prefix the combined expression is scoped to — `"text"`
-/// for the body channel (`chunks_fts`) or `"aliases"` for the doc-side
-/// expansion channel (`chunk_aliases_fts`, V010). Raw mode (`'...'`) is still
-/// passed through verbatim without any column scoping, so an explicit
-/// user-supplied column filter is honored unchanged.
-fn build_match_string_for_column(text: &str, column: &str) -> Option<String> {
    let trimmed = text.trim();
    if trimmed.is_empty() {
        return None;
@@ -274,7 +242,7 @@ fn build_match_string_for_column(text: &str, column: &str) -> Option<String> {
        (Some(w), Some(a)) if w == a => w,
        (Some(w), Some(a)) => format!("({w}) OR ({a})"),
    };
-    Some(format!("{column} : ({expression})"))
+    Some(format!("text : ({expression})"))
 }

 /// Return `Some(inner)` if `s` is wrapped in a matching pair of single
@@ -512,77 +480,6 @@ fn row_from_sql(row: &Row<'_>) -> rusqlite::Result<RawRow> {
    })
 }

-/// Search the doc-side expansion channel (`chunk_aliases_fts`, V010) and
-/// build [`RawRow`]s with the **same 10-column shape** as [`run_query`] so
-/// `row_from_sql` / `build_hit` can be reused verbatim. The snippet is taken
-/// from the body (`substr(c.text, 1, ?)`) rather than the alias text so the
-/// rendered hit stays consistent with the body channel. When
-/// `chunk_aliases_fts` is empty (no chunk carries aliases) this returns 0
-/// rows, making the merge a no-op (regression-safe).
-///
-/// 1차는 filters 미적용 — body 채널이 필터를 적용하고, 별칭 경로는 pool 진입
-/// (회수)이 목적이다(측정 후 필요 시 filters 공유). `bm25(chunk_aliases_fts)`
-/// 오름차순 + `af.chunk_id` tie-break 로 결정적 순서.
-fn run_alias_query(
-    conn: &Connection,
-    match_str: &str,
-    snippet_chars: usize,
-    fetch_limit: usize,
-) -> Result<Vec<RawRow>> {
-    let sql = "SELECT \
-            af.chunk_id, af.doc_id, \
-            bm25(chunk_aliases_fts) AS score, \
-            substr(c.text, 1, ?) AS snippet, \
-            c.heading_path_json, c.section_label, c.source_spans_json, \
-            c.chunker_version, \
-            d.workspace_path, d.updated_at \
-         FROM chunk_aliases_fts af \
-         JOIN chunks c    ON c.chunk_id = af.chunk_id \
-         JOIN documents d ON d.doc_id = af.doc_id \
-         WHERE chunk_aliases_fts MATCH ? \
-         ORDER BY score, af.chunk_id LIMIT ?";
-    let params: Vec<Box<dyn ToSql>> = vec![
-        Box::new(snippet_chars as i64),
-        Box::new(match_str.to_owned()),
-        Box::new(i64::try_from(fetch_limit).unwrap_or(i64::MAX)),
-    ];
-    let mut stmt = conn
-        .prepare(sql)
-        .context("kb-search lexical: prepare alias FTS5 statement")?;
-    let rows = stmt
-        .query_map(
-            params_from_iter(params.iter().map(std::convert::AsRef::as_ref)),
-            row_from_sql,
-        )
-        .context("kb-search lexical: execute alias FTS5 query")?;
-    let mut out: Vec<RawRow> = Vec::new();
-    for r in rows {
-        out.push(r.context("kb-search lexical: read alias row")?);
-    }
-    Ok(out)
-}
-
-/// Merge body + alias rows: body rows first (already bm25-ordered), then
-/// any alias-only chunk (not already present in the body result) appended in
-/// alias-relevance order. Capped at `limit`. An empty `alias` slice leaves
-/// `body` unchanged, so an empty `chunk_aliases_fts` reproduces the
-/// pre-expansion behavior exactly.
-fn merge_body_alias(body: Vec<RawRow>, alias: Vec<RawRow>, limit: usize) -> Vec<RawRow> {
-    use std::collections::HashSet;
-    let mut seen: HashSet<String> = body.iter().map(|r| r.chunk_id.clone()).collect();
-    let mut out = body;
-    for r in alias {
-        if out.len() >= limit {
-            break;
-        }
-        if seen.insert(r.chunk_id.clone()) {
-            out.push(r);
-        }
-    }
-    out.truncate(limit);
-    out
-}
-
 // ── Hit construction ─────────────────────────────────────────────────────

 fn build_hit(
--- a/crates/kebab-search/tests/lexical.rs
+++ b/crates/kebab-search/tests/lexical.rs
@@ -144,42 +144,6 @@ fn insert_chunk(
    .expect("insert chunk");
 }

-/// Like [`insert_chunk`] but also writes the `chunks.aliases` column so the
-/// `chunk_aliases_ai` trigger (V010) mirrors the row into `chunk_aliases_fts`.
-/// `aliases=None` leaves the column NULL (trigger skips → no alias row).
-#[allow(clippy::too_many_arguments)]
-fn insert_chunk_with_aliases(
-    conn: &Connection,
-    chunk_id: &str,
-    doc_id: &str,
-    text: &str,
-    heading_path: &[&str],
-    section_label: Option<&str>,
-    source_spans_json: &str,
-    chunker_version: &str,
-    aliases: Option<&str>,
-) {
-    let heading_json = serde_json::to_string(heading_path).unwrap();
-    conn.execute(
-        "INSERT INTO chunks (
-            chunk_id, doc_id, text, heading_path_json, section_label,
-            source_spans_json, token_estimate, chunker_version,
-            policy_hash, block_ids_json, created_at, aliases
-        ) VALUES (?, ?, ?, ?, ?, ?, 0, ?, 'h', '[]', '2024-01-01T00:00:00Z', ?)",
-        rusqlite::params![
-            chunk_id,
-            doc_id,
-            text,
-            heading_json,
-            section_label,
-            source_spans_json,
-            chunker_version,
-            aliases,
-        ],
-    )
-    .expect("insert chunk with aliases");
-}
-
 /// Pad a short ID to the 32-hex shape kebab_core newtypes expect.
 fn id32(prefix: &str) -> String {
    let mut s = prefix.to_string();
@@ -1290,51 +1254,14 @@ fn lexical_raw_mode_can_opt_into_heading_path_filter() {
    );
 }

-// ── doc-side expansion (V010) — body+alias merged search ──────────────────
+// ── body-only lexical recall (regression-safety) ──────────────────────────

-/// pool-rescue core: a term present ONLY in `chunks.aliases` (not in the
-/// body) must still recall the chunk via the `chunk_aliases_fts` channel.
-/// Body is English ("backpropagation…"); the Korean term "역전파" lives only
-/// in the alias text, so the body `chunks_fts` MATCH alone would miss it.
+/// Body `chunks_fts` recall works for a plain term in the chunk text.
+/// (Was previously the `empty_aliases_table_matches_baseline` regression
+/// guard; doc-side expansion was removed 2026-06-03 so the body channel is
+/// the only lexical channel.)
 #[test]
-fn alias_only_term_recalls_chunk() {
-    let env = Env::new();
-    let conn = env.raw_conn();
-    insert_document(&conn, &id32("d"), "notes/nn.md", "NN", "en", "primary", &[]);
-    insert_chunk_with_aliases(
-        &conn,
-        &id32("c1"),
-        &id32("d"),
-        "backpropagation computes gradients",
-        &["NN"],
-        None,
-        r#"[{"kind":"line","start":1,"end":1}]"#,
-        "v1",
-        Some("역전파\n신경망 오차 역전달"),
-    );
-    drop(conn);
-
-    let r = env.retriever();
-    let hits = r
-        .search(&SearchQuery {
-            text: "역전파".to_string(),
-            mode: SearchMode::Lexical,
-            k: 10,
-            filters: SearchFilters::default(),
-        })
-        .unwrap();
-    assert!(
-        hits.iter().any(|h| h.chunk_id.0 == id32("c1")),
-        "별칭에만 있는 term 으로도 청크가 회수돼야 한다 (pool-rescue); got {:?}",
-        hits.iter().map(|h| h.chunk_id.0.clone()).collect::<Vec<_>>()
-    );
-}
-
-/// Regression-safety: with every chunk's `aliases=NULL` the
-/// `chunk_aliases_fts` table is empty, so the alias channel yields 0 rows
-/// and the body search result is identical to the pre-expansion behavior.
-#[test]
-fn empty_aliases_table_matches_baseline() {
+fn body_term_recalls_chunk() {
    let env = Env::new();
    let conn = env.raw_conn();
    insert_document(
@@ -1346,7 +1273,6 @@ fn empty_aliases_table_matches_baseline() {
        "primary",
        &[],
    );
-    // aliases=None → no chunk_aliases_fts row; body channel only.
    insert_chunk(
        &conn,
        &id32("c1"),
@@ -1370,6 +1296,6 @@ fn empty_aliases_table_matches_baseline() {
        .unwrap();
    assert!(
        hits.iter().any(|h| h.chunk_id.0 == id32("c1")),
-        "aliases 빈 상태에서 본문 매칭 청크가 정상 회수돼야 한다 (회귀 안전)"
+        "본문 매칭 청크가 정상 회수돼야 한다 (회귀 안전)"
    );
 }
--- a/crates/kebab-store-sqlite/src/documents.rs
+++ b/crates/kebab-store-sqlite/src/documents.rs
@@ -123,8 +123,8 @@ impl kebab_core::DocumentStore for SqliteStore {
                    chunk_id, doc_id, text, heading_path_json,
                    section_label, source_spans_json, token_estimate,
                    chunker_version, policy_hash, block_ids_json, created_at,
-                    tokenized_korean_text, aliases
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                    tokenized_korean_text
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
            )
            .map_err(StoreError::from)?;
        for chunk in chunks {
@@ -153,7 +153,6 @@ impl kebab_core::DocumentStore for SqliteStore {
                block_ids,
                now,
                chunk.tokenized_korean_text.as_deref(),
-                chunk.aliases.as_deref(),
            ])
            .map_err(StoreError::from)?;
        }
@@ -268,7 +267,6 @@ impl kebab_core::DocumentStore for SqliteStore {
            chunker_version: kebab_core::ChunkerVersion(row.chunker_version),
            policy_hash: row.policy_hash,
            tokenized_korean_text: row.tokenized_korean_text,
-            aliases: None,
        }))
    }

--- a/crates/kebab-store-sqlite/tests/chunk_aliases.rs
+++ b/crates/kebab-store-sqlite/tests/chunk_aliases.rs
@@ -1,220 +0,0 @@
-//! V010 doc-side expansion: `put_chunks` 가 `chunk.aliases` 를 chunks.aliases
-//! 컬럼에 영속화하고, chunk_aliases_ai trigger 가 별도 `chunk_aliases_fts`
-//! 가상 테이블로 mirror 하는지 검증.
-//!
-//! `put_chunks` 는 store-owned conn(FK ON)에서 도므로 chunks 의
-//! `doc_id REFERENCES documents(doc_id)` FK 를 만족시키려면 asset +
-//! document 그래프가 먼저 있어야 한다. 헬퍼는 `idempotency.rs` 패턴 복제.
-//! 인덱싱 검증은 side-channel `env.with_conn` 으로 chunk_aliases_fts 를 직접
-//! MATCH 한다(같은 established 패턴).
-
-use std::path::PathBuf;
-
-use kebab_core::{
-    AssetId, AssetStorage, Block, CanonicalDocument, Checksum, Chunk, ChunkerVersion, CommonBlock,
-    DocumentId, DocumentStore, HeadingBlock, Lang, MediaType, Metadata, ParserVersion, Provenance,
-    SourceSpan, SourceType, SourceUri, TextBlock, TrustLevel, WorkspacePath,
-};
-use kebab_store_sqlite::SqliteStore;
-use time::OffsetDateTime;
-
-mod common;
-
-fn make_asset() -> kebab_core::RawAsset {
-    let bytes = b"dummy";
-    kebab_core::RawAsset {
-        asset_id: AssetId("a".repeat(32)),
-        source_uri: SourceUri::File(PathBuf::from("/tmp/foo.md")),
-        workspace_path: WorkspacePath::new("notes/foo.md".into()).unwrap(),
-        media_type: MediaType::Markdown,
-        byte_len: bytes.len() as u64,
-        checksum: Checksum(blake3::hash(bytes).to_hex().to_string()),
-        discovered_at: OffsetDateTime::from_unix_timestamp(1_700_000_000).unwrap(),
-        stored: AssetStorage::Reference {
-            path: PathBuf::from("/tmp/foo.md"),
-            sha: Checksum(blake3::hash(bytes).to_hex().to_string()),
-        },
-    }
-}
-
-fn make_metadata() -> Metadata {
-    Metadata {
-        aliases: vec![],
-        tags: vec![],
-        created_at: OffsetDateTime::from_unix_timestamp(1_700_000_000).unwrap(),
-        updated_at: OffsetDateTime::from_unix_timestamp(1_700_000_000).unwrap(),
-        source_type: SourceType::Markdown,
-        trust_level: TrustLevel::Primary,
-        user_id_alias: None,
-        user: Default::default(),
-        repo: None,
-        git_branch: None,
-        git_commit: None,
-        code_lang: None,
-    }
-}
-
-fn make_doc() -> CanonicalDocument {
-    let doc_id = DocumentId("d".repeat(32));
-    let span = SourceSpan::Line { start: 1, end: 1 };
-    let block = Block::Heading(HeadingBlock {
-        common: CommonBlock {
-            block_id: kebab_core::BlockId("b".repeat(32)),
-            heading_path: vec![],
-            source_span: span.clone(),
-        },
-        level: 1,
-        text: "Title".into(),
-    });
-    let para = Block::Paragraph(TextBlock {
-        common: CommonBlock {
-            block_id: kebab_core::BlockId("c".repeat(32)),
-            heading_path: vec!["Title".into()],
-            source_span: span,
-        },
-        text: "body".into(),
-        inlines: vec![],
-    });
-    CanonicalDocument {
-        doc_id,
-        source_asset_id: AssetId("a".repeat(32)),
-        workspace_path: WorkspacePath::new("notes/foo.md".into()).unwrap(),
-        title: "Title".into(),
-        lang: Lang("en".into()),
-        blocks: vec![block, para],
-        metadata: make_metadata(),
-        provenance: Provenance { events: vec![] },
-        parser_version: ParserVersion("test-parser".into()),
-        schema_version: 1,
-        doc_version: 1,
-        last_chunker_version: None,
-        last_embedding_version: None,
-    }
-}
-
-/// 단일 청크 생성. `aliases` 만 호출측이 지정.
-fn base_chunk(chunk_id: &str, doc_id: &DocumentId, aliases: Option<String>) -> Chunk {
-    Chunk {
-        chunk_id: kebab_core::ChunkId(chunk_id.into()),
-        doc_id: doc_id.clone(),
-        block_ids: vec![kebab_core::BlockId("b".repeat(32))],
-        text: "Rust ownership and borrowing".into(),
-        heading_path: vec!["Title".into()],
-        source_spans: vec![SourceSpan::Line { start: 1, end: 1 }],
-        token_estimate: 5,
-        chunker_version: ChunkerVersion("md-heading-v1".into()),
-        policy_hash: "h".into(),
-        tokenized_korean_text: None,
-        aliases,
-    }
-}
-
-/// asset + document 그래프를 깔고 마이그레이션된 store 를 돌려준다.
-fn open_store_with_document(env: &common::TestEnv) -> SqliteStore {
-    let store = SqliteStore::open(&env.config()).unwrap();
-    store.run_migrations().unwrap();
-    store.put_asset(&make_asset()).expect("put_asset");
-    store.put_document(&make_doc()).expect("put_document");
-    store
-}
-
-#[test]
-fn aliases_indexed_into_chunk_aliases_fts() {
-    let env = common::TestEnv::new();
-    let store = open_store_with_document(&env);
-    let doc = DocumentId("d".repeat(32));
-    let chunk = base_chunk(
-        &"e".repeat(32),
-        &doc,
-        Some("메모리 안전성\nwho owns the value".into()),
-    );
-    store.put_chunks(&doc, &[chunk]).unwrap();
-
-    // 별칭에만 있는 한국어 term 으로 chunk_aliases_fts 검색 → 청크 회수.
-    let n: i64 = env.with_conn(|c| {
-        c.query_row(
-            "SELECT count(*) FROM chunk_aliases_fts \
-             WHERE chunk_aliases_fts MATCH 'aliases : (\"메모리\")'",
-            [],
-            |r| r.get(0),
-        )
-    });
-    assert_eq!(
-        n, 1,
-        "aliases 의 한국어 term 이 chunk_aliases_fts 에 색인돼야 한다"
-    );
-}
-
-#[test]
-fn none_aliases_not_indexed() {
-    let env = common::TestEnv::new();
-    let store = open_store_with_document(&env);
-    let doc = DocumentId("d".repeat(32));
-    let chunk = base_chunk(&"e".repeat(32), &doc, None);
-    store.put_chunks(&doc, &[chunk]).unwrap();
-
-    let n: i64 = env.with_conn(|c| {
-        c.query_row("SELECT count(*) FROM chunk_aliases_fts", [], |r| r.get(0))
-    });
-    assert_eq!(
-        n, 0,
-        "aliases=None 이면 chunk_aliases_fts 에 행이 없어야 한다"
-    );
-}
-
-/// Task 2 리뷰 M2: 같은 doc 을 두 번 `put_chunks` 해도 `chunk_aliases_fts`
-/// 행이 중복되지 않아야 한다. put_chunks 의 DELETE-then-INSERT 가
-/// chunk_aliases_ad → chunk_aliases_ai 를 발화해 멱등 재동기화하는지 검증.
-#[test]
-fn reput_keeps_single_alias_row() {
-    let env = common::TestEnv::new();
-    let store = open_store_with_document(&env);
-    let doc = DocumentId("d".repeat(32));
-    let mk = || base_chunk(&"e".repeat(32), &doc, Some("메모리 안전성".into()));
-
-    store.put_chunks(&doc, &[mk()]).unwrap();
-    store.put_chunks(&doc, &[mk()]).unwrap(); // 같은 doc 재-put
-
-    let n: i64 = env.with_conn(|c| {
-        c.query_row("SELECT count(*) FROM chunk_aliases_fts", [], |r| r.get(0))
-    });
-    assert_eq!(n, 1, "재색인 후에도 별칭 행은 1개여야 한다 (중복/누락 없음)");
-}
-
-/// Task 2 리뷰 N1: 별칭 term 이 본문 `chunks_fts` 로 새지 않아야 한다(§3.3 격리).
-/// 본문엔 없고 별칭에만 있는 한국어 term 으로 chunks_fts 를 MATCH 하면 0행.
-#[test]
-fn aliases_dont_leak_into_body_fts() {
-    let env = common::TestEnv::new();
-    let store = open_store_with_document(&env);
-    let doc = DocumentId("d".repeat(32));
-    // 본문 "Rust ownership and borrowing" 에 "메모리" 없음, 별칭에만 있음.
-    let chunk = base_chunk(&"e".repeat(32), &doc, Some("메모리 안전성".into()));
-    store.put_chunks(&doc, &[chunk]).unwrap();
-
-    let body_hits: i64 = env.with_conn(|c| {
-        c.query_row(
-            "SELECT count(*) FROM chunks_fts WHERE chunks_fts MATCH 'text : (\"메모리\")'",
-            [],
-            |r| r.get(0),
-        )
-    });
-    assert_eq!(body_hits, 0, "별칭 term 이 본문 chunks_fts 로 누출되면 안 된다");
-}
-
-/// Task 2 리뷰 M1: 빈 문자열 별칭은 색인하지 않는다(trigger 가드
-/// `AND new.aliases <> ''`). producer 가 Some("") 를 넘겨도 무용한 행이
-/// chunk_aliases_fts 에 쌓이지 않아야 한다.
-#[test]
-fn empty_string_alias_not_indexed() {
-    let env = common::TestEnv::new();
-    let store = open_store_with_document(&env);
-    let doc = DocumentId("d".repeat(32));
-    let chunk = base_chunk(&"e".repeat(32), &doc, Some(String::new()));
-    store.put_chunks(&doc, &[chunk]).unwrap();
-
-    let n: i64 = env.with_conn(|c| {
-        c.query_row("SELECT count(*) FROM chunk_aliases_fts", [], |r| r.get(0))
-    });
-    assert_eq!(n, 0, "빈 문자열 별칭은 chunk_aliases_fts 에 색인되면 안 된다");
-}
--- a/crates/kebab-store-sqlite/tests/corpus_revision.rs
+++ b/crates/kebab-store-sqlite/tests/corpus_revision.rs
@@ -23,6 +23,8 @@ fn open_store(tmp: &TempDir) -> SqliteStore {
 /// Fresh store baseline: V004 seeds `corpus_revision = 0`, then V009,
 /// V010, and V011 migrations bump it by one each to invalidate any stale
 /// LRU cache — so a fresh store after `run_migrations()` reads back as `3`.
+/// (V012 derivation_cache + V013 drop-chunk-aliases are structural/additive
+/// and do NOT bump corpus_revision.)
 #[test]
 fn fresh_store_starts_at_post_migration_baseline() {
    let tmp = TempDir::new().unwrap();
--- a/crates/kebab-store-sqlite/tests/embedding_records_fk.rs
+++ b/crates/kebab-store-sqlite/tests/embedding_records_fk.rs
@@ -160,7 +160,6 @@ fn put_chunks_cleans_original_and_sentinel_embeddings() {
        chunker_version: ChunkerVersion("v1".to_string()),
        policy_hash: "h".to_string(),
        tokenized_korean_text: None,
-        aliases: None,
    };
    store.put_chunks(&doc_id, std::slice::from_ref(&chunk)).unwrap();

@@ -270,7 +269,6 @@ fn put_chunks_cleans_per_alias_sentinel_embeddings() {
        chunker_version: ChunkerVersion("v1".to_string()),
        policy_hash: "h".to_string(),
        tokenized_korean_text: None,
-        aliases: None,
    };
    store.put_chunks(&doc_id, std::slice::from_ref(&chunk)).unwrap();

--- a/crates/kebab-store-sqlite/tests/idempotency.rs
+++ b/crates/kebab-store-sqlite/tests/idempotency.rs
@@ -98,7 +98,6 @@ fn make_chunks(doc_id: &DocumentId) -> Vec<Chunk> {
        chunker_version: ChunkerVersion("md-heading-v1".into()),
        policy_hash: "deadbeefdeadbeef".into(),
        tokenized_korean_text: None,
-        aliases: None,
    }]
 }

--- a/crates/kebab-tui/src/ingest_progress.rs
+++ b/crates/kebab-tui/src/ingest_progress.rs
@@ -154,7 +154,17 @@ fn apply_event(state: &mut IngestState, event: IngestEvent) {
        }
        // v0.20.0 sub-item 1: per-page PDF OCR events — TUI does not
        // surface per-page OCR progress in v1; no counter to update.
-        IngestEvent::PdfOcrStarted { .. } | IngestEvent::PdfOcrFinished { .. } => {}
+        IngestEvent::PdfOcrStarted { .. }
+        | IngestEvent::PdfOcrFinished { .. }
+        // v0.24.0 asset-internal phase events: the status-bar reducer tracks
+        // per-asset counters, not sub-asset phase progress, so these are
+        // no-ops here (the CLI / --json surfaces render them).
+        | IngestEvent::AssetChunked { .. }
+        | IngestEvent::AssetTimings { .. }
+        // v0.26.1 slow-phase hint (ocr / caption / embed): the CLI bar uses
+        // it for a live phase message; the TUI status-bar reducer tracks only
+        // per-asset counters, so it's a no-op here.
+        | IngestEvent::AssetPhase { .. } => {}
    }
 }

--- a/crates/kebab-tui/tests/inspect.rs
+++ b/crates/kebab-tui/tests/inspect.rs
@@ -114,7 +114,6 @@ fn make_chunk() -> Chunk {
        chunker_version: ChunkerVersion("md-heading-v1".into()),
        policy_hash: "deadbeefdeadbeef".into(),
        tokenized_korean_text: None,
-        aliases: None,
    }
 }

--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -16,11 +16,11 @@ Cargo workspace, 함수 호출 기반 모듈러 모놀리스. UI binary (`kebab-
 | metadata | SQLite + FTS5 (lexical search + v0.20.1 한국어 형태소 tokenizer via lindera-ko-dic) |
 | vector | LanceDB (embedded, model 별 분리 table) |
 | Markdown parser | `pulldown-cmark`. frontmatter 에 title 없으면 첫 H1 → H2 → 첫 paragraph 80 자 → 파일명 순으로 자동 채움 (`parser_version = md-frontmatter-v2`, 기존 doc 도 다음 ingest 에서 갱신) |
-| embedding | `fastembed-rs` (`multilingual-e5-large`, 1024d, v0.18.0부터 default 업그레이드) |
+| embedding | `fastembed-rs` (`multilingual-e5-large`, 1024d, v0.18.0부터 default 업그레이드). opt-in 대안: candle (e5 또는 `snowflake-arctic-embed-l-v2.0`) / Ollama `/api/embed`. arctic = 설명형 query recall 보강 (v0.26.0, 아래 결정표) |
 | 한국어 형태소분석 | `lindera-ko-dic` (FTS5 외부 tokenizer, v0.20.1) — 2자 이상 한국어 query 지원 |
 | LLM | Ollama HTTP (default `gemma4:e4b` ─ OCR / caption 와 family 통일. 사용자가 더 큰 variant `gemma4:26b` 등으로 override 가능) |
 | 음성 ASR | `whisper.cpp` (via `whisper-rs`) — P8 보류, 시스템 dep brainstorm 후 |
-| OCR (image) | Ollama vision LM (default `gemma4:e4b`) — `OcrEngine` trait 으로 Tesseract / Apple Vision 등 future swap (HOTFIXES P6-2) |
+| OCR (image) | `OcrEngine` trait, 2 백엔드: **`ollama-vision`** (default, `gemma4:e4b`) / **`paddle-onnx`** (v0.27.0 — PP-OCRv5 ONNX in-process via `ort` =2.0.0-rc.9, DBNet det + CTC rec, 후처리 min-area rect/unclip pure-Rust, Python 런타임 0). engine 선택은 `[image.ocr] engine`, 팩토리는 `kebab-app::build_image_ocr_engine`. e2e CER 0.005 / 큰 페이지 <4초. (HOTFIXES P6-2, 2026-06-04) |
 | OCR (PDF, v0.20.0+) | Ollama vision LM (default `qwen2.5vl:3b`) — post-extract enrichment via `kebab-app::pdf_ocr_apply` (H-1 resolution). DCTDecode-only v1 (FlateDecode/CCITTFax skip + warning). family asymmetry vs image OCR: PoC alnum 94.79% (qwen2.5vl) >> 27% (gemma4:e4b 받침), 본 단계에서 PDF OCR 만 qwen2.5vl. |
 | Image caption | Ollama vision LM, runtime gate `image.caption.enabled` (default OFF) |
 | RAG groundedness 검증 | `kebab-nli` 의 mDeBERTa-v3 XNLI 가 `(packed_chunks, generated_answer)` entailment 검사 (fb-41). `[rag] nli_threshold > 0` (default 0 = disabled, production 권장 0.5) 일 때 활성 — 미달 시 `refusal_reason = nli_verification_failed` (LLM self-judge ceiling 보완). 첫 호출 시 ~280 MB ONNX 자동 다운로드 |
@@ -32,8 +32,8 @@ Cargo workspace, 함수 호출 기반 모듈러 모놀리스. UI binary (`kebab-
 | citation 형식 | URI fragment (`path#L12-L34` / `path#p=12` / `path#xywh=0,0,100,50`, W3C Media Fragments) |
 | ID 생성 | `blake3(canonical_json(tuple))[..32]` hex |
 | RRF fusion_score | `[0, 1]` 정규화 — `2 / (k_rrf + 1)` 로 나눠 mode 간 비교 가능 (post-merge hotfix) |
-| doc-side expansion 별칭 (v0.21.0) | 색인 시 LLM 이 청크별 "같은 의미 다른 표현" 별칭 생성. 별칭은 줄별 **개별 dense 벡터**(sentinel `{chunk}#alias#N`)로 색인하고 본문 벡터는 그대로 둠 (묶음 1벡터는 평균화로 희석 → 회귀, HOTFIXES 2026-05-31). boilerplate 청크는 별칭 skip. 검색 시 별칭 hit 는 `kebab-core::strip_alias_suffix` 로 원본 chunk_id 에 매핑. `[ingest.expansion]` default off (opt-in, 청크당 LLM 비용). |
-| 파생물 캐시 `derivation_cache` (V012, v0.21.0) | 비싼 ingest 파생물(embedding 벡터 / 별칭 LLM 결과)을 청크 **내용 해시** 키로 SQLite 에 캐싱 → 재색인 시 내용 불변 청크는 재계산 skip. `cache_key = blake3(kind ‖ text_blake3 ‖ version_key)[:32]`; version_key 에 model/prompt/dimensions 포함 → §9 cascade 와 정합(버전 bump 시 자동 miss). 위치 기반 `chunk_id` 와 달리 내용이 같으면 문서·위치 무관 동일 키. 순수 가산 — `corpus_revision` bump 안 함, 손상/삭제돼도 정확성 영향 0(miss → 재계산). search/ask 는 `kebab.sqlite`+`lancedb` 만으로 동작하므로 외부 서버 색인 후 DB 만 복사하는 이식 워크플로 가능 (HOTFIXES 2026-05-31). |
+| ~~doc-side expansion 별칭 (v0.21.0)~~ | **제거됨 (v0.25.0, HOTFIXES 2026-06-03)** — 색인-시 청크당 LLM 별칭 생성 + 별칭 검색 채널을 완전히 제거. 별칭 ROI 음수(cross-lingual 은 e5-large 단독으로 충분, 기여는 설명형 +2 그룹뿐인데 대가가 청크당 색인-시 LLM). V013 마이그레이션이 `chunk_aliases_fts` + `chunks.aliases` DROP. 기존 KB 의 잔존 별칭 벡터는 검색 시 `strip_alias_suffix` 로 본문 chunk 에 매핑(graceful)되거나 `kebab reset` 으로 정리. spec: `docs/superpowers/specs/2026-06-03-remove-doc-expansion-spec.md`. |
+| 파생물 캐시 `derivation_cache` (V012, v0.21.0) | 비싼 ingest 파생물(embedding 벡터)을 청크 **내용 해시** 키로 SQLite 에 캐싱 → 재색인 시 내용 불변 청크는 재계산 skip. `cache_key = blake3(kind ‖ text_blake3 ‖ version_key)[:32]`; version_key 에 model/dimensions 포함 → §9 cascade 와 정합(버전 bump 시 자동 miss). 위치 기반 `chunk_id` 와 달리 내용이 같으면 문서·위치 무관 동일 키. 순수 가산 — `corpus_revision` bump 안 함, 손상/삭제돼도 정확성 영향 0(miss → 재계산). search/ask 는 `kebab.sqlite`+`lancedb` 만으로 동작하므로 외부 서버 색인 후 DB 만 복사하는 이식 워크플로 가능 (HOTFIXES 2026-05-31). (별칭 LLM 캐싱 kind 는 v0.25.0 에서 제거 — embedding kind 만 남음.) |
 | layout | XDG (`~/.local/share/kebab/`, `~/.config/kebab/`, …) |

 전체 frozen 설계는 [docs/superpowers/specs/2026-04-27-kebab-final-form-design.md](superpowers/specs/2026-04-27-kebab-final-form-design.md) 12 sections 참조.
@@ -67,7 +67,8 @@ flowchart TB
    subgraph Adapters ["traits + adapters"]
        embed["kebab-embed<br/>(trait)"]
        embedlocal["kebab-embed-local<br/>(fastembed, default)"]
-        embedcandle["kebab-embed-candle<br/>(candle, NUMA-safe opt-in)"]
+        embedcandle["kebab-embed-candle<br/>(candle, e5+arctic, NUMA-safe opt-in)"]
+        embedollama["kebab-embed-ollama<br/>(Ollama /api/embed, opt-in)"]
        llm["kebab-llm<br/>(trait)"]
        llmlocal["kebab-llm-local<br/>(Ollama)"]
        search["kebab-search"]
@@ -94,6 +95,7 @@ flowchart TB
    app --> vector
    app --> embedlocal
    app --> embedcandle
+    app --> embedollama
    app --> llmlocal
    app --> search
    app --> rag
@@ -108,6 +110,8 @@ flowchart TB
    embedlocal --> embed
    embedcandle --> core
    embedcandle --> config
+    embedollama --> core
+    embedollama --> config
    llmlocal --> llm
    rag --> search
    rag --> llm
@@ -136,6 +140,23 @@ UI → store/llm/parse 직접 의존 금지. 모든 user-facing 진입은 `kebab

 `kebab-parse-code` 의 외부 tree-sitter grammar crate 의존: P10-1A-2 에서 `tree-sitter-rust` 추가, P10-1B 에서 `tree-sitter-python` / `tree-sitter-typescript` / `tree-sitter-javascript` 추가, P10-1C-Go 에서 `tree-sitter-go` 추가, P10-1C-JK 에서 `tree-sitter-java` / `tree-sitter-kotlin-ng` 추가, P10-1D 에서 `tree-sitter-c` / `tree-sitter-cpp` 추가. 모두 `kebab-parse-code` 에만 격리 (facade 룰 — UI crate / chunker 가 직접 import 금지). Kotlin 은 `tree-sitter-kotlin-ng` 사용 (bare `tree-sitter-kotlin` 은 tree-sitter 0.21–0.23 에 고착 — 사용 불가). v0.18.0+ 부터 `kebab-source-fs` 는 자체 `code_meta` 모듈 (lang detect + skip helpers + BUILTIN_BLACKLIST) 을 보유, kebab-parse-code 와 분리 (refactor 2026-05-26). v0.19.0 부터 `kebab-parse-md` 가 `kebab-parse-types` (parser intermediate types) + `kebab-normalize` (CanonicalDocument lift) 두 crate 를 흡수 — 24 → 22 crates, design §3.7b 재작성 (HOTFIXES 2026-05-26). v0.20.1 부터 `kebab-search` 가 `lindera-ko-dic` 를 의존해 한국어 FTS5 형태소 tokenizer 지원 — V009 migration 으로 2자 이상 한국어 query 매칭 (Bug #8 closure).

+### 임베딩 백엔드 결정표 (v0.26.0)
+
+| provider | 모델 | pooling / prefix | 위치 | 언제 |
+|---|---|---|---|---|
+| `fastembed` (기본) | `multilingual-e5-large` | mean / `query:`·`passage:` | in-process (onnxruntime) | 기본. 단일 소켓 호스트 |
+| `candle` | e5 또는 `snowflake-arctic-embed-l-v2.0` | 모델별 (e5=mean, arctic=CLS) / arctic=`query:`·무접두어 | in-process (pure Rust) | NUMA 서버 (onnxruntime 48-스레드 double-free 회피), Apple Silicon Metal GPU |
+| `ollama` | `snowflake-arctic-embed2` 등 | 모델 태그로 추론 / arctic=`query:`·무접두어 | 원격 HTTP (`/api/embed`) | candle 폴백, 측정에 쓴 경로 그대로 재현 |
+
+**arctic-embed-l-v2.0 채택 근거**: 별칭(doc-side expansion) 제거(v0.25.0) 후 설명형
+query 의 recall 보강책. 측정(`/build/dogfood/logs/2026-06-03-method-measurements.md`)에서
+arctic = recall@10 130/132 (e5 대비 +7, 색인 1회·per-query 0·LLM 0, 용어 무손실).
+candle 이 주 백엔드(in-process, NUMA 안전), Ollama 가 폴백(측정 경로 재현). 두 경로의
+pooling/prefix 정확성은 `kebab-embed-candle/tests/arctic_ollama_parity.rs`
+(candle arctic vs Ollama arctic 코사인>0.99, `#[ignore]`) 로 고정. e5 → arctic 전환은
+`embedding_version` cascade (모델별 벡터 상이) → 재색인 필요. 기본값 e5 유지라 기존
+사용자 무영향. 자세한 내용: [tasks/HOTFIXES.md](../tasks/HOTFIXES.md) 2026-06-03 arctic entry.
+
 ## 디렉토리 구조

 ```text
@@ -184,16 +205,17 @@ kebab/
 │   ├── kebab-store-sqlite/                            # SQLite + FTS5 (V001/V002/V003) (P1-6, P2-1, P3-3). src/derivation_cache.rs = derivation_cache 테이블 저장소 (V012, v0.21.0)
 │   ├── kebab-search/                                  # Lexical + Vector + Hybrid retriever (P2-2, P3-4)
 │   ├── kebab-embed/  kebab-embed-local/                  # Embedder trait + fastembed adapter (P3-1, P3-2)
-│   ├── kebab-embed-candle/                             # candle (pure-Rust) Embedder, NUMA-safe opt-in provider=candle (Track 1, v0.22.0)
+│   ├── kebab-embed-candle/                             # candle (pure-Rust) Embedder, 모델 레지스트리(e5 mean + arctic CLS), NUMA-safe opt-in provider=candle (Track 1, v0.22.0; arctic v0.26.0)
+│   ├── kebab-embed-ollama/                             # Ollama /api/embed Embedder, opt-in provider=ollama (arctic 폴백 경로, v0.26.0)
 │   ├── kebab-store-vector/                            # LanceDB VectorStore (P3-3, P7-3 follow-up)
 │   ├── kebab-llm/  kebab-llm-local/                      # LanguageModel trait + Ollama adapter (P4-1, P4-2)
 │   ├── kebab-rag/                                     # RAG pipeline (P4-3)
 │   ├── kebab-nli/                                     # NLI verifier (mDeBERTa-v3 XNLI, fb-41 PR-9a/9b/9c-1)
 │   ├── kebab-eval/                                    # golden query runner + metrics (P5-1, P5-2)
-│   ├── kebab-parse-image/                             # ImageExtractor + Ollama OCR + caption (P6)
+│   ├── kebab-parse-image/                             # ImageExtractor + OCR (ollama-vision + paddle-onnx ONNX) + caption (P6)
 │   ├── kebab-parse-pdf/                               # lopdf per-page text extractor (P7-1)
 │   ├── kebab-parse-code/                              # tree-sitter AST extractors: Rust (P10-1A-2), Python + TypeScript + JavaScript (P10-1B), Go (P10-1C-Go), Java + Kotlin (P10-1C-JK — java.rs + kotlin.rs), C + C++ (P10-1D — c.rs + cpp.rs); chunker lives in kebab-chunk
-│   ├── kebab-app/                                     # facade (P0 시그니처 + P3-5/P6-4/P7-3 본체). src/expansion.rs = 별칭 생성, src/derivation_payload.rs = 캐시 payload 인코딩 (v0.21.0)
+│   ├── kebab-app/                                     # facade (P0 시그니처 + P3-5/P6-4/P7-3 본체). src/derivation_payload.rs = 캐시 payload 인코딩 (v0.21.0)
 │   ├── kebab-tui/                                     # Ratatui shell + Library 패널 (P9-1)
 │   ├── kebab-mcp/                                     # stdio MCP server — tools: schema, doctor, search, ask (P9-FB-30)
 │   └── kebab-cli/                                     # binary (P0 → 핫픽스로 --config flag wiring 강화)
--- a/docs/DOGFOOD.md
+++ b/docs/DOGFOOD.md
@@ -695,7 +695,7 @@ printf 'schema_version = 1\n\n[workspace]\nroot = "~/MyNotes"\ninclude = ["*.md"
 "$RELEASE_BIN" --config "$DOGFOOD/old.toml" doctor | grep config_migration  # ok 확인
 ```

-기대: dry-run 파일 미수정 → apply 시 `old.toml.bak`(원본 byte-identical) + `[ingest.expansion]`·`[logging]`·`[pdf.ocr]` 가시화 + 손본 `default_k`/주석 보존 + `workspace.include` 제거 → 재실행 멱등 → doctor `config_migration` ok. v0.21.1 evidence 는 `tasks/HOTFIXES.md` 2026-05-31.
+기대: dry-run 파일 미수정 → apply 시 `old.toml.bak`(원본 byte-identical) + `[ingest.code]`·`[logging]`·`[pdf.ocr]` 가시화 + 손본 `default_k`/주석 보존 + `workspace.include` 제거 → 재실행 멱등 → doctor `config_migration` ok. v0.21.1 evidence 는 `tasks/HOTFIXES.md` 2026-05-31.

 ## §10 Eval (P5)

--- a/docs/SMOKE.md
+++ b/docs/SMOKE.md
@@ -107,16 +107,18 @@ respect_markdown_headings = true
 chunker_version = "md-heading-v1"

 [models.embedding]
-provider = "fastembed"               # "fastembed"(기본) / "candle"(순수 Rust, NUMA-안전)
-                                     # / "none"(lexical-only — Ollama 불필요)
-                                     # ⚠ provider="candle" 사용 시 아래 model/dimensions 도
-                                     #   multilingual-e5-large / 1024 로 바꿔야 함
-                                     #   (candle 은 현재 e5-large 만 지원).
-model = "multilingual-e5-small"
+provider = "fastembed"               # "fastembed"(기본, onnxruntime) / "candle"(순수 Rust, NUMA-안전)
+                                     # / "ollama"(원격 HTTP /api/embed) / "none"(lexical-only — Ollama 불필요)
+                                     # ⚠ provider/model 변경 시 아래 dimensions 도 맞춰야 함.
+model = "multilingual-e5-small"      # candle/ollama 는 "snowflake-arctic-embed-l-v2.0"
+                                     # (ollama 태그 "snowflake-arctic-embed2", 1024-dim) 도 지원 —
+                                     # 설명형 query recall 보강. e5↔arctic 전환은
+                                     # embedding_version cascade (재색인 필요).
 version = "v1"
-dimensions = 384
+dimensions = 384                     # arctic / e5-large 는 1024.
 batch_size = 64
 num_threads = 0                      # candle 전용 CPU 스레드 캡 (0=auto). env KEBAB_EMBED_THREADS 우선.
+# endpoint = "http://127.0.0.1:11434"  # provider="ollama" 전용; 생략 시 [models.llm].endpoint fallback.

 [models.llm]
 provider = "ollama"
@@ -356,6 +358,24 @@ lang_hint = "kor"

 이미지 자산 한 장당 OCR 1 호출 + Caption 1 호출 → ~3-6초 (`gemma4:e4b` 기준). 다이어그램 / 카메라 사진 / 스크린샷 위주 워크스페이스에 권장. 책 / 스캔본은 P7 PDF 라인으로.

+**v0.27.0 — paddle-onnx 엔진 (오프라인, Ollama 불필요).** `[image.ocr] engine = "paddle-onnx"` 로 바꾸면 PP-OCRv5 ONNX 를 in-process 로 실행한다 (원격 vision LM 불필요, 큰 페이지 CPU <4초). embedding 까지 끄려면 `[models.embedding] provider = "none"` (lexical-only) 로 두면 Ollama 없이 OCR→FTS5 검색 전체 경로를 스모크할 수 있다:
+
+```toml
+[models.embedding]
+provider = "none"            # lexical-only — Ollama 불필요
+
+[image.ocr]
+enabled = true
+engine = "paddle-onnx"       # PP-OCRv5 ONNX in-process (Python/원격 0)
+model = "ppocrv5-mobile-kor"
+languages = ["kor", "eng"]
+max_pixels = 1600
+# det_model / rec_model / dict 로 번들 모델 경로 override 가능 (생략 시 번들 사용)
+# score_thresh = 0.3 / unclip_ratio = 1.5 / max_boxes = 1000 으로 검출 튜닝
+```
+
+스모크: `kebab ingest --config <cfg>` 후 `kebab search --config <cfg> --mode lexical "<이미지 안 한국어 단어>"` 가 그 image chunk 를 반환하면 OCR→FTS5 wiring 정상. engine 또는 모델을 바꾸면 다음 ingest 가 영향 이미지를 자동 재색인한다.
+
 ## P7-3 PDF ingestion

 `config.toml` 의 `[workspace] include` 에 `**/*.pdf` 를 추가하면 `kebab ingest` 가 텍스트 PDF 자산도 색인합니다. 외부 service 의존 없음 — `kebab-parse-pdf` 가 lopdf 로 페이지 단위 텍스트 추출, `kebab-chunk::PdfPageV1Chunker` 가 페이지 경계를 절대 넘지 않는 chunk 생성.
@@ -707,7 +727,7 @@ kebab --config /tmp/kebab-smoke/old.toml config migrate             # 멱등: "c
 kebab --config /tmp/kebab-smoke/old.toml --json config migrate --dry-run | jq .schema_version
 ```

-기대: dry-run 은 추가될 섹션(`[ingest.expansion]`·`[logging]` 등)과 제거될 `workspace.include` 를 출력하고 **파일을 수정하지 않는다**. 적용 시 `old.toml.bak`(원본과 동일)이 생기고 빠진 섹션이 주석과 함께 추가되며 사용자가 손본 값·주석은 보존된다. 재실행은 멱등(`config 이미 최신입니다`), `--json` 은 `config_migration.v1`.
+기대: dry-run 은 추가될 섹션(`[ingest.code]`·`[logging]` 등)과 제거될 `workspace.include` 를 출력하고 **파일을 수정하지 않는다**. 적용 시 `old.toml.bak`(원본과 동일)이 생기고 빠진 섹션이 주석과 함께 추가되며 사용자가 손본 값·주석은 보존된다. 재실행은 멱등(`config 이미 최신입니다`), `--json` 은 `config_migration.v1`.

 ## 정리

--- a/docs/superpowers/plans/2026-06-03-arctic-embedder-plan.md
+++ b/docs/superpowers/plans/2026-06-03-arctic-embedder-plan.md
@@ -0,0 +1,33 @@
+# Plan: arctic-embed-l-v2.0 임베더 통합 구현
+
+spec: `docs/superpowers/specs/2026-06-03-arctic-embedder-spec.md`. 브랜치 `feat/arctic-embedder`. 빌드 `CARGO_TARGET_DIR=/build/out/cargo-target`, `-j 4`(전체 test `-j 1`). cli 통합테스트용 `target` 심링크 필요 후 정리.
+
+## Task 1 — kebab-embed-candle 모델 레지스트리
+- e5 하드코딩(`HF_MODEL`/`SUPPORTED_MODEL`/mean pool/`query:`+`passage:`) → 레지스트리 구조체 `EmbedModelSpec { name, hf_repo, pooling: Pooling, query_prefix, doc_prefix, dim }`.
+- 등록: e5(`intfloat/multilingual-e5-large`, Mean, `query: `/`passage: `, 1024) + arctic(`Snowflake/snowflake-arctic-embed-l-v2.0`, Cls, `query: `/``, 1024). **arctic pooling 은 모델 `1_Pooling/config.json` 로 확인 후 확정(CLS 추정).**
+- `embed_batch` pooling 분기: Mean=기존 attention-mask-weighted, Cls=hidden_state[:,0,:]. tokenize/forward/L2 공유.
+- `CandleEmbedder::new` 가 config model 로 spec 조회, 없으면 에러. `model_id`/`model_version` 에 모델명 반영.
+- 단위테스트: 레지스트리 조회, prefix 적용, (가능하면) CLS vs mean pooling shape.
+
+## Task 2 — kebab-embed-ollama 신규 크레이트
+- `Cargo.toml`(workspace member), `Embedder` 구현. `reqwest::blocking` POST `/api/embed`.
+- 배치(48) + fail-soft 재시도(3). query/doc prefix 모델별. L2 normalize. dim 검증(config 와 일치).
+- endpoint = config.models.embedding.endpoint ?? models.llm.endpoint. model_version=`ollama:{model}`.
+- 단위테스트: wiremock 으로 /api/embed mock → dim·정규화·prefix 검증.
+
+## Task 3 — config + app 배선
+- `kebab-config`: `EmbeddingCfg.provider` 문서/검증에 `ollama` 추가, `endpoint: Option<String>` 필드(serde default None). migrate.rs 주석.
+- `kebab-app` `embedder()`(또는 해당 선택부, lib.rs ~836): provider match → fastembed | candle(레지스트리) | ollama. facade 통해 cfg 주입.
+- config 직렬화/round-trip 테스트 갱신.
+
+## Task 4 — correctness 검증 테스트 (핵심)
+- candle arctic vs Ollama arctic 코사인>0.99 테스트: 테스트 문장 임베딩을 candle(arctic spec)로 1개 + Ollama(`snowflake-arctic-embed2` @192.168.0.47)로 1개 → cos>0.99 assert. live Ollama 의존이라 `#[ignore]`(이유: 외부 Ollama), 수동 실행 절차를 테스트 doc + HOTFIXES 에 기록. (CI 무인 환경 회피.)
+- 단, **리더가 머지 전 이 테스트를 수동 실행해 통과 확인**(pooling/prefix 정확성 게이트).
+
+## Task 5 — 검증 + 문서
+- clippy 0 / 전체 test 통과(기존 e5 회귀 0).
+- provider=candle+arctic, ollama+arctic, fastembed+e5(기본) 각 로드 스모크.
+- 문서: README Configuration(provider candle/ollama + arctic + endpoint + metal), ARCHITECTURE(백엔드 그래프 + kebab-embed-ollama 크레이트 + 결정표), HANDOFF 1줄, HOTFIXES dated, Cargo.toml members + version minor bump(+Cargo.lock).
+
+## 리뷰 루프
+구현 완료 → 리더가 (a) clippy/test 독립 재확인 (b) **candle≈Ollama 코사인>0.99 수동 검증** → `gitea-pr`(title `feat(embed): arctic-embed-l-v2.0 임베더(candle+ollama)`) → 리뷰 루프 → 사용자 머지. 머지 후 Mac Metal 도그푸딩(recall 130 재현).
--- a/docs/superpowers/plans/2026-06-03-config-invalidation-plan.md
+++ b/docs/superpowers/plans/2026-06-03-config-invalidation-plan.md
@@ -0,0 +1,37 @@
+# Plan: ingest 설정 변경 자동 재색인 구현
+
+spec: `docs/superpowers/specs/2026-06-03-ocr-toggle-invalidation-spec.md`. 브랜치 `fix/ingest-config-invalidation`. 빌드 `CARGO_TARGET_DIR=/build/out/cargo-target`, **테스트 `-j 8`**(절대 `-j 1` 금지), cli 통합테스트용 `target` 심링크 후 정리.
+
+## Task 1 — ingest_config_signature 헬퍼 (kebab-app)
+- `fn ingest_config_signature(config: &Config, media: &MediaType) -> String` 추가.
+- 공통: `[chunking]` target_tokens, overlap_tokens, respect_markdown_headings, chunker_version.
+- image: + image.ocr.enabled (+model if enabled) + image.caption.enabled (+prompt_template_version if enabled).
+- pdf: + pdf.ocr.enabled (+model, always_on if enabled).
+- code: + ingest.code.{skip_generated_header, max_file_bytes, max_file_lines, extra_skip_globs(join), ast_chunk_max_lines, fallback_lines_per_chunk, fallback_lines_overlap}.
+- markdown: 공통만.
+- 결정적(필드 순서 고정). 단위테스트: 같은 config→같은 서명, 관련 필드 변경→서명 변경, 무관 필드(search 등)→불변.
+
+## Task 2 — 4개 ingest 경로에 composite parser_version 적용 (kebab-app/lib.rs)
+- md(~351), image(~1532), pdf(~2109), code 경로: `*_parser_version` = `ParserVersion(format!("{base}|{}", ingest_config_signature(config, media)))` (base = 각 extractor PARSER_VERSION).
+- 이 composite 를 (1) `try_skip_unchanged` 의 `current_parser_version` 으로 전달, (2) **persist 전 `canonical.parser_version` override** 로 저장. 두 곳 동일 보장.
+- doc_id 파생은 손대지 않음(workspace_path 조회).
+- markdown/code/image/pdf 각 경로에서 동일 패턴 적용 — 누락 없게.
+
+## Task 3 — 테스트
+- image.ocr off→on, caption off→on: 재색인(skip 아님). off→off / 동일 설정: skip 유지.
+- pdf.ocr off→on: 재색인. 동일: skip.
+- chunking target_tokens 변경: 전 타입 재색인. 무변경: skip.
+- ingest.code 변경: 코드 자산만 재색인.
+- **search/rag/ui 변경: 재색인 0** (회귀 가드).
+- 동일 config 재실행: 전 자산 skip (불필요 재색인 0).
+- 기존 skip 테스트(markdown unchanged 등) 회귀 0.
+
+## Task 4 — 검증 + 문서
+- `cargo clippy --workspace --all-targets -j 8 -- -D warnings` 0.
+- `cargo test -p kebab-app -p kebab-parse-image -p kebab-parse-pdf -p kebab-parse-code -p kebab-chunk -j 8` 통과(touched 크레이트 타깃; 전체 -j1 금지).
+- 스모크: 이미지 ocr off 색인 → config ocr on → `kebab ingest`(force 없이) → 그 이미지 재색인 확인.
+- tasks/HOTFIXES dated entry(일반화 + 업그레이드 1회 재색인 안내), Cargo.toml version **0.26.1 → 0.26.2**(+Cargo.lock), HANDOFF 1줄. README/wire 변화 없음.
+- 결과 요약 `/tmp/cfginval-result.md`(게이트 + 스모크 캡처).
+
+## 리뷰 루프
+완료 → 리더 clippy/타깃테스트(-j8) 독립 재확인 + 토글 스모크 → `gitea-pr`(title `fix(ingest): ingest 설정 변경 시 영향 자산 자동 재색인`) → 리뷰 루프 → 사용자 머지.
--- a/docs/superpowers/plans/2026-06-03-ingest-log-improve-plan.md
+++ b/docs/superpowers/plans/2026-06-03-ingest-log-improve-plan.md
@@ -0,0 +1,33 @@
+# Plan: ingest 로그 개선 구현
+
+spec: `docs/superpowers/specs/2026-06-03-ingest-log-improve-spec.md`. 브랜치 `feat/ingest-log-improve`. 빌드 `CARGO_TARGET_DIR=/build/out/cargo-target -j 4`(전체 test `-j 1`). cli 통합테스트용 `target` 심링크 후 정리.
+
+## Task 1 — wire 이벤트 (kebab-app/src/ingest_progress.rs)
+- `IngestEvent` 에 `AssetPhase { idx: u32, total: u32, phase: String, model: Option<String> }` variant 추가(serde tag 규약 기존과 동일, snake `asset_phase`).
+- `AssetTimings` 에 `ocr_ms: u64`, `caption_ms: u64` 필드 추가(기존 필드 뒤, serde default 0 → 구 소비자 호환).
+- 직렬화 테스트 추가(asset_phase, 확장 timings).
+
+## Task 2 — emit 지점 (kebab-app/src/lib.rs)
+- 이미지 경로: `apply_ocr` 직전 `AssetPhase{phase:"ocr", model: <ocr model>}`, `apply_caption` 직전 `AssetPhase{phase:"caption", model: <llm model>}` emit. 각 호출 시간 측정 → `ocr_ms`/`caption_ms`.
+- 임베딩 루프 진입 직전 `AssetPhase{phase:"embed", model: embedder.model_id}` emit(텍스트 포함 전 asset).
+- `AssetTimings` 생성부에 ocr_ms/caption_ms 전달.
+- 짧은 phase(parse/chunk/store)는 emit 안 함.
+
+## Task 3 — CLI 렌더 (kebab-cli/src/progress.rs)
+- **파일명**: AssetStarted TTY 핸들러 `bar.set_message(<path>)` (현재 위치-only 주석/로직 교체; path 길면 말미 축약). 비-TTY 줄 유지.
+- **phase+모델**: AssetPhase 수신 → `bar.set_message(format!("{path} · {phase}({model})…"))`. 현재 path 를 핸들러 상태로 보관(AssetStarted 에서 저장).
+- **heartbeat**: AssetStarted 에서 `Instant::now()` 보관 + `bar.enable_steady_tick(1s)` + 메시지 렌더에 경과초 `(Ns)`. AssetFinished/다음 AssetStarted 에서 리셋. (indicatif steady-tick + 커스텀 메시지.)
+- **slowest 요약**: 핸들러에 `Vec<(path, total_ms)>` 누적 — AssetStarted 로 idx→path, AssetTimings 로 idx→sum(parse+chunk+embed+store+ocr+caption). `Completed` 수신 시 상위 5개 stderr 표 출력(`⏱ 최장 소요:`). `--json` 모드 미출력, quiet 여도 요약은 출력.
+- `fmt_ms`(기존) 재사용.
+
+## Task 4 — wire schema + 문서
+- `docs/wire-schema/v1/ingest_progress.schema.json`: `asset_phase` kind(phase enum, model) + `ocr_ms`/`caption_ms` 필드 추가(additive). verbatim 일치.
+- README(있으면 진행 표시 한 줄), HANDOFF 1줄, tasks/HOTFIXES dated entry, Cargo.toml version minor bump(+Cargo.lock).
+
+## Task 5 — 검증
+- clippy 0, 전체 test 통과(기존 progress 테스트 갱신).
+- 스모크: 이미지/PDF 포함 임시 폴더 ingest → TTY 파일명+phase+모델+경과, 종료 top-N. 비-TTY 줄+요약. `--json` ndjson(asset_phase/ocr_ms) 확인, 사람텍스트 미혼입.
+- 결과 요약 `/tmp/ingestlog-result.md`(게이트 + 스모크 캡처).
+
+## 리뷰 루프
+완료 → 리더 clippy/test 독립 재확인 → `gitea-pr`(title `feat(ingest): 진행 로그 개선 — 파일명/phase/heartbeat/slowest 요약`) → 리뷰 루프 → 사용자 머지. 머지 후 Obsidian 볼트 도그푸딩.
--- a/docs/superpowers/plans/2026-06-03-remove-doc-expansion-plan.md
+++ b/docs/superpowers/plans/2026-06-03-remove-doc-expansion-plan.md
@@ -0,0 +1,49 @@
+# Plan: doc-side expansion(별칭) 제거 구현
+
+spec: `docs/superpowers/specs/2026-06-03-remove-doc-expansion-spec.md`. 브랜치 `refactor/remove-doc-expansion`. 빌드 `CARGO_TARGET_DIR=/build/out/cargo-target`, 직렬 `-j 4`(전체 테스트는 `-j 1`).
+
+원칙: 작은 단위로 컴파일 가능 상태 유지. 각 단계 후 `cargo build -p <crate> -j 4`. 최종 clippy+test.
+
+## Task 1 — kebab-core: Chunk.aliases 필드 제거
+- `chunk.rs`: `pub aliases: Option<String>` + serde default + `aliases_defaults_to_none_on_deserialize` 테스트 제거.
+- **금지**: `metadata.rs` `Metadata.aliases`(Vec) 는 손대지 않음.
+- 컴파일 깨짐 → Task 2~ 에서 Chunk 리터럴 정리하며 해소.
+
+## Task 2 — Chunk 리터럴 정리 (kebab-chunk/*, kebab-parse-*/*, store-sqlite, app)
+- `grep -rn "aliases: None" crates/*/src` 로 Chunk 생성부 전수 → `aliases: None,` 줄 삭제.
+- store-sqlite `documents.rs`: chunks INSERT 컬럼리스트/바인딩에서 `aliases` 제거(line ~126/156), SELECT 매핑의 aliases 제거, `aliases: None`(271) 제거.
+
+## Task 3 — kebab-app: expansion 모듈 + 루프 제거
+- `lib.rs`: `pub mod expansion;` 삭제, `expansion.rs` 파일 삭제.
+- ingest_one_asset: expansion 블록 전체(`if app.config.ingest.expansion.enabled { … }` + `alias_version_key`/`alias_cache_*`/`alias_touch_keys`/embed_aliases 임베딩/sentinel 벡터 생성) 제거. `expansion_ms` 타이밍은 0 고정 또는 AssetTimings 에서 필드 유지하되 항상 0 — **AssetTimings 의 expansion_ms 필드는 유지(wire 호환)**, 값 0.
+- alias sentinel 벡터 upsert 경로 제거, purge_vector_orphans 는 본문 벡터 정리로 유지.
+
+## Task 4 — kebab-config: ExpansionCfg 제거
+- `lib.rs`: `ExpansionCfg` struct + `IngestCfg.expansion` 필드 + Default 제거.
+- `migrate.rs`: `[ingest.expansion]` 처리/주석 제거.
+- config 직렬화 테스트에서 expansion 기대 제거.
+
+## Task 5 — kebab-search: alias lexical arm 제거
+- `lexical.rs`: `run_alias_query`, `merge_body_alias`, alias 분기 제거. body_rows 직접 사용으로 단순화. alias 관련 테스트 제거/갱신.
+
+## Task 6 — wire/progress 정리
+- `kebab-app/ingest_progress.rs`: `IngestEvent::ExpansionProgress` variant + 직렬화 테스트 제거. AssetChunked/AssetTimings 유지.
+- `kebab-cli/progress.rs`, `kebab-tui/ingest_progress.rs`: ExpansionProgress 매치/렌더 제거.
+- `kebab-tui/inspect.rs`: 별칭 표시 제거.
+- `docs/wire-schema/v1/ingest_progress.schema.json`: expansion_progress kind 제거.
+
+## Task 7 — sqlite 마이그레이션: DROP chunk_aliases_fts + chunks.aliases
+- `schema.rs`(refinery 마이그레이션 등록부) 확인 → 신규 forward 마이그레이션 추가: `DROP TABLE IF EXISTS chunk_aliases_fts` (+ 관련 트리거/shadow 테이블 chunk_aliases_fts_*), `ALTER TABLE chunks DROP COLUMN aliases`.
+- chunk_aliases_fts 를 만들던 기존 마이그레이션은 **수정 금지**(과거 마이그레이션 freeze) — 새 마이그레이션으로 덮어 제거.
+- `tests/chunk_aliases.rs` 삭제. `tests/migration.rs` 신규 마이그레이션 반영.
+- 번들 sqlite DROP COLUMN 지원 확인(3.35+); 미지원이면 테이블 재생성 패턴.
+
+## Task 8 — 검증 + 문서
+- `cargo clippy --workspace --all-targets -j 4 -- -D warnings`.
+- `cargo test --workspace --no-fail-fast -j 1`.
+- fresh KB `.schema` 로 chunk_aliases_fts/aliases 부재 확인. `kebab ingest` 스모크(별칭 config 없이).
+- grep 잔존 0 (spec Acceptance 의 정규식).
+- 문서: HOTFIXES dated entry, 2026-05-30 doc-expansion-design spec Risks/notes cross-link, HANDOFF 1줄, wire schema, design 본문 removed 주석, Cargo.toml version bump.
+
+## 리뷰 루프
+구현 완료 → `gitea-pr`(title `refactor(app): doc-side expansion(별칭) 제거`, body 요약/검증) → gitea-pr 리뷰 루프(actionable 해소까지) → 사용자 머지.
--- a/docs/superpowers/plans/2026-06-04-rust-native-ocr-plan.md
+++ b/docs/superpowers/plans/2026-06-04-rust-native-ocr-plan.md
@@ -0,0 +1,89 @@
+# Plan: Rust 네이티브 OCR 엔진 (PP-OCRv5 ONNX) 구현
+
+spec: `docs/superpowers/specs/2026-06-04-rust-native-ocr-spec.md`. 브랜치 `feat/rust-native-ocr`.
+빌드 `CARGO_TARGET_DIR=/build/out/cargo-target`, 테스트 **`-j 8`**(절대 `-j 1` 금지), touched 크레이트 위주(`-p kebab-parse-image -p kebab-app -p kebab-config`).
+참조 구현: `oar-ocr`(Apache-2.0) 소스 + Python PaddleOCR + 검증된 PoC `/build/cache/ocr-bench/{rust-poc,onnx,rc9-spike}/`(변환 ONNX + rc.9 동작 확인).
+
+## Task 0a — 레퍼런스 골든 하네스 (C1 — 최우선 선행, executor 차단 제거)
+**T3/T5 골든은 oar-ocr 로 못 만든다**(중간 텐서 미노출, PoC 는 최종텍스트만). 먼저 Python `onnxruntime` 직접(oar-ocr X)으로 변환 모델을 돌려 fixture 별 중간 산출을 골든으로 덤프:
+- 입력: `/build/dogfood/corpus/images/synthetic-ocr-bench/` fixtures + 변환 ONNX(`/build/cache/ocr-bench/onnx/`).
+- 덤프(JSON/npy, repo `crates/kebab-parse-image/tests/golden/`): (a) det 확률맵 슬라이스, (b) threshold 후 박스 폴리곤, (c) **rec 원시 logits `[T,C]`**, (d) 디코드 문자열, (e) 전처리 텐서 일부값.
+- **M2 해결**: 알려진 텍스트라인 crop 의 logits + argmax 로 **blank 인덱스 + dict 11,945→클래스 11,947 매핑(+2 정체)을 경험적으로 도출**해 plan/주석에 사실로 기록(추정 금지). 경계문자(dict 첫/끝) 포함 골든.
+- 도구: 기존 venv `/build/cache/ocr-bench/venv`(onnxruntime 직접 설치) 또는 paddleocr API 의 raw 단계. 하네스 스크립트는 `/build/cache/ocr-bench/` 에 보관(런타임 의존 아님, 골든 생성 전용).
+- 수용: 각 fixture 골든 파일 생성 + blank 인덱스 문서화. 이후 T3~T5 가 이 골든에 핀.
+
+## Task 0 — 모델 번들 (결정 C-1: include_bytes, release feature 게이트)
+- 변환 ONNX(이미 존재: `/build/cache/ocr-bench/onnx/{ppocrv5_mobile_det.onnx, korean_ppocrv5_mobile_rec.onnx, korean_dict.txt}`)를 repo `crates/kebab-parse-image/assets/paddleocr-onnx/` 에 배치(+NOTICE, Apache-2.0).
+- `bundled-ocr-models` cargo feature: on 이면 `include_bytes!` 로 임베드, off(dev 기본)면 config override 경로 필수. release 빌드는 feature on.
+- 대안 C-2/C-3 는 빌드/링크 부담 측정 후 폴백(spec §모델 배포). 17MB 임베드의 dev 링크 영향 먼저 측정 — 과하면 C-2(repo 벤더 + OUT_DIR) 전환.
+- **assets 17MB 커밋 방식 결정(M4/packaging)**: git-LFS 권장(clone/`cargo package` 비대 회피). `.gitattributes` 에 `*.onnx filter=lfs`. NOTICE(Apache-2.0) 동반.
+- **테스트 모델 출처(M4)**: OCR 단위/e2e 테스트는 `bundled-ocr-models` feature 무관하게 `KEBAB_TEST_OCR_MODEL_DIR`(기본 `assets/paddleocr-onnx/`)에서 로드. 모델 없으면 `#[ignore]` 가 아니라 명확 skip+경고(CI 는 assets 존재 가정). dev 빌드 OCR 테스트가 모델 못 찾아 실패하는 모호함 제거.
+- 수용: feature on 빌드 임베드 확인, off 빌드 정상, 테스트가 assets 에서 모델 로드.
+
+## Task 1 — 의존성 (kebab-parse-image/Cargo.toml)
+- `ort = { workspace = true, features = ["ndarray", "download-binaries"] }`(C1: 단독빌드 링크, nli 선례 주석). `ndarray = { workspace = true }`. `imageproc`(연결요소/윤곽).
+- `ort-sys` caret 으로 rc.12 끌려가지 않게 Cargo.lock 정합 확인(rc.9 고정). unclip 다각형 offset 은 **pure-Rust 직접 구현**(clipper2 C++ FFI 회피 — spec).
+- 수용: `cargo build -p kebab-parse-image -j 8` 링크 성공(onnxruntime), `cargo tree` 에 ort 단일 rc.9.
+
+## Task 2 — OnnxPaddleOcr 골격 + 전처리 (kebab-parse-image)
+- **선행 사실 확인**: rc.9 `ort::Session` 이 `Send+Sync` 인지 먼저 확인(아니면 Mutex 래핑). 결과를 주석에 기록.
+- 신규 모듈 `paddle_onnx.rs`. `OcrEngine` 구현. **`engine_version`=생성 시 모델+dict blake3 1회 계산해 String 캐시**(m3: per-asset 재해시 금지 — `ingest_config_signature` 가 자산마다 호출). format 고정(후일 변경 시 mass 재색인 주의).
+- det/rec `ort::Session` 2개 1회 로드 후 보관. **max_pixels 자체 bounds 적용**(spec 의 ocr.rs MIN/MAX clamp 은 Ollama private — paddle 은 자기 clamp 명시).
+- 전처리: 디코드(image)→긴변 max_pixels 축소→BGR mean/std 정규화→`Array4<f32>`.
+- 수용: 단위테스트 — 알려진 이미지→입력텐서 일부 값 골든(T0a).
+
+## Task 3 — det 후처리 (단계 단위, 골든벡터)
+- det Session 추론(`[1,1,H,W]` 확률맵, rc.9 `try_extract_tensor`→`ArrayViewD`) → threshold 0.3 이진화 → imageproc 연결요소/윤곽 → **min-area rotated-rect(rotating calipers 직접 구현)** → **unclip(pure-Rust 다각형 offset, ratio 1.5)** → 박스 Vec.
+- 수용: 합성 fixture 기대 박스 개수/대략 좌표 골든. min-area rect·unclip 각각 단위테스트.
+
+## Task 4 — crop + rectify
+- 회전 박스 → perspective/affine warp 로 수평 정렬(oar-ocr 가 제공하던 부분 이식).
+- 수용: 회전 텍스트 fixture → 정렬 crop 골든.
+
+## Task 5 — rec + CTC decode
+- crop→48×W 정규화→rec Session(`[1,T,C]`) → CTC greedy(argmax/timestep→연속중복 제거→blank 제거).
+- **blank 인덱스 + 11,945→11,947 매핑은 T0a 하네스에서 도출한 사실을 사용**(추정 금지). bounds-check(dict 길이≠클래스 시 생성 에러).
+- 수용: T0a 골든 logit→문자열 일치(blank/중복/**경계문자 dict 첫·끝** 포함).
+
+## Task 6 — 조립 + OcrText
+- 박스 reading-order(상→하,좌→우) → `OcrText{joined, regions:[OcrRegion{bbox,text,confidence}], engine, engine_version}`. per-region 실제 confidence(Ollama 상수1.0 대비 값 변화 — release note).
+- 수용: e2e — 합성 한/영 fixture **CER ≤ 0.05**, bbox>0. PoC 0.976 baseline 대비 회귀 없음.
+- **CER 게이트 실패 시 폴백 사다리(M3)**: ① T0a 단계 골든과 diff 해 어느 단계 divergence 인지 국소화 → ② det postproc(unclip/min-area rect)가 원인이면 **oar-ocr 의 해당 함수를 verbatim 이식**(Apache-2.0, NOTICE+파일별 출처 표기 — 코드 파생물) → ③ time-box(예 반나절) 초과 시 리더 escalate. 손수 재유도에 매몰 금지.
+
+## Task 7 — config (kebab-config)
+- `OcrCfg`: `engine` 값에 "paddle-onnx" 문서화(기본 "ollama-vision" 유지). 신규 override `det_model`/`rec_model`/`dict`(Option), `score_thresh`(0.3)/`unclip_ratio`(1.5)/`max_boxes`(1000). `KEBAB_IMAGE_OCR_*` env. serde default(forward-compat) + init 템플릿 노출.
+- 수용: override 미지정→번들 모델, 지정→그 경로 사용 테스트. config migrate(#198) 무수정 로드 회귀.
+
+## Task 8 — 엔진 팩토리 (kebab-app/lib.rs) — **4개 site 전부(M1)**
+구체타입 `OllamaVisionOcr` 가 박힌 곳이 4군데 — 누락 시 타입에러로 막힘:
+- `:360` image 엔진 생성 → `Box<dyn OcrEngine>` 팩토리(`match engine`: ollama-vision|paddle-onnx|err).
+- `:379` pdf 엔진 생성 → 동일 팩토리.
+- `:839` `ImagePipeline.ocr_engine` 필드 → `Option<&dyn OcrEngine>`.
+- `:1113`, `:2096` `pdf_ocr_engine: Option<&OllamaVisionOcr>` 함수 시그니처 2곳 → `Option<&dyn OcrEngine>`.
+- `apply_ocr_to_pdf_pages`(`pdf_ocr_apply.rs:93`)는 이미 `&dyn OcrEngine` — 스레딩만 변경, 헬퍼 불변. `--config` facade 스레딩(`OnnxPaddleOcr::new(cfg,…)`).
+- 수용: 팩토리 단위테스트(선택/미지값 에러). **ollama-vision 경로 출력 동일** 회귀 테스트(구체→dyn 전환 무영향).
+
+## Task 9 — 서명 cascade (C3, kebab-app)
+- `ingest_config_signature` image/pdf 브랜치 `|ocr:1:{model}` → `|ocr:1:{engine}:{engine_version}`(engine + 모델/dict blake3). 
+- 수용: (a)ollama↔paddle 동일model→서명다름 (b)engine_version 다름→다름 (c)search 등 무관→불변. → 엔진/모델 변경 시 v0.26.2 자동 재색인.
+
+## Task 10 — 에러 매트릭스 (spec §에러 처리)
+- 다운로드/blake3 실패→fail-fast, 디코드불가→skip+provenance, det 0박스→`OcrText{"",[]}` 성공, rec 빈→박스skip, 박스폭증→max_boxes 절단+로그, dict 불일치→생성에러.
+- 수용: 각 케이스 단위/통합 테스트.
+
+## Task 11 — 검증 게이트
+- `cargo clippy --workspace --all-targets -j 8 -- -D warnings` 0.
+- `cargo test -p kebab-parse-image -p kebab-app -p kebab-config -j 8` 통과(+ `-p kebab-parse-image` 단독 링크 확인).
+- 스모크: `engine="paddle-onnx"` 이미지 ingest→FTS5 hit, 큰 페이지 CPU <5초.
+
+## Task 12 — 문서 + 버전 + 도그푸딩
+- README(Configuration: `image.ocr.engine`+모델 번들), docs/SMOKE(config 예시), HANDOFF 1줄, docs/ARCHITECTURE(OCR 백엔드/그래프), HOTFIXES dated entry.
+- Cargo.toml workspace version **minor bump**(+Cargo.lock). release notes(엔진 추가/per-region confidence/오프라인).
+- 도그푸딩: 사용자 실제 이미지·책 스캔 정확도·속도 → HOTFIXES + release notes evidence.
+- 결과 요약 `/tmp/rust-ocr-result.md`(게이트 + 스모크 + 도그푸딩 캡처).
+
+## 리뷰 루프
+완료 → 리더 clippy/타깃테스트(-j8) 독립 재확인 + paddle-onnx 스모크 → `gitea-pr`(title `feat(ocr): PP-OCRv5 ONNX Rust 네이티브 OCR 엔진`) → 리뷰 루프 → 사용자 머지. 모델 ONNX 는 release feature/asset 로 동반.
+
+## 단계 의존
+**T0a(레퍼런스 골든+blank 도출) 최우선 선행** → T0(번들),T1(deps) → T2→T3→T4→T5→T6(파이프라인 순차, 각 T0a 골든에 핀) ∥ T7(config) → T8(팩토리 4site)→T9(서명)→T10(에러) → T11 게이트 → T12 문서. T3~T5 가 핵심 난도(직접 이식), T0a 골든+T6 폴백사다리로 회귀·매몰 차단. T8 의 정확한 라인(:1113/:2096 등)은 구현 시점 grep 으로 재확인(코드 이동 가능).
--- a/docs/superpowers/research/2026-06-03-expansion-cost-rethink-research.md
+++ b/docs/superpowers/research/2026-06-03-expansion-cost-rethink-research.md
@@ -0,0 +1,163 @@
+# Expansion 비용 재고 — 별칭(doc-side LLM expansion)을 대체할 방법 조사
+
+**날짜**: 2026-06-03
+**상태**: 조사 완료, 검증(측정) 대기
+**선행**: [[2026-05-30-vocabulary-gap-recall-fix-research]] (당시 결론 = doc-side expansion), v0.21.0 별칭 구현(#195/#196)
+**계기**: 도그푸딩에서 expansion 이 ingest 임계경로의 압도적 병목으로 확정(청크당 gemma4:e4b ~1.3s, 5150 청크 ≈ 1.9h). 동시성(A)·모델스왑(D) 실측 소진. 사용자가 두 구조적 반론 제기.
+
+---
+
+## 1. 문제 재정의 — 왜 "반창고"가 다 실패하는가
+
+별칭은 **청크마다 LLM 1회 호출**(`kebab-app/src/lib.rs` expansion 루프). 비용이 **코퍼스 크기에 비례**하고, KB 가 살아있으므로(문서 수정·추가) **갱신 청크를 영원히 따라가야 함**.
+
+소진된 레버 (전부 *같은 총량을 언제/어떻게 나눌지*만 바꿈, 총량 불변):
+
+| 레버 | 실측(2026-06-02~03, Mac M4 Pro Metal) | 판정 |
+|------|------|------|
+| A. `OLLAMA_NUM_PARALLEL` + 클라 동시요청 | 슬롯 2/4, 동시 2/4/8 → **최대 1.28×** (GPU compute 포화) | ✖ 불충분 |
+| D. 모델 스왑 | gemma4:e4b 1.22s/건(품질 합격선) · qwen2.5vl:3b 더 느림+무한반복 · **qwen3.5:2b-mlx 0.24s(~5배)지만 중국어(所有权系统)+47줄 degeneration** · 0.8b 입력에코 | ✖ gemma 품질 못 이김 |
+| B. 백그라운드/별도명령 | 총량·팬·리소스 불변, 유지보수 treadmill 잔존 | ✖ 사용자 반론으로 기각 |
+
+**사용자 반론(정확)**: ① 별도 명령이어도 맥 팬·리소스 총량 동일 ② 청크당 이렇게 비싸면 갱신을 못 따라감. → "청크마다 미리 LLM" 구조 자체가 부적합. **아키텍처를 의심해야 하는 지점.**
+
+---
+
+## 2. 학계/웹 조사 핵심 발견
+
+### 2.1 결정타 — Expansion 은 강한 검색기에 오히려 해롭다
+*"When do Generative Query and Document Expansions Fail?"* (arXiv 2309.08541): **검색기 성능과 expansion 이득 사이 강한 음의 상관**. 11개 expansion 기법 × 12개 데이터셋 × 24개 검색 모델에서 일관. 약한 모델엔 도움, **강한 모델엔 손해**(추가 noise 가 relevance 신호를 흐림, false positive 유발). 권고: *"target 이 학습 코퍼스와 크게 다르거나 약한 모델일 때만 expansion, 아니면 피하라."*
+
+→ 함의: 별칭의 v0.21.0 이득이 **14/18→16/18(미미)** 였던 건 우연이 아님. e5-large 는 이미 준수한 다국어 검색기 → 별칭은 *목발*에 가깝고 ROI 가 0~음수 구간일 수 있음. **측정으로 즉시 확인 가능**(별칭 on/off 골든 비교).
+
+### 2.2 어휘·교차언어 격차는 본질적으로 *임베딩* 문제
+별칭은 "역전파↔backpropagation 이 벡터공간에서 안 가깝다"를 색인-시 텍스트로 우회한 것. 정공법 = **교차언어가 강한 임베더로 벡터공간 자체에서 정렬**. 비용 = LLM 0, **색인 1회 재계산**(살아있는 KB 에서도 신규/수정 청크 임베딩은 어차피 하는 일 — treadmill 없음).
+
+### 2.3 임베더 후보 (로컬·오픈, 2026)
+- **BGE-M3** (사용자 Mac 에 이미 pull 됨): XLM-RoBERTa-large 기반(= `kebab-embed-candle` 의 `XLMRobertaModel` 과 **동일 아키텍처**), dense **1024-dim**(= e5-large, 벡터스토어 그대로), **prefix 불필요**(e5 의 `query:`/`passage:` 와 달리), 단 **CLS pooling**(e5 는 mean pooling — 통합 시 분기 필요). **dense+sparse(lexical)+multi-vector(ColBERT)** 3-헤드.
+  - 한↔영 실측(Belebele, 2507.08480): base bge-m3 ≈ base e5-large (EN→KO 는 e5 92.0 > m3 90.4, KO→EN 은 m3 88.4 > e5 86.5). **dense 단독 교체만으론 대박 아님**. 차별점은 sparse/multi-vector 헤드.
+- **Qwen3-Embedding** (2026 초, MTEB v2 오픈웨이트 1위; 8B 는 무거움, 0.6B/4B 변형 존재): 다국어 최상위. 소형 변형이 로컬 가용하면 dense 업그레이드 후보.
+- 다국어 일반 권고(2026 가이드들): "BGE-M3 또는 Nomic". e5-large 도 여전히 경쟁력.
+
+### 2.4 Multi-vector(ColBERT)는 색인-전체가 아니라 *질의-시 rerank* 로
+ColBERT/multi-vector 는 토큰당 벡터 1개 → 저장 폭증(10M doc ≈ 6TB vs bi-encoder 30GB). **전체 코퍼스 색인 금지.** 실용 패턴 = dense 1차 검색 → **top-50/100 만 multi-vector late-interaction rerank(질의-시, O(질의))**. 진단된 "near-tie 벡터 불안정"([[project_crossscript_diagnosis]])을 정조준하면서 색인 비용 0.
+
+### 2.5 굳이 expansion 한다면 — query-side, single-pass
+CTQE(2509.02377): LLM 한 번의 decoding 패스에서 candidate token 재활용 → **추가 inference 없이** query expansion. 비용 O(질의), 캐시 가능. doc-side 의 O(코퍼스)·treadmill 과 정반대.
+
+---
+
+## 3. 권고 아키텍처 — 청크당 LLM 0, 측정-우선 단계별
+
+원칙: 비용을 **O(코퍼스 LLM)** 에서 **O(코퍼스 임베딩, 이미 수용중) + O(질의)** 로 이동. 각 단계는 기존 골든/variant eval 로 검증 후 다음 진행(사용자 "측정 먼저" 방법론).
+
+- **Step 0 — 별칭 ROI 실측 (LLM 0, 코드 0)**: 현재 e5-large 에서 별칭 **on vs off** 골든/variant 비교. 2.1 예측대로 차이 미미/음수면 → **별칭 기능 통째 제거**(즉시 최대 승리: 청크당 LLM 영구 소멸). 차이가 유의미할 때만 Step 1+.
+- **Step 1 — 강한 dense 임베더 (LLM 0, 색인 1회)**: BGE-M3 를 `kebab-embed-candle` 로 dense 임베더 교체 검증(같은 XLM-R, CLS pooling + prefix 제거, 1024-dim 동일). 소형 Qwen3-Embedding 가용 시 병행. `embedding_version` cascade = 전체 1회 재임베딩(0.48s/asset 관측, 수용 범위, treadmill 아님).
+- **Step 2 — BGE-M3 sparse 헤드를 lexical arm 으로 (LLM 0)**: 학습된 sparse lexical 이 FTS5 보다 교차언어 우수. 같은 임베드 패스 산출물 → 추가 색인 비용 ≈ 0. RRF 의 lexical 항 보강/대체.
+- **Step 3 — (선택) 질의-시 multi-vector rerank**: 잔존 near-tie 순위 출렁이면 top-50 만 BGE-M3 multi-vector late-interaction rerank(O(질의), 색인 bloat 0).
+
+**통합 이점**: 사용자가 이미 NUMA 대응으로 만든 `kebab-embed-candle`(XLM-RoBERTa)가 BGE-M3 와 동일 아키텍처 → 가중치/풀링/헤드 추가 위주로 재사용. fastembed 도 bge-m3 지원(단 NUMA double-free 회피 위해 candle 경로 선호).
+
+**리스크/주의**: ① dense 단독 교체 이득은 한↔영 데이터상 작을 수 있음 → sparse/multi-vector 가 실질 차별점, Step 1 단독 성패로 판단 말 것. ② CLS vs mean pooling, prefix 차이 → 정확히 구현 안 하면 품질 급락(검증 필수). ③ `embedding_version` bump = breaking, 재임베딩 필요(versioning cascade). ④ Mono-IR 소폭 저하 가능(2507.08480) — 골든의 한국어-단일 케이스도 같이 측정.
+
+---
+
+## 4. Step 0 측정 결과 (2026-06-03, v0.24.0 fresh)
+
+namu corpus(997 docs / 23151 chunks, e5-large) + `namu_golden_step0.yaml`(doc_id 재매핑, 18그룹×4변형+10대조) hybrid k=50.
+
+| arm | fully_consistent | recall@10 | recall@50 | mean_spread@10 | 색인 LLM 비용 |
+|------|------|------|------|------|------|
+| **OFF (별칭 없음, fresh v0.24.0)** | **14/18** | **68/72 (0.944)** | 70/72 (0.972) | **0.222** | **0** |
+| ON (별칭, v0.21.0 prior, 동일 corpus/golden) | 16/18 | ~70/72 | ~72/72 | 0.111 | 별칭 LLM (정답 18문서만 **2.5h**, 전 corpus 수 시간) |
+
+fresh OFF 가 이전 baseline(14/18, A2/B2, spread 0.222)을 **정확히 재현** → 이전 ON(16/18, A1/B1, spread 0.111, handoff 2026-05-31)과 직접 비교 유효. ON 재측정은 시드 캐시의 alias 행이 7개뿐이라 전 corpus cold 별칭생성=수 시간(= 사용자가 못 견디는 그 비용) → 비실시.
+
+**변형 종류별 OFF recall@10 (별칭 0):**
+`en 18/18 · ko 18/18 · syn 11/11 · abbr 7/7 · para 14/18` — **교차언어(en↔ko)·동의어·약어는 별칭 없이 이미 완벽.** 유일한 약점 = 설명형(paraphrase) 4쿼리.
+
+**결론 (Step 0)**:
+- 별칭이 정조준한 **cross-lingual 격차는 e5-large 단독으로 이미 top-10 완벽 해결**(역전파↔backprop 우려는 기우였음). 별칭의 실제 기여 = **paraphrase 그룹 +2(14→16)** 뿐, 그것도 stack/svm 설명형 잔존.
+- 그 +2 를 위해 **색인-시 수 시간 LLM + 살아있는 KB treadmill**(사용자 2대 반론) 을 지불 = ROI 음수 구간. §2.1 "강한 검색기엔 expansion 이 해롭다" 와 정합.
+- **권고**: 별칭 default-off 유지하다 **제거 후보**로 격하. 단 paraphrase 잔존(4쿼리)을 §3 Step 1(BGE-M3 dense, LLM 0/색인 1회)이 닫는지 먼저 측정 → 닫으면 별칭 완전 삭제, 못 닫으면 query-side single-pass(§2.5) 소폭 보강. **어느 쪽도 청크당 LLM 0.**
+
+산출물: `/build/dogfood/_archive/step0/`(config-off/on, kb-off, namu_golden_step0.yaml, fill_docids_step0.py), OFF run `run_019e89c524ca76a1befae126f0c77336`, `/tmp/step0_off_variants.json`.
+
+## 5. Step 1 측정 결과 (2026-06-03) — bge-m3 dense = lateral, 업그레이드 아님
+
+kebab(fastembed 4.9.1)은 bge-m3 dense 미지원(reranker V2M3 / BGE EN·ZH v1.5 / e5 만). candle 은 e5 전용(mean pool+prefix). → **standalone 측정**: kb-off 청크 23151개 + 변형 72쿼리를 Ollama `bge-m3:latest`(Mac GPU, /api/embed, prefix 없음)로 임베딩, exact cosine top-k recall. e5 baseline = kebab `--mode vector`(run_019e89d0...). 청크 임베딩 911s(~25/s), npz 캐시 `bge_m3_chunks.npz`.
+
+| 변형 | e5-large dense | bge-m3 dense | Δ |
+|------|------|------|------|
+| en (영→한 cross-lingual) | 18/18 | 17/18 | −1 |
+| ko | 18/18 | 18/18 | = |
+| syn (동의어) | 11/11 | 10/11 | −1 |
+| abbr (약어) | 7/7 | 6/7 | −1 |
+| **para (설명형)** | 14/18 | **17/18** | **+3** |
+| **recall@10 합계** | **68/72 (0.944)** | **68/72 (0.944)** | **0** |
+| recall@50 합계 | 70/72 | 71/72 | +1 |
+
+bge-m3 미스(recall@10): nn_syn(뉴럴 네트워크 모델), dp_abbr(DP 알고리즘), **stk_para**(stack 설명형 — 양쪽 공통 잔존), re_en(regular expression).
+
+**결론(Step 1)**: bge-m3 dense 는 **맞교환** — 설명형 +3, 용어/약어/영어 −3, 합계 동률. §2.3 KO-EN 연구("base bge-m3 ≈ base e5-large, 케이스별 한쪽씩")의 정량 재현. **dense 단독 임베더 교체는 정당화 안 됨**(이득 0, embedding_version cascade 재임베딩 비용만 발생). bge-m3 의 미검증 레버 = sparse+multivector hybrid(용어 손실을 sparse 가 회복하며 para 이득 유지 가능) — 단 별도/대형 작업(kebab 에 bge-m3 3-head 통합 필요).
+
+## 6. 종합 결론 & 권고
+- **별칭(doc-side expansion) = 제거 확정 후보.** Step 0: cross-lingual 은 e5 단독으로 이미 완벽, 별칭 기여는 para +2 뿐, 대가는 청크당 LLM(살아있는 KB 에 지속 불가). §2.1 문헌과 정합. **권고 = 별칭 기능 제거(또는 영구 default-off + 문서화), e5-large 유지.** → 사용자 2대 반론(총량·treadmill) 즉시 해소.
+- **임베더 교체(e5→bge-m3 dense) = 보류.** Step 1: 이득 0(lateral). 추진 시에도 dense 단독 말고 **bge-m3 hybrid(sparse 포함)** 를 먼저 측정해야 의미 — 별도 조사 트랙.
+- **잔존 약점(설명형 ~4쿼리, 특히 stack)**: 별칭으로도 bge-m3 로도 안 닫힘 → 별도 소형 과제(query-side single-pass §2.5 또는 bge-m3 sparse)로 분리, 우선순위 낮음.
+
+**다음 행동**: 별칭 제거 spec → plan → 구현(gitea-pr 리뷰루프). bge-m3 hybrid 는 후속 조사 항목으로 파킹. 관련 메모리 [[project_expansion_perf]] · [[project_paraphrase_robustness]] · [[project_embedding_numa_backends]].
+
+## 7. 딥리서치 — 별칭 대체 방법 (2026-06-03, 4-agent 병렬)
+
+별칭이 정조준했던 목적(설명형/풀어쓴 질의 recall)을 사용자 제약(로컬, 비용∝질의 또는 색인-1회, 청크당 LLM 금지)에서 달성하는 방법을 4갈래 병렬 조사. 출처는 각 절 말미.
+
+### 7.1 핵심 재프레이밍 (agent 1·4 수렴)
+잔존 실패("마지막에 넣은 것을 먼저 꺼내는 자료구조"→스택)는 **reverse-dictionary / describe-to-term** 과제 — 설명에서 이름(용어)을 찾는, 본질적으로 **생성·추론** 문제. dense cosine(e5든 bge-m3든) 단독이 약한 이유. **함의: 빠진 표면 용어("스택/stack/LIFO")를 materialize 하는 방법 > 벡터만 평활화하는 방법(dense PRF 등).** 측정된 실패 분해(OFF): recall@10 68/72, recall@50 70/72 → **MisRanked ~2(top-50 안, top-10 밖) + Missing ~2(top-50 밖)**.
+
+### 7.2 후보 shortlist (제약 적합)
+| # | 방법 | 비용모델 | 설명형 효과 | 로컬 경로 | 통합 난이도 | 한계 |
+|---|------|---------|-----------|----------|-----------|------|
+| **A** | **heading/title chunk enrichment** (제목+가장 가까운 heading 을 청크 임베드 텍스트/FTS5 필드에 주입) | **per-doc, LLM 0**(heading 추출만, kebab `heading_path` 이미 존재) | terse doc 에 "손잡이" 부여 → Missing 완화. MC-indexing +16~43% recall(무학습) | 색인 1회 재임베딩 | 낮음 | 순수 paraphrase(용어가 doc 본문에도 없음)엔 부분적 |
+| **B** | **임베더 교체 → `dragonkue/snowflake-arctic-embed-l-v2.0-ko`** | 색인 1회 재임베딩, LLM 0 | **e5 대비 Korean 전 벤치 우위**(Ko-StrategyQA·AutoRAGRetrieval·Belebele 설명형 + XPQA 용어 둘 다) — bge-m3 와 달리 **회귀 없는 업그레이드** | XLM-R-large·1024-dim·`query:` prefix = candle crate 거의 드롭인 | 낮음 | chunk >~1300토큰서 품질↓(긴 청크면 KURE-v1 고려) |
+| **C** | **query-time rerank `bge-reranker-v2-m3`** (RRF top-50 재정렬) | **per-query**(O질의) | MisRanked 설명형의 정석 해결(cross-encoder 토큰 상호작용); 긴/설명형서 이득 최대 | **fastembed 4.9.1 `BGERerankerV2M3` 이미 보유**(ONNX int8 CPU/ M4 GPU) | 가장 낮음(신규 인덱스 0) | **Missing 못 고침**(top-50 밖). CPU FP32 느림→int8 필수. `dragonkue/...-ko` 파인튠 +3.5% |
+| **D** | **term-style query expansion**(설명→핵심용어 ≤32토큰, 캐시, RRF 별 리스트 융합) | per-query, **캐시→amortized ~0** | reverse-dictionary 직접 공략(용어 materialize). pseudo-doc(HyDE) 아님 | 기존 Ollama 재사용 | 중간 | 드리프트 위험→원쿼리 융합 유지·하드질의만 게이트 |
+| **E** | **bge-m3 sparse 헤드**를 RRF lexical 항으로 | 색인 1회(dense+sparse 1패스), LLM 0 | dense 의 용어/약어 손실 회복 가능(MLDR서 sparse>dense +10NDCG) | fastembed `SparseTextEmbedding`/ bge-m3 ONNX | 높음(3rd 인덱스+가중치) | FTS5 와 중복, dense 항은 Korean서 arctic-ko 보다 약함 |
+
+### 7.3 수렴한 경고 (피할 것)
+- **always-on HyDE / pseudo-document LLM**: 로컬 1~4B 에서 13s+/질의, 살아있는(long-tail) KB 서 환각·baseline 하회. → 쓰면 **term 변형 + 하드질의 게이트만**.
+- **dense PRF 를 주해법으로**: 이미 recalled facet 만 강화, Missing 못 살림, 드리프트. (싼 add-on 이상 금물.)
+- **학습형 QPP 를 트리거로**: 비신뢰·미일반화(2504.01101). → 대신 사용자가 이미 측정한 **near-tie Δcosine(0.003~0.005, [[project_crossscript_diagnosis]])** 를 corpus-보정 게이트로 사용.
+- **SPLADE 전면 도입 / ColBERT 전체 색인**: Korean 약함·저장 폭증. (multi-vector 는 top-k rerank 로만.)
+- **reranking 으로 Missing 기대**: 불가(1차에 없으면 못 살림).
+
+### 7.4 권고 — 측정-우선 계층 (싼 것부터)
+0. **무료 점검**: e5 `query:`/`passage:` prefix 정확 적용 확인(불일치 시 verbose↔terse 격차 악화). 코드 0.
+1. **Layer A (heading enrichment)** — 가장 싸고 제약 완벽 적합, kebab 이 `heading_path` 보유. 재임베딩 1회 후 골든 측정. Missing 완화 기대.
+2. **Layer B (arctic-ko 임베더)** — bge-m3 와 달리 회귀 없는 Korean 업그레이드 가설. candle 드롭인. A 와 직교·중첩 가능. 측정.
+3. **Layer C (bge-reranker-v2-m3 top-50)** — MisRanked 해결 + **MisRanked:Missing 비율 진단 도구**(한 실험으로 둘 다). 이미 보유.
+4. **Layer D (near-tie 게이트 term-expansion/triggered HyDE)** — A~C 후에도 순수 paraphrase 잔존 시에만, 하드질의에만.
+
+각 계층은 기존 golden/variant eval 로 검증, 회귀(잘 되던 질의) 감시.
+
+### 7.5 반대 의견 (agent 4, 정직히 기록)
+단일 사용자 KB(본인이 쓴 corpus, 존재를 기억)에선 놓친 paraphrase 질의는 **용어로 재입력하면 초 단위 복구** — 멀티테넌트엔 없는 무료 fallback. 공격적 expansion 의 false-positive 비용 > 가끔의 miss 비용일 수 있음. reverse-dictionary 는 본질적으로 어려워(생성 추론) 무리한 추격은 16/18 잘 되는 걸 회귀시킬 위험([[project_ranking_deferred]]). **현실적 결론: 싼 A(+B) 로 80% 잡고, 잔존 paraphrase 꼬리는 "알려진 한계"로 문서화** — eval 이 그게 실사용의 큰 반복 비중임을 보이지 않는 한.
+
+### 7.6 출처
+- reverse-dictionary: [GEAR 2412.06654](https://arxiv.org/pdf/2412.06654) · [unified RD 2205.04602](https://arxiv.org/abs/2205.04602) · [RD probe 2402.14404](https://arxiv.org/pdf/2402.14404)
+- query expansion: [CTQE 2509.02377](https://arxiv.org/abs/2509.02377) · [QE survey 2509.07794](https://arxiv.org/html/2509.07794) · [knowledge-leakage 2504.14175](https://arxiv.org/html/2504.14175v1) · [HyDE on local 1B/4B 2506.21568](https://arxiv.org/html/2506.21568v1)
+- PRF: [LLM-VPRF 2504.01448](https://arxiv.org/abs/2504.01448) · [PRF pitfalls TOIS 3570724](https://dl.acm.org/doi/10.1145/3570724)
+- rerank: [bge-reranker-v2-m3](https://huggingface.co/BAAI/bge-reranker-v2-m3) · [dragonkue ko 파인튠](https://huggingface.co/dragonkue/bge-reranker-v2-m3-ko) · [onnx-community ONNX](https://huggingface.co/onnx-community/bge-reranker-v2-m3-ONNX) · [FlashRank](https://github.com/PrithivirajDamodaran/FlashRank) · [Scaling Laws for Reranking 2603.04816](https://arxiv.org/pdf/2603.04816) · [SlideGar 2501.09186](https://arxiv.org/html/2501.09186v1)
+- 임베더: [arctic-embed-l-v2.0-ko](https://huggingface.co/dragonkue/snowflake-arctic-embed-l-v2.0-ko) · [Arctic-Embed 2.0 2412.04506](https://arxiv.org/html/2412.04506v1) · [ko-embedding-leaderboard](https://github.com/OnAnd0n/ko-embedding-leaderboard) · [KURE](https://github.com/nlpai-lab/KURE) · [bge-m3 2402.03216](https://arxiv.org/html/2402.03216v3) · [bge-m3-onnx dense+sparse](https://github.com/yuniko-software/bge-m3-onnx)
+- verbose-query/asymmetry: [Key Concepts in Verbose Queries (SIGIR'08)](https://dl.acm.org/doi/abs/10.1145/1390334.1390419) · [Collapse of Dense Retrievers 2503.05037](https://arxiv.org/pdf/2503.05037) · [MC-indexing 2404.15103](https://arxiv.org/pdf/2404.15103) · [Elastic title-into-chunk](https://www.elastic.co/search-labs/blog/multi-vector-documents) · [Adaptive-RAG 2403.14403](https://arxiv.org/pdf/2403.14403) · [QPP limits 2504.01101](https://arxiv.org/abs/2504.01101)
+
+## 출처
+- [When do Generative Query and Document Expansions Fail? (2309.08541)](https://arxiv.org/pdf/2309.08541)
+- [Korean-English Cross-Lingual Retrieval data-centric study (2507.08480)](https://arxiv.org/html/2507.08480)
+- [BGE M3-Embedding (2402.03216)](https://arxiv.org/html/2402.03216v3) · [HF BAAI/bge-m3](https://huggingface.co/BAAI/bge-m3) · [Ollama bge-m3](https://ollama.com/library/bge-m3)
+- [Doc2Query++ (2510.09557)](https://arxiv.org/abs/2510.09557) · [Doc2Query-- When Less is More](https://www.semanticscholar.org/paper/7b2e78d4e7986914ae633fa6b30e73bad8a2b2c1)
+- [CTQE — Upcycling Candidate Tokens for Query Expansion (2509.02377)](https://arxiv.org/pdf/2509.02377)
+- [Query Expansion in the Age of LLMs: A Survey (2509.07794)](https://arxiv.org/abs/2509.07794)
+- [Best Open-Source Embedding Models 2026 (BentoML)](https://www.bentoml.com/blog/a-guide-to-open-source-embedding-models)
+- [ColBERT / late interaction storage tradeoff (Weaviate)](https://weaviate.io/blog/late-interaction-overview) · [PLAID (2205.09707)](https://arxiv.org/pdf/2205.09707)
+- [MILCO — multilingual learned sparse (2510.00671)](https://www.arxiv.org/pdf/2510.00671)
--- a/docs/superpowers/specs/2026-05-30-doc-side-expansion-design.md
+++ b/docs/superpowers/specs/2026-05-30-doc-side-expansion-design.md
@@ -15,6 +15,12 @@ contract_sections:

 # 색인시 doc-side expansion — 설계 spec

+> **⚠️ 제거됨 (2026-06-03).** 본 spec 이 도입한 doc-side expansion(별칭) 기능은
+> 2026-06-03 완전히 제거되었다. 근거: 별칭 ROI 음수(cross-lingual 은 e5-large
+> 단독으로 충분, 기여는 설명형 +2 그룹뿐인데 대가가 살아있는 KB 에 지속 불가한
+> 청크당 색인-시 LLM). 제거 spec: `docs/superpowers/specs/2026-06-03-remove-doc-expansion-spec.md`,
+> HOTFIXES dated entry 2026-06-03. 이 문서는 역사적 contract 로 freeze 유지.
+
 ## 0. 한 줄 요약

 문서를 색인할 때(ingest) 각 청크마다 로컬 LLM(gemma)에게 "이 내용을 찾을 사람이 던질 법한 다른
--- a/docs/superpowers/specs/2026-06-03-arctic-embedder-spec.md
+++ b/docs/superpowers/specs/2026-06-03-arctic-embedder-spec.md
@@ -0,0 +1,66 @@
+# Spec: arctic-embed-l-v2.0 임베더 통합 (candle 우선 + Ollama provider)
+
+**날짜**: 2026-06-03
+**유형**: feature (신규 임베딩 백엔드/모델)
+**근거**: `docs/superpowers/research/2026-06-03-expansion-cost-rethink-research.md` + `/build/dogfood/logs/2026-06-03-method-measurements.md`. 별칭 제거(v0.25.0) 후 설명형 recall 보강의 최선책. 측정: arctic-embed2 = recall@10 **130/132**, recall@50 **132/132**, **용어 무손실**(bge-m3 와 달리 syn/abbr/en 유지). e5 대비 +7, 색인 1회·per-query 0·LLM 0 = 살아있는 KB 최적합.
+**사용자 결정**: candle 우선 + Ollama embed provider 폴백 둘 다.
+
+## 목표
+`models.embedding` 에서 arctic-embed-l-v2.0 을 선택 가능하게 한다. 두 백엔드:
+1. **candle** (주): `kebab-embed-candle` 를 e5 전용 → 다중 모델로 일반화, arctic 추가. in-process pure-Rust, NUMA 안전.
+2. **ollama** (폴백): 신규 Ollama embedding provider. 측정에 쓴 경로(`/api/embed`) 그대로 → 130 보장.
+기본 동작 불변(기본 provider=fastembed e5). arctic 은 opt-in.
+
+## 모델 사실 (구현 기준)
+- 아키텍처: **XLM-RoBERTa-large** (candle `XLMRobertaModel` 로드 가능, e5 와 동일 계열).
+- dim: **1024** (e5 와 동일 → 벡터스토어/lancedb 테이블 차원 불변, 단 테이블명은 모델명 포함).
+- pooling: arctic-embed-l-v2.0 의 sentence-transformers `1_Pooling/config.json` 기준(**CLS 토큰 추정 — 반드시 config 로 확인**). e5 는 mean pooling → pooling 을 모델별 분기.
+- prefix: **query 에 `query: ` 접두어, 문서는 무접두어**(e5 의 `query:`/`passage:` 와 다름). 모델별 분기.
+- 정규화: L2 normalize (코사인 일관성, 기존 e5 경로와 동일).
+- HF repo: `Snowflake/snowflake-arctic-embed-l-v2.0` (candle 다운로드). Ollama: `snowflake-arctic-embed2`.
+
+## 작업 A — kebab-embed-candle 다중 모델화
+- 현재 `HF_MODEL`/`SUPPORTED_MODEL` 상수(e5 하드코딩) → **모델 레지스트리**로: `{ name, hf_repo, pooling: Mean|Cls, query_prefix, doc_prefix, dim }`. e5(mean, `query: `/`passage: `) + arctic(cls, `query: `/``).
+- `embed_batch` 의 pooling 단계를 모델별 분기(mean=attention-mask-weighted mean / cls=first token). 나머지(tokenize→forward→L2)는 공유.
+- `model_id()` / `model_version()` 가 모델명+pooling 반영(전환 시 embedding_version cascade 트리거).
+- config `models.embedding.model` 이 레지스트리에 없으면 기존처럼 명확한 에러.
+- `[features] metal`/`mkl` 유지(arctic 도 동일 XLM-R 경로라 그대로 동작).
+
+## 작업 B — Ollama embedding provider (신규)
+- 신규 크레이트 `kebab-embed-ollama` (또는 kebab-embed-local 내 모듈 — **새 크레이트 권장**, 의존 분리). `Embedder` trait 구현.
+- `reqwest::blocking` 으로 `POST {endpoint}/api/embed` `{model, input:[...]}` → `embeddings`. 배치(예: 48/req), fail-soft 재시도.
+- query/doc prefix 모델별(arctic: query 에 `query: `). 결과 **L2 normalize**(Ollama raw 반환 → 일관성 위해 정규화).
+- endpoint: `models.embedding.endpoint`(신규, 미설정 시 models.llm.endpoint fallback). model_version = `ollama:{model}`.
+
+## 작업 C — config + app 배선
+- `kebab-config`: `EmbeddingCfg.provider` 에 `"ollama"` 허용. 신규 `endpoint: Option<String>`(ollama 용). serde forward-compat 유지.
+- `kebab-app`: embedder 선택 분기(`embedder()`)에 candle 다중모델 + ollama provider 추가. facade(`*_with_config`) 통해 config 주입(facade rule 준수).
+- UI 크레이트는 kebab-app 만 touch(불변).
+
+## 결정 사항
+- **차원 1024 동일** → lancedb 테이블은 모델명 포함(`chunk_embeddings_{model}_{dim}`)이라 모델 전환 시 새 테이블, 충돌 없음.
+- **embedding_version cascade**: arctic 으로 전환 = embedding_version 변경 → 전체 재임베딩 필요(breaking). 기존 e5 KB 와 혼용 불가(명확). 기본값 e5 유지라 기존 사용자 무영향.
+- arctic **ko 파인튠(dragonkue)** 은 base(130) 로 충분 → 본 작업은 base. ko 는 후속 옵션(레지스트리에 추가만 하면 됨).
+- A(heading enrichment) 는 측정상 arctic 에서 악화 → **미적용**.
+
+## 검증 기준 (Acceptance)
+- `cargo clippy --workspace --all-targets -j 4 -- -D warnings` 통과.
+- `cargo test --workspace --no-fail-fast -j 1` 통과 — 기존 e5-candle/fastembed 테스트 회귀 0.
+- **correctness 핵심**: candle arctic 으로 임베딩한 테스트 문장(예: `query: 스택 자료구조` + 문서 `후입선출 자료구조`)이 **Ollama `snowflake-arctic-embed2` 임베딩과 코사인 > 0.99 일치**(Ollama 192.168.0.47 도달 가능 — pooling/prefix 정확성 정밀 검증, 130 재현 위험 차단). live Ollama 없으면 `#[ignore]` + 수동 절차 문서화.
+- ollama provider: mock 또는 live 로 dim 1024 정규화 벡터 반환 smoke.
+- config provider=`candle`+arctic / `ollama`+arctic 각각 올바른 embedder 로드.
+- 기본 provider=fastembed e5 동작 불변(스모크).
+
+## 도그푸딩 (별도, Mac Metal — 본 PR acceptance 아님)
+arctic 으로 namu 재임베딩 → `namu_golden_expanded.yaml` 로 recall@10 ≈ 130 재현 확인. CLAUDE.md §Dogfood trigger(embedder 모델 변경) 충족. 결과 HOTFIXES + release notes.
+
+## 문서 동기화 (같은 PR)
+- README Configuration: provider=candle/ollama + arctic 모델 + endpoint + Apple Silicon(metal) 안내.
+- docs/ARCHITECTURE: 임베딩 백엔드 그래프 + 신규 크레이트(kebab-embed-ollama) + 결정 표(arctic 채택 근거 측정 링크).
+- HANDOFF 1줄. tasks/HOTFIXES dated entry(측정 근거 + cascade).
+- Cargo.toml workspace members += kebab-embed-ollama, version minor bump.
+
+## 비범위
+- e5 KB 자동 마이그레이션(전환 = 수동 재임베딩, cascade 규칙대로).
+- dragonkue ko 파인튠(후속).
+- D(query-side)·C(reranker) 통합(별도 후속, 본 PR 은 임베더만).
--- a/docs/superpowers/specs/2026-06-03-ingest-log-improve-spec.md
+++ b/docs/superpowers/specs/2026-06-03-ingest-log-improve-spec.md
@@ -0,0 +1,60 @@
+# Spec: ingest 로그 개선 (파일명·phase·heartbeat·slowest 요약)
+
+**날짜**: 2026-06-03
+**유형**: feature (관측성/UX, additive wire)
+**근거**: arctic 도그푸딩 중 Obsidian 볼트(이미지/PDF 혼재 + OCR/caption on)에서 ingest 가 중간부터 느려졌는데, **TTY 진행바가 파일명·현재 phase·모델·경과시간을 안 보여줘** "멈춘 것처럼" 보였다. 원인(비전 모델 스와핑)을 로그만으로 파악 불가. v0.24.0 상세 진행 로깅의 후속 — 느린 phase(특히 이미지 OCR/caption)와 병목 파일을 가시화한다.
+
+## 현재 한계 (코드 근거)
+- `kebab-cli/src/progress.rs:145` — TTY 에서 AssetStarted 는 **위치만 갱신, 파일명 메시지 미설정**(의도적; 비-TTY 줄에만 파일명). → 인터랙티브 실행 시 현재 파일 안 보임.
+- 이미지 **OCR/caption 진행 이벤트 없음** — `PdfOcrStarted/Finished`(PDF 페이지)만 존재. 이미지 OCR/caption(gemma 비전, 느림)은 무이벤트 → 진행바 정지처럼 보임(`lib.rs` apply_ocr/apply_caption 호출 주변).
+- 한 asset 이 오래 걸려도 **경과시간 heartbeat 없음**(완료 후 `AssetTimings` ⏱ 한 번).
+- 병목 파일을 **사후 파악할 요약 없음**.
+
+## 목표 (사용자 결정: 1+2+3+4)
+1. **파일명**을 TTY 진행바 메시지에 표시.
+2. 느린 **phase(OCR/caption/embed) + 모델명** 실시간 표시.
+3. 현재 asset **경과시간 heartbeat**.
+4. 종료 시 **가장 오래 걸린 파일 top-N 요약**.
+
+## 작업
+
+### A. wire 이벤트 (additive, ingest_progress.v1)
+- **신규 `AssetPhase { idx, total, phase, model }`** — asset 이 느린 phase 진입 시 emit. `phase: &str` ∈ {`"ocr"`,`"caption"`,`"embed"`}; `model: Option<String>`(그 phase 를 수행하는 모델 — OCR/caption=비전 LLM 모델 id, embed=임베더 model_id). 짧은 phase(parse/chunk/store)는 emit 안 함(노이즈 방지).
+- **`AssetTimings` 확장**: `ocr_ms`, `caption_ms` 필드 추가(additive, 기본 0). 기존 parse/chunk/embed/store/expansion_ms 유지. → top-N 요약의 정확한 per-asset 총시간 계산 근거.
+- `PdfOcrStarted/Finished`(기존) 유지 — PDF 페이지 단위 진행은 이미 있음.
+- wire schema `docs/wire-schema/v1/ingest_progress.schema.json`: `asset_phase` kind + `phase`/`model` + `ocr_ms`/`caption_ms` 필드 문서화(additive, v1 유지).
+
+### B. emit 지점 (kebab-app)
+- `ingest_one_asset` / 이미지·미디어 경로(`apply_ocr`/`apply_caption` 호출 직전, `lib.rs:~1568/1586`): 각각 `AssetPhase{phase:"ocr"|"caption", model}` emit. 임베딩 루프 진입 시 `AssetPhase{phase:"embed", model:embedder.model_id}` emit(텍스트 asset 도 적용).
+- OCR/caption 소요를 측정해 `AssetTimings.ocr_ms`/`caption_ms` 채움.
+
+### C. CLI 렌더 (kebab-cli/src/progress.rs)
+1. **파일명**: AssetStarted TTY 핸들러에서 `bar.set_message(<path 축약>)`(현재 위치-only 주석 제거). 비-TTY 줄은 그대로.
+2. **phase+모델**: AssetPhase 수신 시 `bar.set_message("{path} · {phase}({model})…")`.
+3. **heartbeat**: AssetStarted 에서 현재 asset 시작 시각 기록 + steady-tick(예: 1s)으로 메시지 끝에 `(Ns)` 경과 갱신. asset 전환/완료 시 리셋.
+4. **slowest 요약**: AssetStarted(idx→path) + AssetTimings(idx→총ms=parse+chunk+embed+store+ocr+caption) 를 누적, `Completed` 수신 시 stderr 에 `⏱ 최장 소요 top-N`(기본 N=5) 표 출력. 비-TTY/quiet 에서도 요약은 출력(유용), `--json` 모드는 미출력(ndjson 오염 방지).
+
+### 결정 사항
+- 모두 **additive wire** → `ingest_progress.v1` 유지(major bump 없음). 신규 소비자는 `asset_phase` 부재 허용.
+- AssetPhase 는 **emit 스로틀 불필요**(asset·phase 당 1회, 빈도 낮음). PDF 페이지 OCR 은 기존 PdfOcrStarted 가 담당(페이지 많으면 그쪽 스로틀은 별도 — 본 spec 비범위).
+- top-N 의 N: 상수 5(후속에 config 화 가능, 본 spec 비범위).
+- `--quiet` 시 진행바·phase 메시지는 억제하되 **slowest 요약은 출력**(짧고 유용). `--json` 은 전부 ndjson 으로만.
+
+## 검증 기준
+- clippy 0 / 전체 test 통과(기존 진행 렌더 테스트 갱신 + 신규 이벤트 직렬화 테스트).
+- TTY 스모크: 이미지/PDF 포함 폴더 ingest 시 진행바에 **파일명 + OCR/caption/embed phase + 모델 + 경과초** 표시, 종료 시 **top-N 요약**.
+- 비-TTY: 기존 줄 로그 유지 + 종료 요약.
+- `--json`: `asset_phase`/확장 `asset_timings` ndjson 출력, 사람용 텍스트 미혼입.
+- wire schema 문서 동기화 + verbatim 일치(CI diff-check 있으면).
+
+## 도그푸딩 (별도)
+사용자 Obsidian 볼트(이미지/PDF + OCR on)로 재현 — 느린 구간에서 어떤 파일·phase·모델인지 즉시 보이는지, 종료 요약이 병목 파일을 짚는지 확인. HOTFIXES + release notes.
+
+## 문서 동기화 (같은 PR)
+- `docs/wire-schema/v1/ingest_progress.schema.json` (asset_phase, ocr_ms/caption_ms).
+- README(진행 표시 설명 있으면 갱신, 명령표 영향 없음), HANDOFF 1줄, tasks/HOTFIXES dated entry, Cargo.toml version minor bump.
+
+## 비범위
+- PDF 페이지 OCR 진행 스로틀/요약(기존 이벤트 유지).
+- 모델 스와핑 자체 해결(그건 Ollama 설정/OCR off — 본 작업은 가시화만).
+- top-N 의 config 화.
--- a/docs/superpowers/specs/2026-06-03-ocr-toggle-invalidation-spec.md
+++ b/docs/superpowers/specs/2026-06-03-ocr-toggle-invalidation-spec.md
@@ -0,0 +1,55 @@
+# Spec: ingest 출력에 영향 주는 모든 설정 변경 시 자동 재색인 (skip 무효화 일반화)
+
+**날짜**: 2026-06-03
+**유형**: bug fix (patch)
+**근거**: `[image.ocr]`/`[image.caption]` 를 off→색인→on 으로 바꿔도 증분 skip 이 이미지를 "Unchanged" 로 건너뛴다. 더 일반적으로, `try_skip_unchanged` 가 자산 내용(blake3)+`parser_version`+`chunker_version`+`embedding_version` 만 비교하는데, **ingest 산출물을 바꾸는 다른 설정들**(청킹 파라미터, OCR/caption, pdf.ocr, 코드 ingest 옵션)이 이 셋 중 어디에도 반영되지 않아 변경해도 재색인이 안 된다. 사용자 요구: **OCR/caption 뿐 아니라 ingest 출력에 영향 주는 모든 설정**이 같은 방식으로 동작(변경→영향 자산 자동 재색인). 결과 포맷·인터페이스·새 플래그 변화 없음(내부 skip 판정 정정) → **patch**.
+
+## 동작 사실 (코드 근거)
+- `try_skip_unchanged`(lib.rs:866)는 `get_document_by_workspace_path` 로 기존 doc 조회 후 `existing_doc.parser_version != current_parser_version`(line 959) 면 재색인(cascade). **조회는 workspace_path** 이므로 doc_id 파생과 무관 — 비교는 저장된 `parser_version` 필드 대 현재값.
+- 각 경로가 상수 parser_version 을 넘김: md `md-heading-v1`(351), image `image-meta-v1`(1532), pdf `pdf-text-v1`(2109), code 등. 청킹 파라미터(`target_tokens`/`overlap_tokens`/`respect_markdown_headings`)는 `chunker_version` 상수에 안 들어가 변경해도 재청킹 안 됨(동일 갭).
+
+## 설계: per-asset-type "ingest config signature" 를 effective parser_version 에 폴딩
+
+`try_skip_unchanged` 에 넘기는 `current_parser_version` 과 **persist 되는 doc 의 `parser_version` 필드**를, 그 자산 타입의 **ingest 산출물에 영향을 주는 설정 전체의 결정적 서명**을 포함한 composite 로 만든다. 두 값이 같은 함수에서 나오므로, 관련 설정이 바뀌면 다음 run 비교가 mismatch → **영향 받는 자산만** 자동 재색인. doc_id 는 path 조회라 기존대로(안정, orphan churn 회피).
+
+### 어떤 설정이 어느 자산에 영향 (서명 구성)
+공통 헬퍼 `ingest_config_signature(config, media_type) -> String`. **ingest 산출물에 영향 주는 것만** 포함(아래 외 search/rag/nli/ui/logging/storage/workspace 는 **제외** — 바뀌어도 재색인 안 함):
+
+- **공통(모든 타입)**: `[chunking]` target_tokens, overlap_tokens, respect_markdown_headings, chunker_version. (embedding model/dim 은 이미 `embedding_version` cascade 가 담당 — 서명에 중복 포함 불필요, 단 일관성 위해 포함해도 무방.)
+- **image**: + `[image.ocr]` enabled (+enabled 면 model), `[image.caption]` enabled (+enabled 면 prompt_template_version).
+- **pdf**: + `[pdf.ocr]` enabled (+enabled 면 model, always_on).
+- **code**: + `[ingest.code]` skip_generated_header, max_file_bytes, max_file_lines, extra_skip_globs, ast_chunk_max_lines, fallback_lines_per_chunk, fallback_lines_overlap.
+- **markdown**: 공통만.
+
+서명 형식: 결정적 문자열 또는 그 blake3-12. 예 `image-meta-v1|chunk:500:80:true|ocr:1:qwen2.5vl:3b|cap:1:caption-v1`. off/미적용 항목은 안정적 표현(빈값)으로 — 동일 설정 재실행은 서명 동일 → **불필요 재색인 0**.
+
+## 작업 (kebab-app)
+1. `ingest_config_signature(config, media_type)` 헬퍼 추가(위 매핑). 출력 결정적(필드 순서 고정, Vec 는 join).
+2. 각 ingest 경로에서 effective parser_version = `format!("{base}|{signature}")` 또는 base 를 서명으로 감싼 값으로:
+   - md(351), image(1532), pdf(2109), code 경로의 `*_parser_version` 계산을 composite 로.
+   - **persist 전 `canonical.parser_version` 을 동일 composite 로 override**(extractor 가 박은 상수 대신). skip-check 와 저장값이 같아야 함.
+3. doc_id: 변경 불필요(workspace_path 조회). composite 는 비교 필드에만.
+
+## 동작 / 호환
+- ingest 영향 설정(청킹/OCR/caption/pdf.ocr/code) 변경 또는 모델·prompt 변경 → effective parser_version 변화 → **영향 자산만** `--force-reingest` 없이 자동 재색인(+UPSERT/purge). 비영향 설정(search/rag/ui/log) 변경 → 재색인 0.
+- **업그레이드 1회 효과**: 기존 doc 의 저장 parser_version(상수)이 새 composite 와 달라 → 업그레이드 후 첫 ingest 에서 전 자산 1회 재색인(현재 설정대로). 마크다운/코드도 1회 재청킹되나 embedding 은 V012 캐시 히트라 재임베딩 비용 작음. (HOTFIXES/release notes 에 1회 재색인 명시.)
+- `--force-reingest` 는 전체 강제용으로 그대로 유지.
+
+## 검증 기준
+- clippy 0. `cargo test -p kebab-app -p kebab-parse-image -p kebab-parse-pdf -p kebab-parse-code -p kebab-chunk -j 8` 통과 (**전체 워크스페이스 `-j 1` 금지 — `-j 8`**).
+- 신규 테스트(자산 타입별):
+  - image.ocr off→on / caption off→on → 해당 이미지 재색인(skip 아님). off→off, on→on(동일) → skip 유지.
+  - pdf.ocr off→on → PDF 재색인. 동일 설정 → skip.
+  - chunking target_tokens 변경 → md/code/image/pdf 전부 재색인. 변경 없으면 skip.
+  - ingest.code 옵션 변경 → 코드 자산 재색인, 이미지/md 는 영향 받되 **공통(chunking) 변경 아니면 코드만** (code 전용 설정은 code 서명에만).
+  - search/rag/ui 설정 변경 → 재색인 0 (회귀 가드, 중요).
+  - 동일 config 재실행 → 전 자산 skip(불필요 재색인 0) — 회귀 가드.
+- 스모크: 이미지 ocr off 색인 → config ocr on → `kebab ingest`(force 없이) → 그 이미지만 재색인 확인.
+
+## 비범위
+- 새 config 키/CLI 플래그/wire(없음).
+- 서명에 max_pixels/languages/timeout 같은 *런타임 비-산출* 파라미터는 **제외**(산출물 불변 → 과도 무효화 회피). 포함 기준 = "그 값이 바뀌면 색인되는 chunk/embedding 내용이 달라지는가".
+- search/rag/nli/ui/logging/storage/workspace 설정(ingest 산출 무관) 제외.
+
+## 문서/버전
+- tasks/HOTFIXES dated entry(일반화 + 1회 재색인 안내). Cargo.toml **patch bump (0.26.1 → 0.26.2)**(+Cargo.lock). README/wire 변화 없음. HANDOFF 1줄(선택).
--- a/docs/superpowers/specs/2026-06-03-remove-doc-expansion-spec.md
+++ b/docs/superpowers/specs/2026-06-03-remove-doc-expansion-spec.md
@@ -0,0 +1,55 @@
+# Spec: doc-side expansion(별칭) 기능 제거
+
+**날짜**: 2026-06-03
+**유형**: 기능 제거 (refactor/removal)
+**근거**: `docs/superpowers/research/2026-06-03-expansion-cost-rethink-research.md` (Step 0/1 측정 + 딥리서치). 별칭 ROI 음수: cross-lingual 은 e5-large 단독으로 이미 완벽, 별칭 기여는 설명형 +2 그룹뿐인데 대가가 청크당 색인-시 LLM(살아있는 KB 에 지속 불가). 문헌(arXiv 2309.08541)도 "강한 검색기엔 expansion 해롭다" 확인.
+**design contract 영향**: design §(Phase 2 doc-side expansion) 에서 도입된 기능 제거 → `tasks/HOTFIXES.md` dated entry + 원 spec(`docs/superpowers/specs/2026-05-30-doc-side-expansion-design.md`)의 Risks/notes 에 제거 cross-link 1줄. design 본문은 별도 spec PR 이 아닌 본 PR 에서 "deprecated/removed" 주석만.
+
+## 목표
+색인-시 청크당 LLM 별칭 생성 + 별칭 검색 경로를 **완전히 제거**한다. 기본 동작 불변(별칭은 이미 default-off)이라 일반 사용자 체감 0. 코드/스키마/wire 표면을 정리해 유지보수 부담을 없앤다.
+
+## 제거 대상 (REMOVE)
+- `crates/kebab-app/src/expansion.rs` — 모듈 전체 (ExpansionGenerator, is_nav_boilerplate, parse_aliases, strip_list_marker).
+- `crates/kebab-app/src/lib.rs` — `pub mod expansion;`, ingest_one_asset 의 expansion 루프(별칭 생성·캐시 조회/저장·`alias_version_key`·`embed_aliases` 임베딩·alias sentinel 벡터 `{orig}#alias#N`), 관련 카운터(`alias_cache_hit/miss`, `alias_touch_keys`).
+- `crates/kebab-config/src/lib.rs` — `ExpansionCfg` 구조체 + `IngestCfg.expansion` 필드 + 기본값.
+- `crates/kebab-config/src/migrate.rs` — `[ingest.expansion]` 섹션 주석/마이그레이션 처리.
+- `crates/kebab-core/src/chunk.rs` — `Chunk.aliases: Option<String>` 필드 (+ 관련 serde default 테스트). **주의: `crates/kebab-core/src/metadata.rs` 의 `Metadata.aliases: Vec<String>` 는 문서 메타데이터(§3.6)로 무관 — 유지.**
+- `crates/kebab-search/src/lexical.rs` — `run_alias_query`, `merge_body_alias`, alias FTS 분기(`build_match_string_for_column(.., "aliases")`).
+- `crates/kebab-store-sqlite` — `chunk_aliases_fts` 테이블 + 트리거 + `chunks.aliases` 컬럼: **신규 forward 마이그레이션(V0XX)으로 DROP**. INSERT/SELECT 경로(`documents.rs` 의 aliases 컬럼 쓰기/읽기) 제거.
+- `crates/kebab-app/src/ingest_progress.rs` — `IngestEvent::ExpansionProgress` variant (+ 직렬화 테스트). **`AssetChunked`/`AssetTimings` 는 유지**(별칭과 무관, 청킹/타이밍 가시성).
+- `crates/kebab-cli/src/progress.rs` + `crates/kebab-tui/src/ingest_progress.rs` — ExpansionProgress 렌더(`별칭 확장 N/chunks`).
+- `crates/kebab-tui/src/inspect.rs` — chunk 별칭 표시(있으면).
+- derivation_cache 의 `"alias"` kind: 쓰기 경로 제거. 기존 행은 무해(읽지 않음), `kebab reset` 시 정리. kind enum 에서 alias 제거는 선택(read 호환 위해 남겨도 무방).
+
+## 유지 (KEEP — 제거 금지)
+- `Metadata.aliases` (문서 메타데이터, metadata.rs).
+- `AssetChunked`, `AssetTimings` wire 이벤트 + 렌더.
+- derivation_cache 의 `embedding` kind (V012 임베딩 캐시 — 별칭과 독립, 성능 핵심).
+- `chunks_fts`(본문 FTS) 전부.
+- `Chunk` 구조체를 생성하는 모든 곳(kebab-chunk/*, kebab-parse-*/*): `aliases: None` 리터럴은 필드 제거에 맞춰 **삭제만**(기능 변경 아님).
+
+## 결정 사항
+- **마이그레이션**: 신규 forward-only 마이그레이션으로 `chunk_aliases_fts`(+ 트리거)와 `chunks.aliases` 컬럼 DROP. SQLite 3.35+ `DROP COLUMN` 사용(번들 sqlite 확인). down 마이그레이션 불필요(refinery forward-only 관행 따름). 기존 KB: 별칭 default-off 라 대부분 빈 데이터 → 손실 없음. corpus_revision cascade 불필요(별칭은 검색 보조였을 뿐, 본문/임베딩 불변).
+- **wire schema**: `ingest_progress.v1` 에서 `expansion_progress` kind 제거. v0.24.0 에서 막 추가된 additive variant 라 소비자(agent/CLI)는 부재 허용 → major bump 불요. `docs/wire-schema/v1/ingest_progress.schema.json` 에서 해당 kind 정의 삭제 + 주석.
+- **버전**: workspace `version` patch/minor bump(별칭 제거 = surface 정리, breaking schema 아님 — 단 chunk_aliases_fts DROP 마이그레이션 포함이라 이전 binary 가 새 DB 열 때 영향 없음(컬럼 제거는 구 binary 의 SELECT 깨뜨릴 수 있으나 단일 사용자·forward-only 전제). minor bump 권장.
+- **config**: `[ingest.expansion]` 제거 후 기존 사용자 config.toml 에 해당 섹션이 있어도 serde forward-compat(unknown field ignore)로 무해. `kebab config migrate` 가 섹션 제거하도록 갱신(선택).
+
+## 문서 동기화 (같은 PR)
+- `tasks/HOTFIXES.md`: dated entry — 제거 근거(연구 링크) + 마이그레이션 + wire 변경.
+- `docs/superpowers/specs/2026-05-30-doc-side-expansion-design.md`: Risks/notes 에 "2026-06-03 제거됨, 본 spec 참조" 1줄.
+- `README.md` / `HANDOFF.md`: 별칭이 README 에 노출돼 있으면 제거(default-off 라 노출 없을 가능성). HANDOFF 한 줄.
+- `docs/wire-schema/v1/ingest_progress.schema.json`: expansion_progress 제거.
+- design 본문(frozen contract)에 Phase 2 별칭 기술이 있으면 "removed (HOTFIXES 2026-06-03)" 주석.
+
+## 검증 기준 (Acceptance)
+- `cargo clippy --workspace --all-targets -j 4 -- -D warnings` 통과.
+- `cargo test --workspace --no-fail-fast -j 1` 통과 — 별칭 전용 테스트(`tests/chunk_aliases.rs`, expansion.rs 테스트, lexical alias 테스트)는 삭제, 그 외 회귀 0.
+- 신규 마이그레이션 적용된 fresh KB 에 `chunk_aliases_fts`/`chunks.aliases` 부재 확인(`.schema`).
+- `kebab ingest`(별칭 config 없이) 정상 — AssetChunked/AssetTimings 진행 표시 유지, expansion_progress 미출력.
+- 기존 별칭 데이터가 있던 KB 도 마이그레이션 후 search/ask 정상(별칭 벡터는 무시/정리).
+- grep 잔존 0: `expansion::|ExpansionCfg|chunk_aliases|run_alias_query|merge_body_alias|ExpansionProgress|embed_aliases|is_nav_boilerplate|Chunk.*aliases`.
+
+## 비범위 (out of scope)
+- 별칭 대체 방법(heading enrichment / arctic-ko 임베더 / reranker / query-side) — 후속 별 작업(연구문서 §7 Layer A~D).
+- `Metadata.aliases`(문서 메타) 변경.
+- derivation_cache GC wiring.
--- a/docs/superpowers/specs/2026-06-04-rust-native-ocr-spec.md
+++ b/docs/superpowers/specs/2026-06-04-rust-native-ocr-spec.md
@@ -0,0 +1,192 @@
+# Spec: Rust 네이티브 OCR 엔진 (PP-OCRv5 ONNX, in-process)
+
+**날짜**: 2026-06-04
+**유형**: feature (minor) — 신규 OCR 엔진 + config 키 + 동작 변화
+**상태**: draft (self-review 대기)
+**contract_sections**: design §6 (parse/extract), §8 (deps), §9 (versioning cascade)
+
+## 동기
+
+현재 이미지/PDF OCR 은 Ollama Vision LLM(`gemma4:e4b` 8B) 1콜(`crates/kebab-parse-image/src/ocr.rs`, `OllamaVisionOcr`). 사용자 실측 문제:
+
+- 실제 이미지 한 장당 **~50초**(VLM 은 글자를 토큰 단위로 생성 → 조밀 페이지는 본질적으로 느림). 모델을 바꿔도(qwen2.5vl:3b GPU 20~28초) 사용자 허용치 미달.
+- 사용자 결정: **배치 ingest 용도 + Python 의존 불가 + Rust 내장**.
+
+### 근거 벤치 (2026-06-04, `/build/dogfood/logs/2026-06-04-ocr-model-bench.md`)
+
+| 방식 | 작은 이미지 | 초대형 1757×2644 | 정확도 | 비고 |
+|---|---|---|---|---|
+| gemma4:e4b 8B VLM (GPU) | 11초 | 43초 | 0.65~0.82 | 현재 |
+| qwen2.5vl:3b VLM (GPU) | 3.6초 | 20초 | 0.93 | 속도 미달 |
+| **PP-OCRv5 mobile ONNX, Rust (CPU)** | **0.05초** | **2.75초** | **0.976** | **PoC 검증됨** |
+
+VLM 은 생성 병목으로 탈락. **검출+인식형 전용 엔진(PP-OCRv5)을 ONNX 로 Rust in-process 실행**이 속도·정확도·한국어·단일바이너리 모두 만족. PoC: `oar-ocr` 0.6.3 + `ort` 로 위 수치 확인(오류는 띄어쓰기뿐, 한국어 오인식 0). PoC 코드/모델: `/build/cache/ocr-bench/{rust-poc,onnx}/`.
+
+## 핵심 설계 결정: oar-ocr 미채택, 핀 ort 위 직접 구현
+
+PoC 는 `oar-ocr` 0.6.3 으로 검증했으나 **프로덕션 의존성으로는 쓰지 않는다**. 이유(load-bearing):
+
+- kebab 은 `ort = "=2.0.0-rc.9"` 를 **의도적 핀**(workspace `Cargo.toml:195-204`): fastembed 4.9 의 ONNX Runtime+tokenizer 스택을 워크스페이스 단일 버전으로 유지. `ndarray = "0.16"` 도 동일.
+- `oar-ocr` 0.6.3 은 `ort 2.0.0-rc.12` + `ndarray 0.17` 요구. `ort` 는 `ort-sys` 가 onnxruntime 네이티브 라이브러리를 `links` 하므로 **두 버전 공존 불가** → oar-ocr 채택 시 ort/ndarray 를 bump 해야 하고, 이는 fastembed/kebab-nli/kebab-embed-candle 의 임베딩·NLI 스택을 흔든다(사용자 우선순위인 검색 품질 직결, [[search-quality-dogfood]]).
+
+**→ PaddleOCR 의 전/후처리(검출 DBNet postproc + 인식 CTC decode)를 kebab 의 기존 핀 `ort`(rc.9) 위에 직접 구현.** oar-ocr(Apache-2.0) 소스 + Python PaddleOCR 을 레퍼런스로. 공유 ort 라 새 네이티브 의존성 0, 임베딩 스택 무영향.
+
+### C2 검증 완료 (rc.9 스파이크, 2026-06-04)
+
+PoC 는 oar-ocr 경유 ort **rc.12** 로 돌았으므로, 핀 **rc.9** 가 paddle2onnx 산출 모델을 실제 로드/추론하는지 별도 검증함(`/build/cache/ocr-bench/rc9-spike/`). 결과 **PASS**:
+- `ort = "=2.0.0-rc.9"` + `ort-sys = "=2.0.0-rc.9"`(caret 으로 rc.12 끌려가는 것 방지 — kebab Cargo.lock 과 동일) + `ndarray 0.16` + feature `["ndarray","download-binaries"]` 로 빌드/링크/onnxruntime 다운로드 성공.
+- det: 입력 `"x"` → 출력 `[1,1,640,640]`(DBNet 확률맵). rec: 출력 `[1,40,11947]`(timestep×클래스; dict 11,945 + blank/특수 = 11,947, CTC 정합 확인).
+- `try_extract_tensor::<f32>()` 는 rc.9 에서 `ArrayViewD<f32>` 반환(rc.12 의 `(shape,&[T])` 와 다름) — 구현 시 유의.
+- **함의**: 핀 ort 유지(ort/ndarray bump 불필요)로 임베딩 스택 무영향 확정. opset 호환 OK. 출력 형태가 후처리 설계(det threshold→박스 / rec CTC)와 일치.
+
+### 추가 의존성
+
+- `image`(이미 허용), `ndarray`(workspace `=0.16`), `ort`(workspace `=2.0.0-rc.9`, **features `["ndarray","download-binaries"]`**).
+  - **download-binaries 필수**: `kebab-parse-image` 는 fastembed 빌드그래프에 없어, 단독 빌드(`cargo test -p kebab-parse-image`)시 onnxruntime 링크 위해 명시 필요. `kebab-nli/Cargo.toml:23` 의 동일 선례 주석 그대로 따름.
+  - `ort-sys` 가 caret 으로 rc.12 로 끌려가지 않도록 workspace 핀과 Cargo.lock 정합 확인.
+- `imageproc` — det 확률맵 연결요소/윤곽 추출. **단 min-area rotated-rect 는 imageproc 미제공 → rotating-calipers 직접 구현**.
+- DBNet unclip(다각형 확장): **`clipper2` 는 C++ FFI 가능성 → single-binary/pure-Rust 위배 위험. 우선 pure-Rust 다각형 offset 직접 구현 또는 검증된 pure-Rust crate.** (plan 에서 clipper2 가 C++ 링크인지 확인 후 택일.)
+
+## 파이프라인 (OnnxPaddleOcr)
+
+`crates/kebab-parse-image/src/` 에 신규 모듈. `OcrEngine` trait(`ocr.rs:54`) 구현:
+
+```rust
+pub trait OcrEngine: Send + Sync {
+    fn engine_name(&self) -> &'static str;       // "paddle-onnx"
+    fn engine_version(&self) -> String;          // "ppocrv5-mobile-kor-v1" (+model hash)
+    fn recognize(&self, image_bytes: &[u8], lang_hint: Option<&Lang>) -> Result<OcrText>;
+}
+```
+
+`recognize` 단계 (PoC 와 동일 알고리즘):
+
+1. **디코드+다운스케일**: `image` 로 디코드 → 긴변 `max_pixels`(기본 1600) 로 축소(기존 `OcrCfg.max_pixels` 재사용, qwen 과 달리 PP-OCRv5 는 원본도 안전하나 속도 위해 유지).
+2. **검출(det)**: BGR 정규화 → det ONNX(`PP-OCRv5_mobile_det`) → 확률맵 → threshold(0.3) 이진화 → 윤곽(imageproc) → min-area rect → unclip(ratio 1.5) → 텍스트 박스 N개.
+3. **인식(rec)**: 각 박스 crop+회전보정 → 48×W 리사이즈/정규화 → rec ONNX(`korean_PP-OCRv5_mobile_rec`) → CTC greedy decode(dict 11,945자, blank 처리) → 텍스트+score.
+4. **조립**: 박스를 reading-order(상→하, 좌→우) 정렬 → `OcrText { joined, regions: Vec<OcrRegion{bbox,text,confidence}>, engine, engine_version }`. **Ollama 와 달리 per-line bbox/confidence 제공**(`OcrRegion` 풍부화).
+
+배치: PoC 는 박스별 순차 rec. 성능 충분(초대형 2.75초)하나, rec 를 ort 배치 입력으로 묶으면 추가 향상 가능(plan 에서 측정 후 결정).
+
+### 단계별 분해 (M1 — 각 단계 골든벡터 단위테스트)
+
+후처리가 실제 난도. "쉽다"로 뭉뚱그리지 않고 **각 단계를 독립 테스트 가능 단위**로 쪼갠다. 각 단위는 oar-ocr/Python PaddleOCR 이 **같은 fixture** 에 내는 출력을 골든벡터로 박아 단계별 회귀(0.976 baseline 대비)를 잡는다:
+
+1. **전처리**(resize/pad/normalize): det 입력 정규화(mean/std, /255). 골든: 알려진 이미지→텐서 일부 값.
+2. **det 후처리**: 확률맵(`[1,1,H,W]`)→threshold(0.3)→연결요소(imageproc)→**min-area rotated-rect(rotating calipers 직접 구현)**→**unclip(다각형 offset, ratio 1.5)**→박스. 골든: 합성 이미지의 기대 박스 개수/대략 좌표.
+3. **crop+rectify**: 회전 박스→perspective/affine warp 로 수평 정렬(oar-ocr 가 공짜 제공하던 부분; 직접 구현 필요). 골든: 회전 텍스트 fixture.
+4. **rec 전처리+추론**: crop→48×W 정규화→rec ONNX→`[1,T,C]` logits.
+5. **CTC greedy decode**: argmax per timestep→연속중복 제거→blank(인덱스 0 또는 dict 길이 위치, **PaddleOCR 규약 정확 매칭**) 제거→dict 인덱스→char. dict 길이(11,945) vs rec 출력 클래스(11,947) 정합 + **인덱스 bounds-check**(잘못된 dict 길이/빈 줄 방어). 골든: 알려진 logit→문자열.
+6. **box reading-order**: 상→하, 좌→우 정렬(가로쓰기 전제; 세로/회전 페이지는 비범위).
+
+각 단계 divergence 를 end-to-end 가 아니라 단위에서 잡는다(M1 권고).
+
+## Config
+
+`OcrCfg`(`kebab-config/src/lib.rs:343`)에 `engine` 필드 **이미 존재**(기본 `"ollama-vision"`). 변경:
+
+- `engine` 값에 `"paddle-onnx"` 추가(문서화). 기본값은 **당장 바꾸지 않음**(default 변경은 별도 결정 — 아래 "기본 엔진" 참조).
+- 신규(선택) 필드: `det_model` / `rec_model` / `dict` 경로 override(미지정 시 자동 다운로드 캐시 경로). `score_thresh`(기본 0.3), `unclip_ratio`(기본 1.5) 는 고급 튜닝용(기본값 고정, 노출 최소).
+- `pdf.ocr` 도 동일 `engine` 분기 적용(같은 trait).
+
+### 모델 배포 — 결정 C: kebab 와 함께 번들 (HF 미사용, 사용자 확정 2026-06-04)
+
+제3자(HF) 호스팅 의존 제거. 변환본(det 4.7MB + korean rec 13MB + dict ≈ **17MB**)을 kebab 자체에 번들. **구체 기법은 plan 에서 택1**(모두 HF/외부 네트워크 0):
+
+- **C-1 바이너리 임베드(`include_bytes!`)**: 모델을 바이너리에 박음. 진정한 single-binary·완전 오프라인·재현성 100%. 비용: 릴리스 바이너리 +17MB, 그리고 dev/test 빌드마다 17MB 링크 부담 → **release feature(`bundled-ocr-models`) 게이트**로 dev 빌드 제외 가능. 로컬-first 철학 최적합.
+- **C-2 repo 벤더링**: `assets/paddleocr-onnx/`(git 또는 git-LFS) 에 두고 빌드 시 `OUT_DIR` 복사 또는 런타임 상대경로. 바이너리 비대 회피하나 배포 시 파일 동반 필요.
+- **C-3 gitea 릴리스 에셋 + 첫 실행 다운로드**: `gitea-release --asset` 로 첨부, 첫 실행 시 릴리스 URL 에서 `model_dir/paddleocr-onnx/` 로 받음. 바이너리 lean 하나 첫 실행 시 gitea 네트워크 필요(에어갭 불가) — 로컬-first 와 약간 상충.
+
+**권장 = C-1(release feature 게이트)**: 오프라인·재현성·single-binary 가 kebab 정체성과 가장 정합. plan 에서 빌드/링크 영향 측정 후 확정.
+
+- **무결성**: 임베드(C-1)면 빌드 시점 고정이라 별도 해시 불요(바이너리=정본). C-2/C-3 면 blake3 pin 필수.
+- **라이선스**: PP-OCRv5 가중치 Apache-2.0 — 재배포 가능. 번들에 NOTICE 동반.
+- **오프라인**: C-1 완전 오프라인. config override(`det_model`/`rec_model`/`dict`)로 로컬 모델 교체 항상 가능.
+
+## 엔진 선택 (kebab-app 팩토리)
+
+현재 `OllamaVisionOcr` 하드코딩(`kebab-app/src/lib.rs:360`(image), `379`(pdf)). 변경:
+
+```rust
+let ocr_engine: Option<Box<dyn OcrEngine>> = if cfg.image.ocr.enabled {
+    match cfg.image.ocr.engine.as_str() {
+        "ollama-vision" => Some(Box::new(OllamaVisionOcr::new(cfg)?)),
+        "paddle-onnx"   => Some(Box::new(OnnxPaddleOcr::new(cfg)?)),
+        other => bail!("unknown image.ocr.engine: {other}"),
+    }
+} else { None };
+```
+
+- `ImagePipeline.ocr_engine` 를 `Option<&'a dyn OcrEngine>` 로(현재 구체타입 `&OllamaVisionOcr`).
+- pdf 경로 동일. `apply_ocr`/`apply_ocr_to_pdf_pages` 는 이미 `&dyn OcrEngine` 받음 → 변경 불필요.
+- `OnnxPaddleOcr` 는 한 번 생성(모델 1회 로드) 후 ingest 전체에서 재사용(PoC 모델로드 58ms, 무시 가능).
+
+## 버전/재색인 cascade
+
+OCR 엔진 변경 시 **영향 자산 자동 재색인**되어야 함(v0.26.2 메커니즘). 현재 `ingest_config_signature`(`kebab-app/src/lib.rs:3036` 부근)의 image/pdf 브랜치는 `|ocr:1:{ocr.model}` 만 서명.
+
+**C3 (필수, 권장 아님)**: paddle-onnx 브랜치에서 `model`("gemma4:e4b" 기본) 은 **미사용** — 실제 모델 정체성은 det/rec/dict + engine_version 에 있음. 따라서:
+- 서명을 `|ocr:1:{engine}:{engine_version}` 로(엔진 + 모델/dict 식별자). `engine_version()`(spec 의 model+dict blake3 해시 포함, 라인 47)을 **반드시** 서명에 사용.
+- 이유: ① `engine="ollama-vision"→"paddle-onnx"` 전환 시 model 이 기본값 그대로면 `{model}` 만으론 서명 불변 → **재색인 안 됨**(silent stale index, v0.26.2 가 없애려던 바로 그 버그). ② 모델 재변환/dict 수정 시 engine_version 변화로 재색인 트리거.
+- 단위테스트(필수): (a) `ollama-vision`↔`paddle-onnx` 동일 model → 서명 다름. (b) 동일 engine, engine_version 다름 → 서명 다름. (c) 무관 설정(search 등) → 서명 불변.
+
+## 기본 엔진 (default) — 별도 결정
+
+본 spec 은 `paddle-onnx` 를 **선택 가능**하게만 한다. kebab 의 `image.ocr.engine` **기본값을 `paddle-onnx` 로 바꿀지**는 후속 결정:
+- 바꾸면: 신규 사용자/기본 동작 변화 + 모델 다운로드 기본화. 강력하나 영향 큼.
+- v1 은 기본 `ollama-vision` 유지, opt-in `paddle-onnx`. 도그푸딩 후 기본 전환을 별 PR 로. (사용자 본인 config 는 즉시 `paddle-onnx`.)
+
+## 에러 처리 (M3 — 명시 매트릭스)
+
+배치 ingest 가 미지의 사용자 스캔을 돈다. 각 케이스 동작 확정:
+
+| 케이스 | 동작 | 근거 |
+|---|---|---|
+| 모델 다운로드 실패 | 엔진 생성 시 **fail-fast**(Ollama 와 동일, `lib.rs:360`) | 색인 시작 전 차단 |
+| blake3 불일치 | fail-fast + 사유 | 무결성 |
+| 디코드 불가 이미지 | **자산 skip + provenance 노트**(ingest 중단 X) | 기존 `apply_ocr` "skip vs surface" 계약(`ocr.rs:75`) |
+| det 0 박스(빈 이미지 등) | **성공, `OcrText{joined:"", regions:[]}`**(에러 아님) | Ollama 빈줄 동작(`ocr.rs:290`) 미러 |
+| rec 빈 출력(한 박스) | 그 박스 skip, 나머지 진행 | |
+| 박스 폭증(노이즈 스캔) | **`max_boxes` 상한**(기본 예: 1000) 초과분 절단 + 로그 | 메모리/지연 cliff 방지 |
+| dict 길이 ≠ rec 클래스 | 생성 시 에러(정합 검증) | bounds-check |
+
+ort `Session` 은 생성 후 1회 로드·재사용. ingest 는 현재 직렬(`lib.rs:460`, rayon 없음)이라 동시접근 없음 — 단 `OcrEngine: Send+Sync` 유지(미래 병렬화 대비, rc.9 Session Send/Sync 확인은 plan).
+
+## 검증 기준
+
+- `cargo clippy --workspace --all-targets -j 8 -- -D warnings` 0.
+- `cargo test -p kebab-parse-image -p kebab-app -j 8` 통과(touched 크레이트; `kebab-parse-image` 단독 빌드가 download-binaries 로 링크되는지 포함).
+- 신규 단위테스트:
+  - 단계별 골든벡터(전처리/det후처리/CTC/박스정렬) — baseline 0.976 대비 단계 회귀 감지.
+  - OnnxPaddleOcr e2e: 합성 한/영 fixture → **CER ≤ 0.05**(=문자정확도 ≥95%), bbox>0. (단 합성 fixture 는 실코퍼스 회귀 미보장 → 도그푸딩 병행.)
+  - CTC decode: 알려진 logit→문자열(blank/중복 제거, bounds-check).
+  - 엔진 팩토리: `engine="paddle-onnx"`→OnnxPaddleOcr, 미지 값 에러.
+  - 서명(C3): 위 (a)(b)(c) 케이스.
+  - config override(`det_model`/`rec_model`/`dict`) 가 실제 사용됨 + **`--config` facade 스레딩**(CLAUDE.md facade rule, P3-5/P4-3 회귀 전례) — `OnnxPaddleOcr::new(cfg, …)` 가 explicit Config 받음.
+- 회귀 가드: `engine="ollama-vision"`(기본) 경로 — 팩토리 리팩터(구체타입→`&dyn`) 후에도 **출력 동일** 핀하는 테스트.
+- 스모크: `engine="paddle-onnx"` 이미지 ingest → OCR 텍스트 FTS5 hit. 큰 페이지 CPU <5초.
+- 도그푸딩: 사용자 실제 이미지/책 스캔 정확도·속도(HOTFIXES + release notes).
+
+## 의존성 규칙 (design §8)
+
+`kebab-parse-image` allowed: kebab-core, kebab-config, serde, image, tracing, thiserror(task p6-2). 추가: `ort`(workspace, features `["ndarray","download-binaries"]`), `ndarray`(workspace), `imageproc`. **clipper2 미추가**(C++ FFI 회피 — unclip pure-Rust 직접). **hf-hub 미추가**(결정 C: 모델 번들, 외부 다운로드 0). **금지 유지**: kebab-store-*/embed-*/llm-* 미import. UI 크레이트 영향 없음.
+
+## 비범위
+
+- **OCR 텍스트→임베딩 갭**(현재 OCR 은 FTS5 lexical 전용, 벡터 미포함). 사용자 "OCR 모델만 먼저" → 별도 작업.
+- **caption** 은 gemma 유지([[project_llm_default]]).
+- **GPU provider**(ort CUDA/CoreML): CPU 로 충분(2.75초). 후속 옵션.
+- **기본 엔진 전환**(default `paddle-onnx`): 도그푸딩 후 별 PR.
+- 다국어 dict 동적 전환(현재 korean dict = 한+영+숫자+기호 11,945자로 한/영 충분).
+
+## 잔여 노트 (critic minors)
+
+- **max_pixels(m1)**: 기존 `[256,4096]` clamp 은 VLM 프롬프트 비용 기준. det/rec 엔진은 비용이 latency 라 trade-off 다름. v1 은 기본 1600 **유지(의도적)** — PoC 에서 1600 대 원본 정확도 차 미미, 속도 이점. plan 에서 paddle-onnx 전용 기본 재검토 가능.
+- **config 마이그레이션(m3)**: 신규 키(`det_model` 등)는 serde default 로 forward-compat(기존 파일 무수정 로드). `kebab config migrate`(#198) 가 주석/순서 보존하며 신규 키 추가 — migration 핸들링 불필요(serde default), 단 init 템플릿에 신규 키 노출.
+- **per-region confidence(open q)**: Ollama 는 region confidence 상수 1.0, paddle-onnx 는 실제 score. `OcrRegion` 형태 불변이라 wire 호환(값만 의미있어짐) — release note 1줄.
+- **세로/회전 페이지**: 비범위(가로쓰기 reading-order 전제). 회전 박스 rectify 는 지원하나 페이지 전체 세로조판은 미지원 명시.
+
+## 버전/문서
+
+- feature(신규 engine 값 + 동작) → **minor bump**.
+- README(Configuration: `image.ocr.engine`, 모델 첫 다운로드 안내), docs/SMOKE(config 예시), HANDOFF 1줄, docs/ARCHITECTURE(새 OCR 백엔드 추가 시 그래프/결정), HOTFIXES dated entry(도그푸딩 evidence). wire schema 불변(OcrText 내부, `--json` 표면 동일).
--- a/docs/wire-schema/v1/ingest_progress.schema.json
+++ b/docs/wire-schema/v1/ingest_progress.schema.json
@@ -14,6 +14,9 @@
        "scan_completed",
        "asset_started",
        "asset_finished",
+        "asset_chunked",
+        "asset_phase",
+        "asset_timings",
        "embed_batch_started",
        "embed_batch_finished",
        "pdf_ocr_started",
@@ -33,7 +36,16 @@
      "enum": ["new", "updated", "skipped", "error"],
      "description": "asset_finished: per-asset outcome (mirrors `ingest_report.v1.items[].kind`)."
    },
-    "chunks":       { "type": "integer", "minimum": 0, "description": "asset_finished: chunk count produced for this asset." },
+    "chunks":       { "type": "integer", "minimum": 0, "description": "asset_finished / asset_chunked (v0.24.0): chunk count produced for this asset." },
+    "phase":        { "type": "string", "enum": ["ocr", "caption", "embed"], "description": "asset_phase (v0.26.1): the slow internal phase the asset just entered. Short phases (parse/chunk/store) are not emitted." },
+    "model":        { "type": ["string", "null"], "description": "asset_phase (v0.26.1): model performing the phase — vision LLM id for ocr/caption, embedder model_id for embed. null when the phase runs without a configured model." },
+    "parse_ms":     { "type": "integer", "minimum": 0, "description": "asset_timings (v0.24.0, additive): parse phase wall-clock (ms). Emitted by markdown / image / PDF paths." },
+    "chunk_ms":     { "type": "integer", "minimum": 0, "description": "asset_timings (v0.24.0, additive): chunk phase wall-clock (ms). Emitted by markdown / image / PDF paths." },
+    "expansion_ms": { "type": "integer", "minimum": 0, "description": "asset_timings (v0.24.0, additive): retained for wire compatibility but always 0 — doc-side expansion was removed (HOTFIXES 2026-06-03)." },
+    "embed_ms":     { "type": "integer", "minimum": 0, "description": "asset_timings (v0.24.0, additive): embed + vector phase wall-clock (ms) — embedding, vector upsert, and stale-vector purge." },
+    "store_ms":     { "type": "integer", "minimum": 0, "description": "asset_timings (v0.24.0, additive): SQLite persist phase wall-clock (ms) — put_asset/document/blocks/chunks only." },
+    "ocr_ms":       { "type": "integer", "minimum": 0, "description": "asset_timings (v0.26.1, additive, default 0): image/PDF OCR phase wall-clock (ms). 0 on the markdown path (no OCR)." },
+    "caption_ms":   { "type": "integer", "minimum": 0, "description": "asset_timings (v0.26.1, additive, default 0): image caption phase wall-clock (ms). 0 on markdown / PDF paths." },
    "n_chunks":     { "type": "integer", "minimum": 0, "description": "embed_batch_started / embed_batch_finished: chunks in this embedding batch." },
    "ms":           { "type": "integer", "minimum": 0, "description": "embed_batch_finished / pdf_ocr_finished: wall-clock duration (ms). pdf_ocr_finished skip path 의 의미는 mixed (DCTDecode 부재 시 0, engine 실패 시 latency-before-bail)." },
    "chars":        { "type": "integer", "minimum": 0, "description": "pdf_ocr_finished: char count of OCR result. Skip 시 0." },
--- a/migrations/V013__drop_chunk_aliases.sql
+++ b/migrations/V013__drop_chunk_aliases.sql
@@ -0,0 +1,25 @@
+-- V013__drop_chunk_aliases.sql — doc-side expansion(별칭) 채널 제거.
+--
+-- 근거: docs/superpowers/specs/2026-06-03-remove-doc-expansion-spec.md +
+-- tasks/HOTFIXES.md 2026-06-03 entry. V010 이 도입한 chunks.aliases 컬럼 +
+-- chunk_aliases_fts FTS5 테이블 + sync trigger 를 forward-only 로 DROP 한다.
+-- V010 자체는 과거 마이그레이션 freeze 규칙에 따라 무수정 — 본 마이그레이션이
+-- 덮어서 제거한다.
+--
+-- 별칭은 default-off 였으므로 대부분의 KB 는 빈 데이터 → 손실 없음. 본문/임베딩은
+-- 불변이라 corpus_revision cascade 불필요(spec §결정 사항) — in-process LRU 캐시는
+-- 프로세스별 휘발성이고 마이그레이션은 query 이전(store open 시)에 돌므로 bump 가
+-- 무의미. 따라서 본 마이그레이션은 순수 구조 변경(DROP)만 수행한다.
+-- body chunks_fts (chunks_ai/ad/au) 와 그 컬럼은 aliases 를 참조하지 않으므로
+-- DROP COLUMN 의 영향 없음. 번들 SQLite 3.45+ 가 ALTER TABLE DROP COLUMN 지원.
+
+-- 1. aliases 를 참조하는 trigger 를 먼저 제거 (DROP COLUMN 전제).
+DROP TRIGGER IF EXISTS chunk_aliases_ai;
+DROP TRIGGER IF EXISTS chunk_aliases_ad;
+DROP TRIGGER IF EXISTS chunk_aliases_au;
+
+-- 2. 별칭 전용 FTS5 테이블 제거 (shadow 테이블 chunk_aliases_fts_* 함께 정리됨).
+DROP TABLE IF EXISTS chunk_aliases_fts;
+
+-- 3. 본문 chunks 의 별칭 컬럼 제거.
+ALTER TABLE chunks DROP COLUMN aliases;
--- a/tasks/HOTFIXES.md
+++ b/tasks/HOTFIXES.md
@@ -14,6 +14,294 @@ historical contract that was implemented; this file accumulates the
 deltas so phase 5+ readers can find the live behavior without diffing
 git history.

+## 2026-06-04 — PP-OCRv5 ONNX Rust 네이티브 OCR 엔진 (v0.27.0)
+
+**무엇을 추가했나.** 이미지 OCR 에 두 번째 백엔드 `paddle-onnx` 를 붙였다. 기존 `ollama-vision`
+(원격 vision LM, 이미지당 ~50초)은 default 로 유지하고, `[image.ocr] engine = "paddle-onnx"` 로
+PP-OCRv5(검출 DBNet + 인식 CTC) ONNX 모델을 `ort`(=2.0.0-rc.9) 로 **in-process** 실행한다 —
+Python 런타임/원격 호출 없이 큰 페이지 CPU <4초. `OcrEngine` trait 의 두 번째 구현
+`OnnxPaddleOcr`(`crates/kebab-parse-image/src/paddle_onnx.rs`), 팩토리는
+`kebab-app::build_image_ocr_engine`/`build_pdf_ocr_engine` (`match engine`). 검출 후처리
+(min-area rect = rotating calipers, unclip = polygon offset)는 clipper2/OpenCV 없이 pure-Rust.
+
+**T11 e2e 에서 발견·수정한 핵심 버그 (unclip).** 첫 실측 CER 이 0.26(게이트 0.05) 으로 크게
+초과. 단계 골든(`crates/kebab-parse-image/tests/golden/`) 와 prediction dump 로 국소화한 결과
+`unclip_rect` 가 corner 를 centroid 기준 **방사(radial) 확장**하고 있었다. 텍스트 박스는
+wide/short(예 586×15)라 대각선이 거의 수평 → 방사 확장 시 corner 가 수평으로만 ~11px 움직이고
+**세로로는 거의 안 커져** 글자 윗/아랫부분이 잘렸다(ㄷ→ㄴ 로 `다`→`나`, ascender 손실).
+PaddleOCR pyclipper 처럼 **edge 별로 바깥으로 offset**(width·height 각각 2·distance 증가) 하도록
+rect 자체 (u,v) 축 기준 확장으로 재작성. 결과: mean gate CER **0.2585 → 0.0049**
+(clean_paragraph/korean_heavy/numbers_table/tech_terms = 0.0), PoC 0.024 baseline 보다 우수.
+큰 페이지 3.9초 < 5초 게이트. **교훈**: 회전 사각형 unclip 은 방사 확장이 아니라 polygon edge
+offset 이어야 한다.
+
+**Config / 서명 cascade.** `[image.ocr]` 에 `det_model`/`rec_model`/`dict`(Option, override) +
+`score_thresh`(0.3)/`unclip_ratio`(1.5)/`max_boxes`(1000) serde-default 필드 + `KEBAB_IMAGE_OCR_*`
+env 추가(기존 config 무수정 로드 — forward-compat). `ingest_config_signature` 의 image/pdf 브랜치를
+`|ocr:1:{model}` → `|ocr:1:{engine}:{engine_version}` 로 바꿔 engine 전환(ollama↔paddle) 또는
+모델 변경 시 영향 자산 자동 재색인. paddle engine_version 은 모델 3-asset blake3 를 **per-process
+1회만** 계산(triple 키 memo) — 자산마다 17MB 재해시 회피.
+
+**모델 배포.** ONNX 2개(det 4.7MB / rec 13MB) + dict + NOTICE 를 `crates/kebab-parse-image/
+assets/paddleocr-onnx/` 에 둔다(Git LFS). 테스트는 `KEBAB_IMAGE_OCR_MODEL_DIR`(기본 = 번들 dir)
+에서 로드, e2e(`tests/paddle_e2e.rs`)는 모델/fixture 부재 시 깨끗이 skip(CI green). 자세한 설계:
+spec/plan `docs/superpowers/{specs,plans}/2026-06-04-rust-native-ocr-*.md`.
+
+## 2026-06-03 — ingest 출력 영향 설정 변경 시 영향 자산 자동 재색인 (v0.26.2)
+
+**무엇이 깨졌나.** `[image.ocr]` / `[image.caption]` 를 off→색인→on 으로 바꿔도 증분
+skip(`try_skip_unchanged`, `kebab-app/src/lib.rs`)이 그 이미지를 "Unchanged" 로 건너뛰어
+재색인이 안 됐다. 더 일반적으로, skip 판정은 자산 내용(blake3) + `parser_version` +
+`chunker_version` + `embedding_version` 만 비교하는데, **ingest 산출물을 바꾸는 다른 설정들**
+(청킹 파라미터, OCR/caption, pdf.ocr, `[ingest.code]` 옵션)이 이 셋 중 어디에도 반영되지
+않아, 변경해도 재색인이 트리거되지 않았다. 사용자 요구: OCR/caption 뿐 아니라 **ingest 출력에
+영향 주는 모든 설정**이 변경되면 영향 자산이 자동 재색인.
+
+**무엇이 바뀌었나 (내부 skip 판정 정정 — 결과 포맷·CLI·wire 불변, patch).**
+
+- 신규 헬퍼 `ingest_config_signature(config, media_type) -> String` — 그 자산 타입의
+  **ingest 산출물에 영향 주는 설정만** 결정적으로 직렬화. 공통(전 타입): `[chunking]`
+  target_tokens/overlap_tokens/respect_markdown_headings/chunker_version. image: + ocr(enabled,
+  +model) + caption(enabled, +prompt_template_version). pdf: + pdf.ocr(enabled||always_on 이면
+  enabled/always_on/model). code: + `[ingest.code]` 7개 필드. markdown: 공통만.
+- 각 ingest 경로(md/image/pdf/code)의 effective parser_version 을
+  `format!("{base}|{signature}")` composite 로 만들어 (a) `try_skip_unchanged` 비교값,
+  (b) **persist 전 `canonical.parser_version` override** — 두 값이 같은 함수에서 나오므로
+  설정 변경 시 다음 run 비교가 mismatch → 영향 자산만 자동 재색인.
+- **doc_id 는 손대지 않음**: base parser_version(extractor 상수)으로 계속 파생 →
+  설정 변경에도 doc_id 안정(orphan churn 회피). composite 는 비교/저장 필드에만.
+- **제외(재색인 트리거 X)**: search/rag/nli/ui/logging/storage/workspace + 산출 무관
+  런타임 파라미터(max_pixels/languages/*_timeout_secs). "그 값이 바뀌면 색인되는
+  chunk/embedding 내용이 달라지는가" 기준. 과도 무효화 회피.
+- code 의 Tier-3 fallback 문서는 의도적으로 bare `"none-v1"` sentinel 유지(skip 의
+  `stored_is_tier3_fallback` bypass 가 정확히 그 문자열에 의존) — composite 는 정상 outcome 에만.
+
+**업그레이드 1회 효과.** 기존 doc 의 저장 parser_version(상수)이 새 composite 와 달라,
+업그레이드 후 첫 `kebab ingest` 에서 **전 자산이 현재 설정대로 1회 재색인**된다(force 불필요).
+마크다운/코드도 1회 재청킹되나 embedding 은 V012 derived-cache 히트라 재임베딩 비용은 작다.
+`--force-reingest` 는 전체 강제용으로 그대로.
+
+**도그푸딩 evidence (release 바이너리, Ollama down — OCR 호출은 Lenient 실패).**
+이미지 1장, `[image.ocr] enabled=false` 색인 → New=1. config 에서 `enabled=true` 로 변경 후
+`kebab ingest`(force 없이) → **Updated=1**(재색인, errors=0). 동일 config 재실행 → **Unchanged=1**
+(불필요 재색인 0). 저장된 parser_version =
+`image-meta-v1|chunk:500:80:true:md-heading-v1|ocr:1:gemma4:e4b|cap:0`(base 보존 + OCR on 반영).
+
+**테스트.** `kebab-app/src/lib.rs::ingest_config_signature_tests`(8 단위: 결정성, 청킹=전타입,
+이미지 ocr/caption 토글=이미지만, pdf.ocr=pdf만, code 옵션=코드만, search/rag/ui·런타임 파라미터
+불변 회귀가드) + `kebab-app/tests/config_invalidation.rs`(4 end-to-end: 동일 config=전 skip,
+청킹 변경=md+code 재색인, `[ingest.code]` 변경=코드만, search 변경=재색인 0). 기존 skip 테스트
+회귀 0(parser_version exact assert 는 base 접두사 비교로 갱신 — code_ingest_smoke/pdf_pipeline).
+
+spec/plan: `docs/superpowers/specs/2026-06-03-ocr-toggle-invalidation-spec.md` /
+`…/plans/2026-06-03-config-invalidation-plan.md`.
+
+## 2026-06-03 — ingest 진행 로그 개선: 파일명·phase·heartbeat·slowest 요약 (v0.26.1)
+
+**무엇을 왜 추가했나.** arctic 도그푸딩 중 이미지/PDF 혼재 + OCR/caption on 볼트에서
+ingest 가 중간부터 느려졌는데, TTY 진행바가 **파일명·현재 phase·모델·경과시간**을 안 보여
+"멈춘 것처럼" 보였다. 원인(비전 모델 스와핑)을 진행 표시만으로 파악 불가. v0.24.0 상세
+진행 로깅의 후속으로 느린 phase 와 병목 파일을 가시화했다. spec/plan:
+`docs/superpowers/specs/2026-06-03-ingest-log-improve-spec.md` / `…/plans/2026-06-03-ingest-log-improve-plan.md`.
+
+**무엇이 바뀌었나 (additive, `ingest_progress.v1` 유지 — major bump 없음).**
+
+- 신규 wire 이벤트 `asset_phase { idx, total, phase, model }` — asset 이 느린 phase
+  (`ocr` / `caption` / `embed`) 진입 시 1회 emit. `model` 은 그 phase 의 모델 id
+  (ocr/caption = 비전 LLM, embed = 임베더 model_id), 없으면 `null`. 짧은 phase
+  (parse/chunk/store) 는 노이즈 방지로 미emit.
+- `asset_timings` 에 `ocr_ms` / `caption_ms` 필드 추가 (serde `default` 0 → 구 소비자
+  호환). 이미지·PDF 경로도 이제 `asset_timings` 를 emit (이전엔 markdown 만) — slowest
+  요약이 비전-모델 병목을 정확히 집계.
+- CLI 렌더(`kebab-cli/src/progress.rs`): AssetStarted 시 진행바 메시지에 파일명(긴 path 는
+  말미 축약), AssetPhase 시 `{path} · {phase}({model})…`, steady-tick 1s 커스텀 키로
+  경과초 `(Ns)` 라이브 갱신, `Completed` 시 stderr 에 `⏱ 최장 소요 top-5` 표.
+  `--quiet` 여도 요약은 출력, `--json` 은 ndjson 만(사람텍스트 미혼입).
+
+**emit 지점.** `kebab-app/src/lib.rs` — 이미지 경로 `apply_ocr`/`apply_caption` 직전
+ ocr/caption 시간 측정, markdown/이미지/PDF 임베딩 루프 직전 `embed` phase, 각 경로
+`asset_timings` 에 측정값 채움. PDF `ocr_ms` 는 기존 page-OCR 총합 재사용.
+
+**알려진 한계.** code asset 경로는 진행 이벤트(AssetChunked/Timings) 무emit 이라 slowest
+요약에 미포함(기존 동작 유지, 비범위). top-N 의 N=5 상수(config 화 비범위). PDF 페이지
+OCR 진행은 기존 `pdf_ocr_started/finished` 가 담당(본 작업 비범위).
+
+**도그푸딩 (별도).** 사용자 Obsidian 볼트(이미지/PDF + OCR on) 재현 — 느린 구간의
+파일·phase·모델 즉시 가시 + 종료 요약이 병목 파일을 짚는지. release notes + 본 entry 갱신.
+
+## 2026-06-03 — arctic-embed-l-v2.0 임베더 통합 (candle + Ollama) (v0.26.0)
+
+**무엇을 왜 추가했나.** 별칭(doc-side expansion) 제거(v0.25.0) 후 설명형 query 의
+recall 보강책으로 `snowflake-arctic-embed-l-v2.0` 임베더를 두 백엔드로 통합했다.
+근거는 방법별 측정(`/build/dogfood/logs/2026-06-03-method-measurements.md`):
+arctic = recall@10 **130/132**, recall@50 **132/132**, **용어 무손실**(syn/abbr/en
+유지). e5-large 대비 +7, 색인 1회·per-query 0·LLM 0 = 살아있는 KB 에 지속 가능.
+별칭이 청크당 색인-시 LLM(나무위키 18문서 cold 2.5h)을 요구한 것과 대조.
+
+**무엇을 건드렸나.**
+- `kebab-embed-candle`: e5 하드코딩(`HF_MODEL`/`SUPPORTED_MODEL`/mean/`query:`+`passage:`)을
+  **모델 레지스트리**(`MODEL_REGISTRY`: `EmbedModelSpec { name, hf_repo, pooling, query_prefix, doc_prefix, dim, version_tag }`)로
+  일반화. e5(mean, `query:`/`passage:`) + arctic(**CLS**, `query:`/무접두어). pooling
+  은 모델별 분기(mean=attention-mask-weighted / CLS=`hidden[:,0,:]`), tokenize/forward/L2
+  공유. arctic pooling=CLS 는 HF `1_Pooling/config.json`(`pooling_mode_cls_token:true`)로
+  확인. `model_version` 은 arctic 일 때 `+arctic-cls` 태그(switch 시 embedding_version
+  cascade 트리거); e5 는 fastembed-e5 와의 호환(NUMA 드롭인) 위해 plain `config.version` 유지.
+- `kebab-embed-ollama` (신규 크레이트): `Embedder` 구현, `reqwest::blocking` POST
+  `/api/embed` `{model, input:[...]}` → `embeddings`. batch 48 + fail-soft 재시도 3,
+  결과 **L2 정규화**(Ollama raw 반환), dim 검증, query/doc prefix 모델 태그로 추론
+  (`arctic-embed`→`query:`/무접두어, `e5`→`query:`/`passage:`). `model_version=ollama:{model}`.
+  endpoint = `models.embedding.endpoint` ?? `models.llm.endpoint`.
+- `kebab-config`: `EmbeddingModelCfg.endpoint: Option<String>`(serde default, ollama용) +
+  `provider` 문서에 `ollama` 추가 + env `KEBAB_MODELS_EMBEDDING_ENDPOINT`.
+- `kebab-app::embedder()`: provider match 에 `ollama` 분기 추가(facade 경유).
+- workspace member += `kebab-embed-ollama`, version 0.25.0 → **0.26.0**(minor).
+
+**correctness 게이트.** candle arctic 임베딩이 측정에 쓴 Ollama `snowflake-arctic-embed2`
+임베딩과 일치해야 pooling/prefix 정확성(=recall 130 재현)이 보장된다. 검증:
+`kebab-embed-candle/tests/arctic_ollama_parity.rs`(`#[ignore]`, live Ollama 의존) 가
+candle arctic vs 우리 Ollama 어댑터로 같은 문장(설명형/약어/영문 포함, doc+query
+양 경로)을 임베딩해 per-sentence **코사인 > 0.99** 를 assert. 수동 실행 결과(코사인값)는
+릴리스 전 본 entry 에 기록.
+
+**수동 검증 결과** (2026-06-03 worker 실측, Ollama @192.168.0.47:11434
+`snowflake-arctic-embed2`): 8문장 × (doc+query) 16벡터 per-sentence 코사인
+**0.999984 ~ 0.999995**, `cosine_min = 0.999984` (게이트 0.99 대비 대폭 상회).
+설명형("후입선출 방식으로 동작하는 자료구조")·약어("SVM 은 support vector machine")·
+영문·한글 모두 일치. → candle arctic 의 CLS pooling + `query: ` prefix 가 Ollama 측정
+경로와 정확히 동일 = recall@10 130 재현 보장. Ollama raw 도 이미 L2-정규화(norm 1.0)라
+어댑터의 L2 정규화는 idempotent no-op. 로그: `/build/dogfood/logs/arctic-parity.log`,
+요약: `/tmp/arctic-result.md`.
+
+**종단 도그푸딩** (2026-06-03, kebab **v0.26.0** 바이너리, provider=ollama
+`snowflake-arctic-embed2` @192.168.0.47). Python 하니스가 아닌 **실제 kebab
+ingest→store→search 파이프라인**으로 검증: namu 코퍼스 997 docs / 23151 chunks
+fresh 색인(`config-arctic.toml`, kb-arctic, errors=0) → 확장 골든
+(`namu_golden_expanded.yaml`, 24그룹/132변형) hybrid k=50 eval
+(run_019e8c5788a374e098d85d84eb900e23). 결과: **recall@10 130/132 (0.985)**,
+**recall@50 132/132 (완벽)**, fully_consistent **22/24**(baseline e5 19/24 대비 +3),
+MisRanked 2 / Missing 0, mean_spread@10 0.083(e5 0.208 대비 대폭 개선). 종류별
+recall@10: abbr 7/7 · en 24/24 · ko 24/24 · syn 17/17 · para 23/24 · para2 18/18 ·
+para3 17/18 = **용어 무손실 + 설명형 거의 완벽**. e5 baseline(123/132) + 측정 하니스
+arctic(130) 와 종단 일치 — 측정→구현→실파이프라인 재현 삼중 확인. 잔존 MisRanked
+2개는 D(query-side) 후속 보강 대상. 결과 `/tmp/arctic_e2e_variants.json`,
+baseline 비교 `/build/dogfood/logs/2026-06-03-new-baseline-v025.md`.
+
+**호환성.** 기본 provider=fastembed e5 동작/벡터 불변(arctic 은 opt-in). dim 1024
+동일이나 LanceDB 테이블명에 모델명 포함(`chunk_embeddings_{model}_{dim}`)이라 충돌
+없음. e5 → arctic 전환 = `embedding_version` cascade(모델별 벡터 상이) → **재색인 필요**
+(기존 e5 KB 와 혼용 불가, 명확). A(heading enrichment)는 측정상 arctic 에서 악화 →
+미적용. spec: `docs/superpowers/specs/2026-06-03-arctic-embedder-spec.md`, plan: 동일
+디렉토리 `2026-06-03-arctic-embedder-plan.md`.
+
+## 2026-06-03 — doc-side expansion(별칭) 기능 완전 제거 (v0.25.0)
+
+**무엇을 왜 제거했나.** v0.21.0 (PR #195/#196) 에서 도입한 색인-시 청크당 LLM
+별칭 생성 + 별칭 검색 채널을 **완전히 제거**했다. 근거는 비용 재고 연구
+(`docs/superpowers/research/2026-06-03-expansion-cost-rethink-research.md`, Step 0/1
+측정 + 딥리서치): 별칭 ROI 가 음수였다 — cross-lingual 검색은 e5-large 임베더
+단독으로 이미 충분하고, 별칭의 실측 기여는 설명형 query +2 그룹(14/18→16/18)뿐인데,
+그 대가가 **청크당 색인-시 LLM 호출**(살아있는 KB 에 지속 불가능한 비용; 나무위키
+18문서 cold 2.5h)이었다. 문헌(arXiv 2309.08541)도 "강한 검색기에는 query/doc
+expansion 이 오히려 해롭다"를 확인. 별칭은 default-off 였으므로 일반 사용자 체감 0.
+
+**무엇이 제거됐나 (코드/스키마/wire).**
+- 코드: `kebab-app/src/expansion.rs` 모듈 전체, `ingest_one_asset` 의 별칭 생성·캐시·
+  임베딩 루프, `Chunk.aliases` 필드, `kebab-config` 의 `IngestExpansionCfg`
+  (`[ingest.expansion]` 섹션 + `KEBAB_INGEST_EXPANSION_*` env), `kebab-search` 의
+  `run_alias_query`/`merge_body_alias` alias lexical arm, alias sentinel 벡터 upsert
+  경로 + `alias_sentinel_ids_to_delete`.
+- wire: `ingest_progress.v1` 의 `expansion_progress` kind 제거 (v0.24.0 에서 막
+  추가된 additive variant 라 소비자는 부재 허용 → major bump 불요).
+  `asset_timings.expansion_ms` 필드는 **wire 호환 위해 유지하되 값 항상 0**.
+- 스키마: 신규 forward-only 마이그레이션 **V013** 이 `chunk_aliases_fts`(+ 트리거)
+  와 `chunks.aliases` 컬럼을 DROP. 과거 V010 은 freeze 무수정. 별칭 default-off 라
+  기존 KB 대부분 빈 데이터 → 손실 없음. corpus_revision bump (검색 캐시 무효화).
+
+**무엇을 유지했나 (제거 금지).** `Metadata.aliases`(문서 메타데이터 Vec, expansion
+과 무관), `AssetChunked`/`AssetTimings` wire 이벤트, derivation_cache 의 `embedding`
+kind(V012 임베딩 캐시 — 성능 핵심), `chunks_fts`(본문 FTS) 전부, `ALIAS_SUFFIX`/
+`strip_alias_suffix`(검색 시 기존 KB 의 잔존 별칭 벡터를 본문 chunk 로 graceful 매핑하는
+read-side 하위호환).
+
+**기존 KB 영향.** 별칭 벡터가 있던 KB 도 마이그레이션 후 search/ask 정상 — 잔존 별칭
+sentinel 벡터(`{chunk}#alias#N`)는 검색 시 `strip_alias_suffix` 로 본문 chunk 에
+매핑되거나 `kebab reset` 으로 정리된다. 본문/임베딩 불변이라 재색인 불요.
+
+**spec/plan.** `docs/superpowers/specs/2026-06-03-remove-doc-expansion-spec.md` +
+`docs/superpowers/plans/2026-06-03-remove-doc-expansion-plan.md`. 원 도입 spec
+`2026-05-30-doc-side-expansion-design.md` 에 제거 banner 추가.
+
+## 2026-06-02 — 상세 ingest 진행 로깅 (asset 내부 phase 가시화, v0.24.0)
+
+**무엇이 문제였나.** ingest 진행 이벤트가 asset(문서) 단위(`asset_started` /
+`asset_finished`)뿐이라 한 문서 내부의 parse / chunk / **expansion(별칭 LLM,
+청크당 순차 호출)** / embed / store 가 깜깜했다. expansion 은 청크당 ~1~4s
+(원격 GPU Ollama)이고 큰 문서는 청크 수백~천 개 → 그 한 문서에서 수십 분이
+걸리는데, 진행바는 `1/5150` 에 멈춘 듯 보여 사용자가 병목을 못 봤다.
+
+**무엇을 추가했나 (wire `ingest_progress.v1` additive, 호환 유지).**
+`IngestEvent` 에 세 변이 추가 — `#[serde(tag="kind")]` 라 신규 `kind` 추가는
+wire v1 호환:
+
+- `asset_chunked { idx, total, chunks }` — 청킹 직후(expansion/embed 전) 즉시
+  "이 문서가 N청크" 노출. markdown / image / pdf 세 경로 모두 emit.
+- `expansion_progress { idx, total, done, chunks }` — expansion 루프 중
+  **스로틀** 발신(매 25청크 또는 ≥1s, 종료 시 `done == chunks` 1프레임 더).
+  캐시 히트 청크도 `done` 에 포함(warm 재색인 fast-forward 가시화). 채널 폭주
+  방지 — 매 청크 emit 금지.
+- `asset_timings { idx, total, parse_ms, chunk_ms, expansion_ms, embed_ms,
+  store_ms }` — asset 처리 phase 별 소요시간. **markdown 경로만** emit
+  (image/pdf 는 phase shape 가 달라 생략; AssetChunked 만 emit).
+
+**설계 결정 — AssetTimings 이벤트 vs AssetFinished 필드.** IMPL_BRIEF §1 은
+`AssetFinished` 에 optional phase-timing 필드를, §2 는 대안으로 신규
+`AssetTimings` 이벤트를 제시(권장). 후자를 택함 — `AssetFinished` 는 호출부
+(`ingest_with_config_progress` 루프)에서 만들어지는데 timing 데이터는
+`ingest_one_asset` 내부에만 있어, 필드를 채우려면 `kebab_core::IngestItem`
+(wire-stable struct) 변경 또는 별도 plumbing 이 필요. `ingest_one_asset` 가
+`progress` 핸들을 이미 들고 있으므로 새 이벤트를 직접 emit 하는 쪽이 crate
+경계(kebab-core 불변)도 지키고 더 깔끔. `AssetFinished` 는 손대지 않음.
+
+**CLI 렌더(`kebab-cli` progress.rs).** `asset_chunked` → 진행바 message `→ N
+chunks`. `expansion_progress` → message `별칭 확장 {done}/{chunks}` (라이브).
+`asset_timings` → asset 종료 시 `⏱ parse Xs · chunk Ys · expand Zs · embed Ws
+· store Vs` 한 줄(`fmt_ms`: <1s 는 ms, ≥1s 는 1-decimal 초). `--json` 은
+`emit_json` 이 임의 이벤트를 직렬화하므로 자동 처리. `--quiet` 억제, 비-TTY
+expansion_progress 는 로그 폭주 방지로 기본 억제(진행바 message 로 커버).
+
+**검증.** `cargo clippy --workspace --all-targets -- -D warnings` exit 0,
+`cargo test -p kebab-app -p kebab-cli` exit 0. 단위 테스트: ingest_progress.rs
+(3 신규 변이 직렬화 `kind` 판별 + 순서 불변식 재작성), progress.rs(`fmt_ms` 단위
+전환), 통합(`--json`/human stderr 에 새 이벤트 흐름). 실동작 smoke: 2-문서 ingest
+의 `--json` 에 `asset_chunked`/`asset_timings` 출현 + human `⏱ parse…·store…` 라인
+확인. expansion 라이브 카운터는 원격 LLM 필요라 단위/통합으로 커버.
+
+**리뷰 반영.** (1) `store_ms` 경계 정정 — stale-vector orphan purge(LanceDB I/O)를
+`store_ms`(SQLite persist 전용)에서 빼 `embed_ms`(vector phase)로 이동. 진단
+정확도: store_ms 가 이제 SQLite put_* 만 의미(편집 재색인 시 920ms 가 실은 벡터
+삭제였던 오귀속 제거). purge 는 여전히 unconditional + 새 upsert 이전 실행 —
+기능 동등. (2) 최종 `expansion_progress` 프레임을 `done != last_done` 로 가드 —
+chunks 가 throttle 배수일 때의 중복 프레임 + chunks==0 시 0/0 프레임 제거.
+
+**알려진 한계.** image/pdf 경로는 phase timing 없음(AssetChunked 만).
+expansion_progress 비-TTY 억제는 의도적(필요 시 `--json` 으로 전량 관측).
+
+## 2026-06-02 — ingest 백엔드/디바이스 표시 + KB 이전 문서 (v0.23.1)
+
+**동기.** Metal 빌드가 실제로 GPU 를 쓰는지 사용자가 터미널에서 못 봐서 Activity
+Monitor 로 확인해야 했다(`select_device()` 의 device 로그는 kb.log 파일로만, 기본
+EnvFilter=warn 이라 `--verbose` 필요). 또 "어떤 DB 파일을 옮기나" 가 README 에
+구체적이지 않았다.
+
+**무엇.** (1) `kebab-cli` ingest 시작 시 임베딩 백엔드/모델/차원을 stderr 한 줄로
+표시(`임베딩 백엔드: candle (Metal/GPU 빌드) · 모델 …`), `--json`/`--quiet` 에선
+억제. Metal 표기는 `cfg!(feature="embed_metal")` 기반(빌드 사실); 확정 런타임
+디바이스는 여전히 kb.log(`candle device = …`). (2) README "외부 계산 + 로컬 검색"
+절에 복사 대상 2개(`kebab.sqlite`/`sqlite`, `lancedb/`/`vector_dir`)와 `[storage]`
+config 키·`models/`·`assets/` 복사 불필요·동일 버전/모델 조건·rsync 예시 추가.
+
+**범위.** CLI 출력 + 문서만. 동작·wire·schema·벡터 변경 없음. 버전 0.23.0 → 0.23.1.
+
 ## 2026-06-02 — candle Metal(Apple Silicon GPU) opt-in build feature

 **동기.** candle CPU 임베딩은 e5-large/512-tok 에서 ~1.5~1.9 s/chunk 로 느리고,