Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.
Python aicode-complexitycode-healthcode-intelligencecode-qualitydead-codedeveloper-toolsdocumentationgit-analyticsmcpopen-sourcepythonrefactoringstatic-analysistechnical-debt
fix(reindex): bound failed batch recovery (#2251)
Raghav Chamadiyafbfe6dec2a1c
diff --git a/packages/cli/src/repowise/cli/commands/reindex_cmd.py b/packages/cli/src/repowise/cli/commands/reindex_cmd.pyindex 30d26c652..ff964b132 100644--- a/packages/cli/src/repowise/cli/commands/reindex_cmd.py+++ b/packages/cli/src/repowise/cli/commands/reindex_cmd.py@@ -14,6 +14,9 @@ from repowise.cli.helpers import ()from repowise.cli.ui import BRAND_STYLE, OWL_SPINNER+_PROVIDER_FAILURE_CIRCUIT_SLICES = 2+_INPUT_TOO_LONG_RETRIES = 4+@click.command("reindex")@click.argument("path", required=False, default=None)@@ -23,7 +26,12 @@ from repowise.cli.ui import BRAND_STYLE, OWL_SPINNERdefault="auto",help="Embedder to use. 'auto' detects from env vars / config.",)[email protected]("--batch-size", type=int, default=32, help="Pages per embedding batch.")+ "--batch-size",+ type=click.IntRange(min=1),+ default=32,+ help="Pages per embedding batch.",+)def reindex_command(path: str | None, embedder: str, batch_size: int) -> None:"""Rebuild vector search index from existing wiki pages.@@ -131,6 +139,8 @@ async def _reindex(repo_path, embedder_name: str, batch_size: int) -> None:indexed = 0failed = 0below_floor = 0+ consecutive_provider_failures = 0+ provider_circuit_error: Exception | None = Nonewith Progress(SpinnerColumn(spinner_name=OWL_SPINNER, style=BRAND_STYLE),@@ -144,24 +154,36 @@ async def _reindex(repo_path, embedder_name: str, batch_size: int) -> None:warned = 0- async def _embed_slice(items: list[tuple[str, str, dict]]) -> None:- """Embed one slice batched; on failure retry per item.+ async def _embed_slice(items: list[tuple[str, str, dict]]) -> Exception | None:+ """Embed one slice with bounded recovery for input-specific failures.The batched call is the fast path (one embedder request per- chunk). A raised error falls back to per-item embedding so one- poison item can't sink its neighbours, and the indexed/failed- counters stay per-item accurate.+ chunk). The store reports exactly which internal chunks failed and+ whether embedding or persistence raised. Only an input-shaped HTTP+ error is isolated per item: retrying timeouts, rate limits, server+ errors, or failed writes one page at a time multiplies an outage+ into hours of duplicate work."""nonlocal indexed, failed, warnedtry:await vector_store.embed_batch(items)indexed += len(items)- return- except Exception:- pass- for page_id, text, meta in items:+ return None+ except Exception as exc:+ successful, retry_items, terminal = _batch_recovery_plan(exc, items)+ indexed += successful++ for (page_id, _text, _meta), stage, exc in terminal:+ failed += 1+ warned += 1+ if warned <= 3:+ console.print(+ f"[yellow] Warning: failed to embed {page_id} during {stage}: {exc}[/yellow]"+ )++ for page_id, text, meta in retry_items:try:- await vector_store.embed_and_upsert(page_id, text, meta)+ await _embed_one_with_input_recovery(vector_store, (page_id, text, meta))indexed += 1except Exception as exc:failed += 1@@ -170,6 +192,7 @@ async def _reindex(repo_path, embedder_name: str, batch_size: int) -> None:console.print(f"[yellow] Warning: failed to embed {page_id}: {exc}[/yellow]")+ return next((exc for _item, stage, exc in terminal if stage == "embedding"), None)# Pages — one batched embed per slice instead of one embedder# round-trip per page (a large wiki paid thousands of serial calls).@@ -206,8 +229,15 @@ async def _reindex(repo_path, embedder_name: str, batch_size: int) -> None:below_floor += 1continueitems.append(item)- await _embed_slice(items)+ provider_failure = await _embed_slice(items)progress.advance(task, advance=len(batch))+ if provider_failure is None:+ consecutive_provider_failures = 0+ else:+ consecutive_provider_failures += 1+ if consecutive_provider_failures >= _PROVIDER_FAILURE_CIRCUIT_SLICES:+ provider_circuit_error = provider_failure+ break# Decision records — embedded into the shared page store under the# decision: namespace, batched like the pages. Uses embed_batch@@ -217,9 +247,9 @@ async def _reindex(repo_path, embedder_name: str, batch_size: int) -> None:# that had just finished the pages, so a repo with no decisions ended# its reindex reading "Indexing decisions... 186/186" — 186 pages# reported as decisions that were never indexed.- if decisions:+ if decisions and provider_circuit_error is None:progress.update(task, description="Indexing decisions...")- for i in range(0, len(decisions), batch_size):+ for i in range(0, len(decisions) if provider_circuit_error is None else 0, batch_size):batch = decisions[i : i + batch_size]items = [item@@ -234,12 +264,25 @@ async def _reindex(repo_path, embedder_name: str, batch_size: int) -> None:)is not None]- await _embed_slice(items)+ provider_failure = await _embed_slice(items)progress.advance(task, advance=len(batch))+ if provider_failure is None:+ consecutive_provider_failures = 0+ else:+ consecutive_provider_failures += 1+ if consecutive_provider_failures >= _PROVIDER_FAILURE_CIRCUIT_SLICES:+ provider_circuit_error = provider_failure+ breakawait vector_store.close()await engine.dispose()+ if provider_circuit_error is not None:+ raise click.ClickException(+ "Embedding provider failed in two consecutive batches; stopped the reindex "+ f"before the outage multiplied across the corpus. Last error: {provider_circuit_error}"+ )+# Record the embedder we actually built the table with. Without this, a# repo indexed keyless keeps `embedder: mock` in config.yaml, and the next# `repowise update` builds a mock store, writes 8-wide vectors into the@@ -272,3 +315,89 @@ async def _reindex(repo_path, embedder_name: str, batch_size: int) -> None:# failure is visible in the exit status, not just in the printed count.if indexed == 0 and failed > 0:raise click.Abort()+++def _batch_recovery_plan(+ exc: Exception,+ items: list[tuple[str, str, dict]],+) -> tuple[+ int,+ list[tuple[str, str, dict]],+ list[tuple[tuple[str, str, dict], str, Exception]],+]:+ """Return successful, individually retryable, and terminal batch items."""++ from repowise.core.persistence.vector_store import BatchEmbeddingError++ if isinstance(exc, BatchEmbeddingError):+ retry_items: list[tuple[str, str, dict]] = []+ terminal: list[tuple[tuple[str, str, dict], str, Exception]] = []+ for failure in exc.failures:+ if failure.stage == "embedding" and _is_input_specific_error(failure.cause):+ retry_items.extend(failure.items)+ else:+ terminal.extend((item, failure.stage, failure.cause) for item in failure.items)+ return exc.successful_count, retry_items, terminal++ if _is_input_specific_error(exc):+ return 0, items, []+ return 0, [], [(item, "embedding", exc) for item in items]+++def _is_input_specific_error(exc: Exception) -> bool:+ """Whether splitting a failed provider request can plausibly isolate one input."""++ seen: set[int] = set()+ current: BaseException | None = exc+ while current is not None and id(current) not in seen:+ seen.add(id(current))+ if getattr(current, "status_code", None) in {400, 413, 422}:+ return True+ current = current.__cause__ or current.__context__+ return False+++async def _embed_one_with_input_recovery(+ vector_store: object,+ item: tuple[str, str, dict],+) -> None:+ """Retry one confirmed oversized input with bounded adaptive truncation."""++ from repowise.core.persistence.vector_store import cap_embed_text++ page_id, text, metadata = item+ candidate = cap_embed_text(page_id, text)+ for attempt in range(_INPUT_TOO_LONG_RETRIES + 1):+ try:+ await vector_store.embed_and_upsert(page_id, candidate, metadata) # type: ignore[attr-defined]+ return+ except Exception as exc:+ if (+ attempt >= _INPUT_TOO_LONG_RETRIES+ or len(candidate) <= 1+ or not _is_input_too_long_error(exc)+ ):+ raise+ candidate = candidate[: max(1, len(candidate) // 2)]+++def _is_input_too_long_error(exc: Exception) -> bool:+ """Whether a provider explicitly rejected one input for token length."""++ markers = (+ "maximum input length",+ "maximum context length",+ "input is too long",+ "too many tokens",+ "token limit",+ )+ seen: set[int] = set()+ current: BaseException | None = exc+ while current is not None and id(current) not in seen:+ seen.add(id(current))+ status = getattr(current, "status_code", None)+ message = str(current).lower()+ if status in {400, 413, 422} and any(marker in message for marker in markers):+ return True+ current = current.__cause__ or current.__context__+ return Falsediff --git a/packages/core/src/repowise/core/persistence/vector_store/__init__.py b/packages/core/src/repowise/core/persistence/vector_store/__init__.pyindex 9c7ec11a0..f83f059d6 100644--- a/packages/core/src/repowise/core/persistence/vector_store/__init__.py+++ b/packages/core/src/repowise/core/persistence/vector_store/__init__.py@@ -26,16 +26,26 @@ to avoid one embedding round-trip per page; the single-itemfrom __future__ import annotations-from ._base import VectorStore, cosine_similarity, embed_item+from ._base import (+ BatchChunkFailure,+ BatchEmbeddingError,+ VectorStore,+ cap_embed_text,+ cosine_similarity,+ embed_item,+)from .in_memory import InMemoryVectorStorefrom .lancedb_store import LanceDBVectorStorefrom .pgvector_store import PgVectorStore__all__ = [+ "BatchChunkFailure",+ "BatchEmbeddingError","InMemoryVectorStore","LanceDBVectorStore","PgVectorStore","VectorStore",+ "cap_embed_text","cosine_similarity","embed_item",]diff --git a/packages/core/src/repowise/core/persistence/vector_store/_base.py b/packages/core/src/repowise/core/persistence/vector_store/_base.pyindex 301177d80..acc6b31fb 100644--- a/packages/core/src/repowise/core/persistence/vector_store/_base.py+++ b/packages/core/src/repowise/core/persistence/vector_store/_base.py@@ -12,6 +12,8 @@ import loggingimport mathfrom abc import ABC, abstractmethodfrom collections.abc import Iterator+from dataclasses import dataclass+from typing import Literalfrom ..information_floor import count_page_denied_a_vector, meets_information_floorfrom ..search import SearchResult@@ -20,12 +22,49 @@ __all__ = ["EMBED_BATCH_MAX_ITEMS","EMBED_TEXT_MAX_CHARS","STORED_SNIPPET_CHARS",+ "BatchChunkFailure",+ "BatchEmbeddingError","VectorStore",+ "cap_embed_text","cosine_similarity","embed_item","iter_embed_chunks",]+EmbeddingItem = tuple[str, str, dict]+++@dataclass(frozen=True)+class BatchChunkFailure:+ """One request-sized chunk that a batch vector write could not persist."""++ items: tuple[EmbeddingItem, ...]+ stage: Literal["embedding", "persistence"]+ cause: Exception+++class BatchEmbeddingError(RuntimeError):+ """Partial batch failure with enough detail for bounded caller recovery.++ Stores used to raise only an aggregate count. A caller could not tell which+ chunks had already committed, so reindex retried the entire outer slice one+ item at a time. Under a provider timeout that multiplied one failed request+ into minutes of duplicate work.+ """++ def __init__(self, *, failures: list[BatchChunkFailure], total_items: int) -> None:+ self.failures = tuple(failures)+ self.total_items = total_items+ self.failed_items = tuple(item for failure in failures for item in failure.items)+ self.successful_count = total_items - len(self.failed_items)+ last = failures[-1]+ detail = f"{type(last.cause).__name__}: {last.cause}"+ super().__init__(+ f"embed_batch: {len(self.failed_items)}/{total_items} items failed during "+ f"{last.stage} ({detail})"+ )++logger = logging.getLogger(__name__)# One embedder call per chunk of this many items. OpenAI rejects embedding@@ -37,9 +76,14 @@ logger = logging.getLogger(__name__)# (a 16-page chunk measured at 0.6s against OpenAI).EMBED_BATCH_MAX_ITEMS = 16-# Per-input cap (~7.5k tokens): embedding models reject a single input past-# ~8,192 tokens, and one oversized page must not sink its whole chunk.-EMBED_TEXT_MAX_CHARS = 30_000+# Per-input cap sized conservatively for code-heavy text. The old 30,000-char+# cap assumed roughly four characters per token, but generated SCC pages in a+# real repository exceeded OpenAI's 8,192-token input limit even after that+# cut. Code and punctuation tokenize more densely than prose. Keep enough of+# each page for useful semantic coverage while leaving substantial headroom+# across providers and tokenizers; confirmed provider rejections can still be+# recovered by a bounded, smaller retry in the reindex command.+EMBED_TEXT_MAX_CHARS = 16_000# How much of a page's content a vector row keeps for its evidence snippet.#@@ -52,6 +96,28 @@ EMBED_TEXT_MAX_CHARS = 30_000STORED_SNIPPET_CHARS = 2_000+def cap_embed_text(page_id: str, text: str) -> str:+ """Return text bounded for one embedding input and report any loss.++ Both batch and single-item writers use this helper. Previously only the+ batch path applied the cap, so a page could succeed during generation but+ fail during ``doctor --repair`` or reindex's per-item isolation depending+ solely on which writer happened to touch it.+ """+ if len(text) <= EMBED_TEXT_MAX_CHARS:+ return text+ logger.error(+ # ``page_id`` is empty for the raw ``embed_texts`` path, which embeds+ # loose strings belonging to no page.+ "embed_text_truncated page_id=%s chars=%d chars_dropped=%d cap=%d",+ page_id,+ len(text),+ len(text) - EMBED_TEXT_MAX_CHARS,+ EMBED_TEXT_MAX_CHARS,+ )+ return text[:EMBED_TEXT_MAX_CHARS]++def embed_item(page_id: str,*,@@ -144,18 +210,7 @@ def iter_embed_chunks("""for start in range(0, len(items), EMBED_BATCH_MAX_ITEMS):chunk = items[start : start + EMBED_BATCH_MAX_ITEMS]- for page_id, text, _meta in chunk:- if len(text) > EMBED_TEXT_MAX_CHARS:- logger.error(- # ``page_id`` is empty for the raw ``embed_texts`` path,- # which embeds loose strings belonging to no page.- "embed_text_truncated page_id=%s chars=%d chars_dropped=%d cap=%d",- page_id,- len(text),- len(text) - EMBED_TEXT_MAX_CHARS,- EMBED_TEXT_MAX_CHARS,- )- yield chunk, [text[:EMBED_TEXT_MAX_CHARS] for _, text, _ in chunk]+ yield chunk, [cap_embed_text(page_id, text) for page_id, text, _ in chunk]def cosine_similarity(a: list[float], b: list[float]) -> float:diff --git a/packages/core/src/repowise/core/persistence/vector_store/in_memory.py b/packages/core/src/repowise/core/persistence/vector_store/in_memory.pyindex 559693417..bd95bc9ad 100644--- a/packages/core/src/repowise/core/persistence/vector_store/in_memory.py+++ b/packages/core/src/repowise/core/persistence/vector_store/in_memory.py@@ -5,7 +5,7 @@ from __future__ import annotationsfrom repowise.core.providers.embedding.base import Embedderfrom ..search import SearchResult-from ._base import VectorStore, cosine_similarity, iter_embed_chunks+from ._base import VectorStore, cap_embed_text, cosine_similarity, iter_embed_chunks__all__ = ["InMemoryVectorStore"]@@ -23,7 +23,7 @@ class InMemoryVectorStore(VectorStore):self._store: dict[str, tuple[list[float], dict]] = {}async def embed_and_upsert(self, page_id: str, text: str, metadata: dict) -> None:- vectors = await self._embedder.embed([text])+ vectors = await self._embedder.embed([cap_embed_text(page_id, text)])self._store[page_id] = (vectors[0], dict(metadata))async def embed_batch(self, items: list[tuple[str, str, dict]]) -> None:diff --git a/packages/core/src/repowise/core/persistence/vector_store/lancedb_store.py b/packages/core/src/repowise/core/persistence/vector_store/lancedb_store.pyindex 21d5ce742..cfaca4baa 100644--- a/packages/core/src/repowise/core/persistence/vector_store/lancedb_store.py+++ b/packages/core/src/repowise/core/persistence/vector_store/lancedb_store.py@@ -5,7 +5,14 @@ from __future__ import annotationsfrom repowise.core.providers.embedding.base import Embedderfrom ..search import _SNIPPET_LEN, SearchResult, snippet_around-from ._base import STORED_SNIPPET_CHARS, VectorStore, iter_embed_chunks+from ._base import (+ STORED_SNIPPET_CHARS,+ BatchChunkFailure,+ BatchEmbeddingError,+ VectorStore,+ cap_embed_text,+ iter_embed_chunks,+)__all__ = ["STORED_SNIPPET_CHARS", "LanceDBVectorStore"]@@ -189,7 +196,7 @@ class LanceDBVectorStore(VectorStore):async def embed_and_upsert(self, page_id: str, text: str, metadata: dict) -> None:await self._ensure_connected()- vectors = await self._embedder.embed([text])+ vectors = await self._embedder.embed([cap_embed_text(page_id, text)])vector = vectors[0]await self._ensure_table(vector)meta = {"content": text, **metadata}@@ -207,24 +214,24 @@ class LanceDBVectorStore(VectorStore):if not items:returnawait self._ensure_connected()- failed = 0- last_exc: Exception | None = None+ failures: list[BatchChunkFailure] = []for chunk, texts in iter_embed_chunks(items):try:vectors = await self._embedder.embed(texts)+ except Exception as exc: # isolate per provider request+ failures.append(BatchChunkFailure(tuple(chunk), "embedding", exc))+ continue+ try:await self._ensure_table(vectors[0])rows = [self._row(page_id, vector, {"content": text, **metadata})for (page_id, text, metadata), vector in zip(chunk, vectors, strict=True)]await self._upsert_rows(rows)- except Exception as exc: # isolate per chunk- failed += len(chunk)- last_exc = exc- if failed:- raise RuntimeError(- f"embed_batch: {failed}/{len(items)} items failed to embed"- ) from last_exc+ except Exception as exc: # preserve vectors' failure stage for callers+ failures.append(BatchChunkFailure(tuple(chunk), "persistence", exc))+ if failures:+ raise BatchEmbeddingError(failures=failures, total_items=len(items))async def _search_by_vector(self, q_vec: list[float], limit: int, query: str | None = Nonediff --git a/packages/core/src/repowise/core/persistence/vector_store/pgvector_store.py b/packages/core/src/repowise/core/persistence/vector_store/pgvector_store.pyindex 07ccc56cb..19a1c015d 100644--- a/packages/core/src/repowise/core/persistence/vector_store/pgvector_store.py+++ b/packages/core/src/repowise/core/persistence/vector_store/pgvector_store.py@@ -7,7 +7,7 @@ from typing import TYPE_CHECKINGfrom repowise.core.providers.embedding.base import Embedderfrom ..search import SearchResult-from ._base import VectorStore, iter_embed_chunks+from ._base import VectorStore, cap_embed_text, iter_embed_chunksif TYPE_CHECKING:from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker@@ -60,7 +60,7 @@ class PgVectorStore(VectorStore):self._embedder = embedderasync def embed_and_upsert(self, page_id: str, text: str, metadata: dict) -> None:- vectors = await self._embedder.embed([text])+ vectors = await self._embedder.embed([cap_embed_text(page_id, text)])vec_str = _encode(vectors[0])from sqlalchemy.sql import text as sa_textdiff --git a/tests/unit/cli/test_reindex_cmd.py b/tests/unit/cli/test_reindex_cmd.pyindex 0fd2b5aa8..fa4a0e41f 100644--- a/tests/unit/cli/test_reindex_cmd.py+++ b/tests/unit/cli/test_reindex_cmd.py@@ -107,10 +107,15 @@ async def test_reindex_aborts_when_every_item_failed(# Force the failure path: every item fails to embed. Patch the vector# store's embed_batch to raise, and give the store a page to process.class _FailingStore:+ batch_calls = 0+ single_calls = 0+async def embed_batch(self, items: list[Any]) -> None:+ self.batch_calls += 1raise RuntimeError("embedder down")async def embed_and_upsert(self, *args: Any, **kwargs: Any) -> None:+ self.single_calls += 1raise RuntimeError("embedder down")async def close(self) -> None:@@ -153,13 +158,117 @@ async def test_reindex_aborts_when_every_item_failed(return _FailingSession2monkeypatch.setattr("sqlalchemy.ext.asyncio.async_sessionmaker", _failing_sessionmaker)+ store = _FailingStore()monkeypatch.setattr("repowise.core.persistence.vector_store.LanceDBVectorStore",- lambda *a, **k: _FailingStore(),+ lambda *a, **k: store,)- with pytest.raises(click.Abort):+ with pytest.raises(click.ClickException, match="failed in two consecutive batches"):await reindex_cmd._reindex(tmp_path, "openai", batch_size=20)+ assert store.batch_calls == 2+ assert store.single_calls == 0+++def test_batch_recovery_retries_only_failed_input_chunk() -> None:+ from repowise.core.persistence.vector_store import BatchChunkFailure, BatchEmbeddingError++ class _BadRequest(Exception):+ status_code = 400++ items = [(f"p{i}", "text", {}) for i in range(32)]+ cause = _BadRequest("one input is invalid")+ exc = BatchEmbeddingError(+ failures=[BatchChunkFailure(tuple(items[16:]), "embedding", cause)],+ total_items=len(items),+ )++ successful, retry_items, terminal = reindex_cmd._batch_recovery_plan(exc, items)++ assert successful == 16+ assert retry_items == items[16:]+ assert terminal == []++[email protected]("status_code", [429, 500, 503])+def test_batch_recovery_does_not_fan_out_provider_failure(status_code: int) -> None:+ from repowise.core.persistence.vector_store import BatchChunkFailure, BatchEmbeddingError++ class _ProviderError(Exception):+ pass++ items = [(f"p{i}", "text", {}) for i in range(32)]+ cause = _ProviderError("provider unavailable")+ cause.status_code = status_code # type: ignore[attr-defined]+ exc = BatchEmbeddingError(+ failures=[BatchChunkFailure(tuple(items[:16]), "embedding", cause)],+ total_items=len(items),+ )++ successful, retry_items, terminal = reindex_cmd._batch_recovery_plan(exc, items)++ assert successful == 16+ assert retry_items == []+ assert [item[0][0] for item in terminal] == [f"p{i}" for i in range(16)]+++def test_batch_recovery_never_reembeds_persistence_failure() -> None:+ from repowise.core.persistence.vector_store import BatchChunkFailure, BatchEmbeddingError++ items = [(f"p{i}", "text", {}) for i in range(16)]+ cause = RuntimeError("lancedb write failed")+ exc = BatchEmbeddingError(+ failures=[BatchChunkFailure(tuple(items), "persistence", cause)],+ total_items=len(items),+ )++ successful, retry_items, terminal = reindex_cmd._batch_recovery_plan(exc, items)++ assert successful == 0+ assert retry_items == []+ assert len(terminal) == len(items)+ assert {stage for _item, stage, _exc in terminal} == {"persistence"}+++async def test_single_recovery_adaptively_truncates_confirmed_oversized_input() -> None:+ from repowise.core.persistence.vector_store._base import EMBED_TEXT_MAX_CHARS++ class _TooLong(Exception):+ status_code = 400++ class _Store:+ def __init__(self) -> None:+ self.text_lengths: list[int] = []++ async def embed_and_upsert(self, _page_id: str, text: str, _metadata: dict) -> None:+ self.text_lengths.append(len(text))+ if len(text) > EMBED_TEXT_MAX_CHARS // 2:+ raise _TooLong("maximum input length is 8192 tokens")++ store = _Store()+ await reindex_cmd._embed_one_with_input_recovery(+ store,+ ("oversized", "x" * (EMBED_TEXT_MAX_CHARS * 3), {}),+ )++ assert store.text_lengths == [EMBED_TEXT_MAX_CHARS, EMBED_TEXT_MAX_CHARS // 2]+++async def test_single_recovery_does_not_retry_other_bad_requests() -> None:+ class _BadRequest(Exception):+ status_code = 400++ class _Store:+ calls = 0++ async def embed_and_upsert(self, _page_id: str, _text: str, _metadata: dict) -> None:+ self.calls += 1+ raise _BadRequest("invalid dimensions")++ store = _Store()+ with pytest.raises(_BadRequest, match="invalid dimensions"):+ await reindex_cmd._embed_one_with_input_recovery(store, ("bad", "text", {}))+ assert store.calls == 1async def test_reindex_auto_honours_the_repo_pinned_embedder(diff --git a/tests/unit/persistence/test_vector_store.py b/tests/unit/persistence/test_vector_store.pyindex c0e47f66d..2987dca67 100644--- a/tests/unit/persistence/test_vector_store.py+++ b/tests/unit/persistence/test_vector_store.py@@ -461,19 +461,38 @@ async def test_in_memory_embed_batch_caps_text_length():assert len(emb.calls[0][0]) == EMBED_TEXT_MAX_CHARS+async def test_in_memory_single_upsert_caps_text_length():+ from repowise.core.persistence.vector_store import InMemoryVectorStore+ from repowise.core.persistence.vector_store._base import EMBED_TEXT_MAX_CHARS++ emb = _RecordingEmbedder()+ store = InMemoryVectorStore(emb)+ await store.embed_and_upsert(+ "p0", "x" * (EMBED_TEXT_MAX_CHARS + 5_000), {"target_path": "f0.py"}+ )+ assert len(emb.calls[0][0]) == EMBED_TEXT_MAX_CHARS++@pytest.mark.asyncioasync def test_lancedb_embed_batch_isolates_failed_chunk(tmp_path):# One failing chunk must not sink the rest of the level, but the loss# must surface as an error (the old code swallowed it entirely).pytest.importorskip("lancedb")- from repowise.core.persistence.vector_store import LanceDBVectorStore+ from repowise.core.persistence.vector_store import BatchEmbeddingError, LanceDBVectorStorefrom repowise.core.persistence.vector_store._base import EMBED_BATCH_MAX_ITEMSemb = _RecordingEmbedder(fail_on_call=2)store = LanceDBVectorStore(str(tmp_path / "lance"), emb)try:- with pytest.raises(RuntimeError, match="failed to embed"):+ with pytest.raises(BatchEmbeddingError, match="failed during embedding") as caught:await store.embed_batch(_items(EMBED_BATCH_MAX_ITEMS * 3))+ assert caught.value.successful_count == EMBED_BATCH_MAX_ITEMS * 2+ assert [item[0] for item in caught.value.failed_items] == [+ f"p{i}" for i in range(EMBED_BATCH_MAX_ITEMS, EMBED_BATCH_MAX_ITEMS * 2)+ ]+ assert len(caught.value.failures) == 1+ assert caught.value.failures[0].stage == "embedding"ids = await store.list_page_ids()# Chunks 1 and 3 persisted; only chunk 2 was lost.assert len(ids) == EMBED_BATCH_MAX_ITEMS * 2