refactor(embedding): split embedding_engine.py along three seams (#173) - #175

Phase A — pure refactoring, zero feature change

Splits infrastructure/embedding_engine.py (506 lines on main) into
behaviour-preserving modules along the three real seams, so a second encoder
(the #169 download-free fallback) can later plug in as a second implementation
without touching the monolith. No fallback embedder is added here.

Closes #173

Seam design

Seam 1 — encoder provider interface (embedding_provider.py, 115 lines)

• EmbeddingProvider — a runtime_checkable Protocol: the text→vector
  interface the store, handlers, and hooks depend on, decoupled from which
  encoder produces the vectors. EmbeddingEngine is its first (neural)
  implementation and structurally satisfies it (asserted in a smoke check).
• _EmbeddingMathMixin — the stateless vector arithmetic shared by any provider
  (cache key, L2 normalize, cosine similarity, blob⇄list), kept as a mixin so
  EmbeddingEngine._cache_key / .similarity / .to_list stay on the class.

Seam 2 — model lifecycle state machine (embedding_model_lifecycle.py, 294 lines)

• ModelState enum makes the load state space explicit — this is exactly
  where a silent-degradation bug can hide:
  • UNINITIALIZED — no load attempted (lazy engine)
  • LOADED — a neural model is in hand
  • PACKAGE_ABSENT — import sentence_transformers failed (not installed)
  • MODEL_FILES_ABSENT — package present, weights not cached → download attempted
  • LOAD_RAISED — construction raised (corrupt cache / offline download failure)
• _EmbeddingLifecycleMixin owns device detection/resolution and the load path
  (_ensure_model decomposed into _construct_model / _download_model /
  _load_model, each ≤40 lines). Behaviour is preserved verbatim:
  PACKAGE_ABSENT → hash fallback + background install; MODEL_FILES_ABSENT →
  download; LOAD_RAISED → propagates.
• The revision-pin history (incident i7d3) and embedding_cache_dir move here.

Seam 3 — engine selection / composition root (embedding_factory.py, 52 lines)

• get_embedding_engine / reset_embedding_engine — the single place that reads
  EMBEDDING_DIM / EMBEDDING_DEVICE and assembles the process-wide encoder.
  Lazy internal import of EmbeddingEngine avoids an import cycle (verified in
  both import orders). embedding_engine re-exports these so every existing
  consumer import keeps working.

Concrete provider (embedding_engine.py, 245 lines) — the neural
EmbeddingEngine: encode path + LRU cache, composing the two mixins. Re-exports
DEFAULT_MODEL_REVISION, embedding_cache_dir, EmbeddingProvider,
ModelState, get_embedding_engine, reset_embedding_engine for import
compatibility.

Proof of behaviour preservation

• The existing embedding test suite (test_embedding_engine.py,
  test_embedding_cache.py, 56 tests) passes unchanged — no test edited.
• Full suite: 5299 passed, 9 skipped, 3 failed. The 3 failures are the
  documented pre-existing test: test_rebuild_profiles depends on live ~/.claude data — 3 failures reproduce on main #174 test_rebuild_profiles failures (depend on live
  ~/.claude data; reproduce identically on main) — unrelated to this PR.
• ruff check . and ruff format --check clean.
• File sizes: 115 / 294 / 52 / 245 — all ≤300; every method ≤40 lines.

One concern per commit (Fowler Extract Class ×2 + Move Function):

1. extract encoder-provider seam
2. extract model-lifecycle state machine
3. extract composition-root/selection seam

🤖 Generated with Claude Code