geny-executor 2.64.2__tar.gz → 2.64.4__tar.gz

{geny_executor-2.64.2 → geny_executor-2.64.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geny-executor
-Version: 2.64.2
+Version: 2.64.4
 Summary: Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API
 Project-URL: Homepage, https://github.com/CocoRoF/geny-executor
 Project-URL: Repository, https://github.com/CocoRoF/geny-executor

{geny_executor-2.64.2 → geny_executor-2.64.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "geny-executor"
-version = "2.64.2"
+version = "2.64.4"
 description = "Harness-engineered agent pipeline library with 21-stage dual-abstraction architecture, built on the Anthropic API"
 readme = "README.md"
 license = "Apache-2.0"

geny_executor-2.64.4/src/geny_executor/memory/_offload.py

@@ -0,0 +1,40 @@
+"""Dedicated worker pool for the memory subsystem's internal offloads.
+
+Why not ``asyncio.to_thread``
+-----------------------------
+``LoopAgnosticLock`` parks CONTENDED acquirers in the loop's default
+thread pool (``to_thread(lock.acquire)``) so the loop stays free. If a
+lock/gate HOLDER then runs its own work via ``to_thread`` too, holder and
+waiters compete for the same bounded pool — and on small machines
+(GitHub CI runners: 2 vCPUs → default pool ≈ 6 workers) a burst of
+waiters can fill every slot while the holder's work item sits queued
+behind them forever: a starvation deadlock. Observed live: the 2.64.3
+release pipeline hung twice in ``Verify tests pass`` on exactly this
+shape (10 concurrent deletes → 9 pooled waiters + 1 queued build),
+while 32-core dev machines sailed through.
+
+Running the subsystem's own offloads on this small dedicated pool makes
+holder progress independent of waiter pressure: the holder finishes,
+releases, and the pooled waiters drain. Two workers are plenty — these
+are serialized-by-lock jobs (vault scan, sidecar build), not a fan-out.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from functools import partial
+from typing import Any, Callable, TypeVar
+
+T = TypeVar("T")
+
+_MEM_EXECUTOR = ThreadPoolExecutor(max_workers=2, thread_name_prefix="mem-offload")
+
+
+async def run_offloaded(fn: Callable[..., T], *args: Any, **kwargs: Any) -> T:
+    """Run ``fn`` on the memory subsystem's dedicated worker pool."""
+    loop = asyncio.get_running_loop()
+    return await loop.run_in_executor(_MEM_EXECUTOR, partial(fn, *args, **kwargs))
+
+
+__all__ = ["run_offloaded"]

{geny_executor-2.64.2 → geny_executor-2.64.4}/src/geny_executor/memory/facts.py

@@ -36,7 +36,7 @@ import json
 import logging
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
-from typing import Any, Awaitable, Callable, Dict, List, Optional, Sequence, Tuple
+from typing import Any, Awaitable, Callable, Dict, List, Optional, Sequence, Set, Tuple
 
 from geny_executor.memory.rollup import _flatten_turn
 
@@ -238,6 +238,52 @@ _KIND_HEADINGS = {
 _IMPORTANCE_ORDER = {"critical": 0, "high": 1, "medium": 2, "low": 3}
 
 
+IDENTITY_CARD_KINDS = ("identity", "relationship")
+_PROHIBITION_MARKERS = (
+    "금지", "금기", "언급하지", "하지 마", "하지마", "never mention", "do not ", "don't ",
+)
+
+
+def render_identity_card(facts: Sequence[Fact], *, max_chars: int = 600) -> str:
+    """Ultra-compact identity card — the facts a persona must NEVER act
+    ignorant of: who the user is, how to address them, standing
+    prohibitions. Injected by the retriever as its own never-dropped
+    layer (L1.4), independent of the pinned-notes budget, because the
+    field failure mode was exactly these facts silently falling out of
+    context and the persona asking its owner's name mid-relationship.
+
+    Returns "" when nothing qualifies (caller may fall back to
+    identity-tagged pinned notes).
+    """
+    if max_chars <= 0:
+        return ""
+    active = [f for f in facts if f.status == "active"]
+    picked: List[Fact] = [f for f in active if f.kind in IDENTITY_CARD_KINDS]
+    picked += [
+        f
+        for f in active
+        if f.kind == "preference"
+        and any(m in f.statement for m in _PROHIBITION_MARKERS)
+    ]
+    if not picked:
+        return ""
+    seen: Set[str] = set()
+    lines = ["[핀 고정 사실 — 이미 아는 것으로 전제할 것. 다시 묻지 말 것.]"]
+    used = len(lines[0])
+    for f in picked:
+        stmt = f.statement.strip()
+        key = stmt.casefold()
+        if not stmt or key in seen:
+            continue
+        seen.add(key)
+        line = f"- {stmt}"
+        if used + len(line) + 1 > max_chars:
+            break
+        lines.append(line)
+        used += len(line) + 1
+    return "\n".join(lines) if len(lines) > 1 else ""
+
+
 def render_ledger_markdown(facts: Sequence[Fact]) -> str:
     """Deterministic human-readable rendering of the ACTIVE facts, grouped
     by kind, importance-ranked inside each group. This is what the

{geny_executor-2.64.2 → geny_executor-2.64.4}/src/geny_executor/memory/provider.py

@@ -1275,6 +1275,18 @@ class MemoryHooks:
     # `NotesHandle.load_pinned(category=...)` and stamped on retrieved
     # chunks as `metadata["host_layer"]`.
     pin_category: str = "critical"
+
+    # L1.4 Identity Card (2.64.4) — its OWN small budget, never dropped and
+    # independent of the pinned layer's ratio budgeting. Rendered from the
+    # fact ledger's identity/relationship/prohibition facts (fallback:
+    # identity-tagged pinned notes). 0 disables the layer.
+    identity_card_chars: int = 600
+
+    # Categories excluded from the retriever's AUTOMATIC keyword/vector
+    # layers (explicit memory_search tool calls are unaffected). Ambient
+    # buffers like screen observations can dominate a vault (observed: 59%
+    # of 6.2k notes) and drown real recall in noise.
+    search_exclude_categories: Tuple[str, ...] = ()
     # STM tail size injected as the L0 chunk regardless of query overlap.
     recent_turns: int = 6
     # When True, MemoryAwareRetriever returns only L0/L1/L1.5/L1.7 and

{geny_executor-2.64.2 → geny_executor-2.64.4}/src/geny_executor/memory/providers/file/index_store.py

@@ -12,6 +12,7 @@ the format that `_FilesystemNotesStore` writes.
 
 from __future__ import annotations
 
+import asyncio
 import json
 import os
 import tempfile
@@ -21,6 +22,7 @@ from pathlib import Path
 from typing import Any, Dict, Iterable, List, Optional, Set, Tuple
 
 from geny_executor.memory._locks import LoopAgnosticLock
+from geny_executor.memory._offload import run_offloaded
 from geny_executor.memory.provider import NoteGraph, NoteMeta, NoteOutline, NoteSummary
 from geny_executor.memory.providers.file.graph_edges import derive_graph_edges
 from geny_executor.memory.providers.file.layout import DirectoryLayout
@@ -78,6 +80,15 @@ class _FileIndexStore:
         # keyed by a cheap (filename, updated_at) signature of the vault.
         self._edges_sig: Optional[tuple] = None
         self._edges_cache: Optional[List[Dict[str, Any]]] = None
+        # Sidecar-refresh coalescing (2.64.3). A burst of writes/deletes
+        # (e.g. an observation prune sweep) used to run one full-vault
+        # payload build PER CHANGE, inline on the event loop — a 6k-note
+        # vault blocked the loop for tens of seconds and got the host
+        # watchdog-restarted mid-sweep. Changes now just mark their
+        # category dirty; whoever holds the gate services ALL accumulated
+        # marks with ONE snapshot + one worker-thread compute/write.
+        self._refresh_dirty: Set[str] = set()
+        self._refresh_gate = LoopAgnosticLock()
 
     def set_category_descriptions(self, descriptions: Dict[str, str]) -> None:
         """Late-set or replace the canonical description map. Called
@@ -100,9 +111,14 @@ class _FileIndexStore:
         the disk view consistent.
         """
         async with self._lock:
-            payload = await self._compute()
-        self._write_hierarchical_sidecars(payload, category=None)
-        return payload
+            notes = await self._notes.all()
+
+        def _work() -> Dict[str, Any]:
+            payload = self._payload_from_notes(notes)
+            self._write_hierarchical_sidecars(payload, category=None)
+            return payload
+
+        return await run_offloaded(_work)
 
     async def refresh_for_category(self, category: Optional[str]) -> None:
         """Incrementally refresh the on-disk sidecars affected by a
@@ -113,10 +129,36 @@ class _FileIndexStore:
 
         Other category shards are left untouched. Called after every
         ``NotesStore.write`` / ``update`` / ``delete``.
+
+        COALESCED + OFF-LOOP (2.64.3): concurrent callers mark their
+        category dirty and serialize on a gate — the gate holder services
+        every accumulated mark with ONE payload build, executed in a
+        worker thread so a large vault never stalls the event loop. A
+        burst of N deletes therefore costs ~2 builds, not N. Sidecars
+        are best-effort by contract; a torn read of a concurrently
+        mutated note is repaired by the next refresh.
         """
-        async with self._lock:
-            payload = await self._compute()
-        self._write_hierarchical_sidecars(payload, category=category)
+        self._refresh_dirty.add(category or "__all__")
+        async with self._refresh_gate:
+            if not self._refresh_dirty:
+                return  # a sibling gate-holder already serviced our mark
+            pending = set(self._refresh_dirty)
+            self._refresh_dirty.clear()
+            async with self._lock:
+                notes = await self._notes.all()
+
+            def _work() -> None:
+                payload = self._payload_from_notes(notes)
+                if "__all__" in pending:
+                    self._write_hierarchical_sidecars(payload, category=None)
+                    return
+                for cat in pending:
+                    self._write_hierarchical_sidecars(payload, category=cat)
+
+            # Dedicated pool: lock WAITERS park in the default to_thread pool
+            # (LoopAgnosticLock) — running the holder's build there too can
+            # starve-deadlock small pools (see memory/_offload.py).
+            await run_offloaded(_work)
 
     async def tag_counts(self) -> Dict[str, int]:
         payload = await self._cached_or_compute()
@@ -410,10 +452,16 @@ class _FileIndexStore:
         cache, so ``_compute`` is fast even on large vaults.
         """
         async with self._lock:
-            return await self._compute()
+            notes = await self._notes.all()
+        return await run_offloaded(self._payload_from_notes, notes)
 
     async def _compute(self) -> Dict[str, Any]:
         notes = await self._notes.all()
+        return self._payload_from_notes(notes)
+
+    def _payload_from_notes(self, notes) -> Dict[str, Any]:
+        """Pure payload build from a notes snapshot — sync by design so
+        heavy vaults can run it in a worker thread (2.64.3)."""
         files: Dict[str, Dict[str, Any]] = {}
         tag_map: Dict[str, List[str]] = {}
         link_graph: Dict[str, List[str]] = {}

{geny_executor-2.64.2 → geny_executor-2.64.4}/src/geny_executor/memory/providers/file/notes_store.py

@@ -19,6 +19,7 @@ from pathlib import Path
 from typing import Any, Awaitable, Callable, Dict, Iterable, List, Optional, Set, Tuple
 
 from geny_executor.memory._locks import LoopAgnosticLock
+from geny_executor.memory._offload import run_offloaded
 from geny_executor.memory.provider import (
     Importance,
     MemoryHooks,
@@ -403,13 +404,27 @@ class _FilesystemNotesStore(NotesHandle):
             modified = note.updated_at.isoformat() if note.updated_at else ""
             return (-note.importance.boost, "" if modified is None else "")  # placeholder
 
+        # Ordering (2.64.4): the fact LEDGER first — it is the designed
+        # always-inject note — then importance desc, then recency. Recency
+        # alone let a periodically-rewritten 5.6k evergreen note claim the
+        # front seat forever and crowd out identity/prohibition facts.
+        def _ledger_first(n: Note) -> int:
+            return 0 if n.ref.filename == "__facts__.md" else 1
+
         pool.sort(
             key=lambda n: (
+                _ledger_first(n),
                 -n.importance.boost,
                 -(n.updated_at.timestamp() if n.updated_at else 0.0),
             )
         )
 
+        # Per-note cap (2.64.4): one oversized note must never exhaust the
+        # whole budget. The old loop admitted the FIRST note whole even past
+        # max_chars — a 5.6k evergreen then starved every other pinned fact
+        # (and the downstream layer dropped the oversized result entirely).
+        per_note_cap = max(200, max_chars // 2)
+
         parts: List[str] = []
         used = 0
         for note in pool:
@@ -418,6 +433,8 @@ class _FilesystemNotesStore(NotesHandle):
                 continue
             header = f"## {note.title}" if note.title else ""
             piece = f"{header}\n{block}".strip() if header else block
+            if len(piece) > per_note_cap:
+                piece = piece[: per_note_cap - 12].rstrip() + "\n…(truncated)"
             cost = len(piece) + (2 if parts else 0)  # blank-line separator
             if used + cost > max_chars and parts:
                 break
@@ -466,7 +483,10 @@ class _FilesystemNotesStore(NotesHandle):
         # BLOCKS the host's event loop — health checks stop answering and the
         # process gets watchdog-killed mid-load. Run it in a worker thread;
         # callers already hold self._lock, so the swap below is single-flight.
-        cache = await asyncio.to_thread(self._scan_disk)
+        # Dedicated pool — the scan holder must never queue behind its own
+        # lock-waiters in the default to_thread pool (starvation deadlock on
+        # small machines; see memory/_offload.py).
+        cache = await run_offloaded(self._scan_disk)
         self._cache = cache
         self._explicit_links.clear()
         self._refresh_backlinks()

{geny_executor-2.64.2 → geny_executor-2.64.4}/src/geny_executor/memory/providers/file/vector_store.py

@@ -25,6 +25,8 @@ backend.
 
 from __future__ import annotations
 
+import hashlib
+
 import json
 import logging
 import math
@@ -133,10 +135,27 @@ class _FileVectorStore:
             return 0
         async with self._lock:
             await self._ensure_loaded()
-            texts = [text for _, text in items]
+            # Idempotent backfill (2.64.3): index_batch is the session-resume
+            # warm-up path — it used to re-embed EVERY note on every resume
+            # (6k-note vault ≈ minutes of embedding HTTP + real money, every
+            # 30-min idle-evict cycle). Rows persist a content sha, so only
+            # new/changed notes reach the embedder.
+            existing_sha = {
+                row.get("filename"): row.get("sha")
+                for row in self._rows
+                if row.get("sha")
+            }
+            todo = [
+                (ref, text)
+                for ref, text in items
+                if existing_sha.get(ref.filename) != _text_sha(text)
+            ]
+            if not todo:
+                return 0
+            texts = [text for _, text in todo]
             vectors = await self._embed_guarded(texts)
             added = 0
-            for (ref, text), vec in zip(items, vectors):
+            for (ref, text), vec in zip(todo, vectors):
                 self._validate_dim(vec)
                 removed = self._remove_by_filename(ref.filename)
                 self._vectors.append(vec)
@@ -423,6 +442,10 @@ class _FileVectorStore:
 # ── helpers ──────────────────────────────────────────────────────────
 
 
+def _text_sha(text: str) -> str:
+    return hashlib.sha1((text or "").encode("utf-8")).hexdigest()
+
+
 def _row_for(ref: NoteRef, text: str) -> Dict[str, Any]:
     return {
         "filename": ref.filename,
@@ -430,6 +453,10 @@ def _row_for(ref: NoteRef, text: str) -> Dict[str, Any]:
         "category": ref.category,
         "backend": ref.backend,
         "preview": (text or "")[:400],
+        # Content fingerprint — lets index_batch (session-resume backfill)
+        # skip re-embedding unchanged notes (2.64.3). Rows persisted before
+        # this field simply lack it and re-embed once, then carry it.
+        "sha": _text_sha(text),
     }
 
 

{geny_executor-2.64.2 → geny_executor-2.64.4}/src/geny_executor/memory/retriever.py

@@ -154,6 +154,17 @@ class MemoryAwareRetriever(MemoryRetriever):
         )
         _record("session_summary", before)
 
+        # ── L1.4: identity card — NEVER dropped, own budget ─────────
+        # The facts a persona must never act ignorant of (owner's name,
+        # honorific, standing prohibitions). Separate from the pinned layer
+        # because pinned is ratio-budgeted and was observed starving these
+        # exact facts out of context ("asked its owner's name").
+        before = total
+        total = await self._load_identity_card(
+            chunks, total, hooks, prefetched=pf.get("identity_card", _UNFETCHED)
+        )
+        _record("identity_card", before)
+
         # ── L1.5: pinned facts (always-inject, host-policy category) ──
         before = total
         total = await self._load_pinned_facts(
@@ -276,6 +287,9 @@ class MemoryAwareRetriever(MemoryRetriever):
 
         _add("summary", _fetch_summary)
 
+        if getattr(hooks, "identity_card_chars", 0) > 0:
+            _add("identity_card", lambda: self._build_identity_card(hooks))
+
         pinned_cap = _layer_cap(hooks, "pinned")
         if pinned_cap > 0:
             _add(
@@ -285,6 +299,22 @@ class MemoryAwareRetriever(MemoryRetriever):
                 ),
             )
 
+        # Ambient-noise exclusion for the AUTOMATIC search layers (explicit
+        # memory_search tool calls are unaffected): screen-observation style
+        # buffers can dominate a vault and drown real recall.
+        _excluded = set(getattr(hooks, "search_exclude_categories", ()) or ())
+
+        def _drop_excluded(hits):
+            if not _excluded or not hits:
+                return hits
+            kept = []
+            for h in hits:
+                cat = (getattr(h, "metadata", None) or {}).get("category")
+                if cat in _excluded:
+                    continue
+                kept.append(h)
+            return kept
+
         if hooks.slim_mode or hooks.always_render_vault_map:
             _add(
                 "vault_map",
@@ -302,11 +332,16 @@ class MemoryAwareRetriever(MemoryRetriever):
                     vec = self._provider.vector()
                     if vec is None:
                         return None
-                    return await vec.search(query, top_k=hooks.max_results)
+                    return _drop_excluded(await vec.search(query, top_k=hooks.max_results))
 
                 _add("vector", _fetch_vector)
 
-            _add("kw_notes", lambda: self._provider.notes().search(query, limit=hooks.max_results))
+            async def _fetch_kw_notes() -> Any:
+                return _drop_excluded(
+                    await self._provider.notes().search(query, limit=hooks.max_results)
+                )
+
+            _add("kw_notes", _fetch_kw_notes)
             _add("kw_ltm", lambda: self._provider.ltm().search(query, limit=hooks.max_results))
 
             async def _fetch_curated() -> Any:
@@ -442,6 +477,88 @@ class MemoryAwareRetriever(MemoryRetriever):
 
     # ── L1.5 ────────────────────────────────────────────────────────
 
+    async def _load_identity_card(
+        self,
+        chunks: List[MemoryChunk],
+        total: int,
+        hooks: MemoryHooks,
+        *,
+        prefetched: Any = _UNFETCHED,
+    ) -> int:
+        cap = getattr(hooks, "identity_card_chars", 0) or 0
+        if cap <= 0:
+            return total
+        if prefetched is not _UNFETCHED:
+            text = prefetched or ""
+        else:
+            text = await self._build_identity_card(hooks)
+        if not text:
+            return total
+        # By design this layer ignores the shared budget check: it is ≤ cap
+        # (small) and the whole point is that no budget pressure can evict it.
+        chunks.append(
+            MemoryChunk(
+                key="identity_card",
+                content=text,
+                source="identity_card",
+                relevance_score=3.0,
+                metadata={"layer": "identity_card", "char_count": len(text)},
+            )
+        )
+        return total + len(text)
+
+    async def _build_identity_card(self, hooks: MemoryHooks) -> str:
+        cap = getattr(hooks, "identity_card_chars", 0) or 0
+        if cap <= 0:
+            return ""
+        # Primary: the fact ledger's identity/relationship/prohibition rows.
+        try:
+            from geny_executor.memory.facts import FactLedger, render_identity_card
+
+            state = await FactLedger(self._provider).load()
+            text = render_identity_card(state.facts, max_chars=cap)
+            if text:
+                return text
+        except Exception:  # noqa: BLE001
+            logger.debug("memory_aware: identity card (ledger) failed", exc_info=True)
+        # Fallback: identity-tagged notes in the pinned category — covers the
+        # (observed) real world where the ledger is empty but the persona has
+        # pinned "user name / honorific / taboo" notes by hand.
+        try:
+            notes = self._provider.notes()
+            metas = await notes.list(category=hooks.pin_category)
+            tags_of_interest = {"identity", "호칭", "금지주제", "금기", "이름"}
+            picked = [
+                m
+                for m in metas
+                if tags_of_interest & {str(t) for t in (m.tags or [])}
+            ]
+            if not picked:
+                return ""
+            lines = ["[핀 고정 사실 — 이미 아는 것으로 전제할 것. 다시 묻지 말 것.]"]
+            used = len(lines[0])
+            seen: set = set()
+            for m in picked:
+                note = await notes.read(m.ref.filename)
+                if note is None or not (note.body or "").strip():
+                    continue
+                stmt = " ".join((note.body or "").split())
+                key = stmt.casefold()
+                if key in seen:
+                    continue
+                seen.add(key)
+                line = f"- {stmt}"
+                if len(line) > cap // 2:
+                    line = line[: cap // 2].rstrip() + "…"
+                if used + len(line) + 1 > cap:
+                    break
+                lines.append(line)
+                used += len(line) + 1
+            return "\n".join(lines) if len(lines) > 1 else ""
+        except Exception:  # noqa: BLE001
+            logger.debug("memory_aware: identity card (fallback) failed", exc_info=True)
+            return ""
+
     async def _load_pinned_facts(
         self,
         chunks: List[MemoryChunk],
@@ -466,8 +583,19 @@ class MemoryAwareRetriever(MemoryRetriever):
         if not content or not str(content).strip():
             return total
         body = str(content)
-        if total + len(body) > budget:
+        # TRUNCATE, never drop (2.64.4). Silently discarding the whole layer
+        # when it didn't fit meant identity/prohibition facts vanished exactly
+        # on the turns with the most conversation history — the persona then
+        # asked its owner's name mid-relationship. Pinned facts are the last
+        # layer that may disappear wholesale; a bounded slice always ships.
+        room = budget - total
+        if room <= 0:
             return total
+        if len(body) > room:
+            logger.debug(
+                "memory_aware: pinned facts truncated %d → %d chars", len(body), room
+            )
+            body = body[: max(0, room - 12)].rstrip() + "\n…(truncated)"
         chunks.append(
             MemoryChunk(
                 key="pinned_facts",

{geny_executor-2.64.2 → geny_executor-2.64.4}/src/geny_executor/memory/vector/qdrant_store.py

@@ -172,8 +172,53 @@ class QdrantVectorStore:
         return await self.index_document(ref, [DocumentChunk(text=text)])
 
     async def index_batch(self, items: Sequence[Tuple[NoteRef, str]]) -> int:
+        """Bulk (re)index — the session-resume warm-up path.
+
+        Idempotent since 2.64.3: points already carry ``content_sha1``, so
+        one payload-only scroll of the collection lets unchanged notes skip
+        the embedder entirely. Re-embedding the whole vault on every resume
+        (6k notes ≈ minutes of embedding HTTP, repeated every idle-evict
+        cycle) was pure waste. Scroll failure falls back to full indexing —
+        correctness never depends on the skip.
+        """
+        if not items:
+            return 0
+        existing: Dict[str, str] = {}
+        try:
+            await self._ensure_collection()
+            qdrant = self._get_qdrant()
+            offset = None
+            while True:
+                batch, offset = await qdrant.scroll(
+                    collection_name=self._collection,
+                    limit=1024,
+                    offset=offset,
+                    with_payload=["filename", "content_sha1", "chunk_index", "chunk_count"],
+                    with_vectors=False,
+                )
+                for point in batch or []:
+                    payload = getattr(point, "payload", None) or {}
+                    # Only single-chunk chunk-0 points represent a plain note
+                    # body — multi-chunk documents always re-index.
+                    if payload.get("chunk_index") == 0 and payload.get("chunk_count") == 1:
+                        fname = payload.get("filename")
+                        sha = payload.get("content_sha1")
+                        if fname and sha:
+                            existing[str(fname)] = str(sha)
+                if not offset:
+                    break
+        except Exception:  # noqa: BLE001 — skip-map is an optimization only
+            logger.debug("qdrant: sha scroll failed — full re-index", exc_info=True)
+            existing = {}
+
         total = 0
         for ref, text in items:
+            # Compare the sha of the UNMODIFIED text — index_document stores
+            # sha1(chunk.text) verbatim (strip() is only its emptiness test).
+            if (text or "").strip() and existing.get(ref.filename) == hashlib.sha1(
+                (text or "").encode("utf-8")
+            ).hexdigest():
+                continue
             total += await self.index(ref, text)
         return total