henchman-ai 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

henchman/rag/concurrency.py

@@ -0,0 +1,206 @@
+"""Concurrency utilities for RAG system.
+
+This module provides locking and retry mechanisms to support
+multiple concurrent instances of henchman using the RAG system.
+"""
+
+from __future__ import annotations
+
+import fcntl
+import time
+from functools import wraps
+from pathlib import Path
+from typing import Optional, Callable, TypeVar, Any
+
+T = TypeVar('T')
+
+
+class LockTimeoutError(Exception):
+    """Exception raised when a lock cannot be acquired within timeout."""
+    
+    def __init__(self, lock_path: str | Path, timeout: float):
+        self.lock_path = str(lock_path)
+        self.timeout = timeout
+        super().__init__(
+            f"Could not acquire lock at {lock_path} within {timeout} seconds"
+        )
+
+
+class RagLock:
+    """File-based lock for RAG system operations.
+    
+    This lock uses advisory file locking (fcntl) to prevent multiple
+    instances from performing RAG indexing simultaneously.
+    
+    Attributes:
+        lock_path: Path to the lock file.
+        lock_file: File object used for locking (if acquired).
+        acquired: Whether the lock is currently held.
+    """
+    
+    def __init__(self, lock_path: Path | str):
+        """Initialize the lock.
+        
+        Args:
+            lock_path: Path where the lock file should be created.
+        """
+        self.lock_path = Path(lock_path)
+        self.lock_file: Optional[Any] = None
+        self._acquired = False
+    
+    @property
+    def acquired(self) -> bool:
+        """Check if the lock is currently acquired."""
+        return self._acquired
+    
+    def acquire(self, timeout: float = 5.0) -> bool:
+        """Attempt to acquire the lock.
+        
+        Args:
+            timeout: Maximum time to wait for lock (seconds).
+            
+        Returns:
+            True if lock was acquired, False if timeout was reached.
+        """
+        if self._acquired:
+            return True
+            
+        start_time = time.time()
+        
+        while time.time() - start_time < timeout:
+            try:
+                # Ensure parent directory exists
+                self.lock_path.parent.mkdir(parents=True, exist_ok=True)
+                
+                # Open file for writing (creates if doesn't exist)
+                self.lock_file = open(self.lock_path, 'w')
+                
+                # Try to acquire exclusive non-blocking lock
+                fcntl.flock(self.lock_file, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                
+                self._acquired = True
+                return True
+                
+            except (IOError, BlockingIOError):
+                # Lock is held by another process
+                if self.lock_file:
+                    self.lock_file.close()
+                    self.lock_file = None
+                
+                # Wait a bit before retrying
+                time.sleep(min(0.1, timeout / 10))
+        
+        # Timeout reached
+        return False
+    
+    def release(self) -> None:
+        """Release the lock if it is held."""
+        if self._acquired and self.lock_file:
+            try:
+                fcntl.flock(self.lock_file, fcntl.LOCK_UN)
+            finally:
+                self.lock_file.close()
+                self.lock_file = None
+                self._acquired = False
+    
+    def __enter__(self) -> RagLock:
+        """Context manager entry."""
+        if not self.acquire():
+            raise LockTimeoutError(self.lock_path, 5.0)
+        return self
+    
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Context manager exit."""
+        self.release()
+    
+    def __del__(self) -> None:
+        """Destructor to ensure lock is released."""
+        self.release()
+
+
+def acquire_rag_lock(lock_path: Path | str, timeout: float = 5.0) -> tuple[bool, Optional[RagLock]]:
+    """Convenience function to acquire a RAG lock.
+    
+    Args:
+        lock_path: Path to the lock file.
+        timeout: Maximum time to wait for lock (seconds).
+        
+    Returns:
+        Tuple of (success, lock) where success is True if lock
+        was acquired, and lock is the RagLock object if successful.
+    """
+    lock = RagLock(lock_path)
+    if lock.acquire(timeout):
+        return True, lock
+    return False, None
+
+
+def retry_on_locked(max_retries: int = 3, delay: float = 0.1) -> Callable[[Callable[..., T]], Callable[..., T]]:
+    """Decorator to retry operations on database lock errors.
+    
+    This decorator catches exceptions that indicate a database is
+    locked (e.g., SQLITE_BUSY) and retries the operation after a delay.
+    
+    Args:
+        max_retries: Maximum number of retry attempts.
+        delay: Initial delay between retries (seconds).
+        
+    Returns:
+        Decorated function that retries on lock errors.
+    """
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        @wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> T:
+            last_exception: Optional[Exception] = None
+            
+            for attempt in range(max_retries):
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    last_exception = e
+                    
+                    # Check if this is a lock-related error
+                    error_str = str(e).lower()
+                    is_lock_error = any(
+                        phrase in error_str
+                        for phrase in [
+                            "locked",
+                            "sqlite_busy",
+                            "resource temporarily unavailable",
+                            "database is locked",
+                        ]
+                    )
+                    
+                    if not is_lock_error or attempt == max_retries - 1:
+                        raise
+                    
+                    # Wait before retrying (exponential backoff)
+                    wait_time = delay * (2 ** attempt)
+                    time.sleep(min(wait_time, 1.0))  # Cap at 1 second
+            
+            # This should never be reached due to the raise above
+            raise last_exception  # type: ignore
+            
+        return wrapper
+    return decorator
+
+
+def is_lock_error(exception: Exception) -> bool:
+    """Check if an exception indicates a database lock error.
+    
+    Args:
+        exception: The exception to check.
+        
+    Returns:
+        True if the exception indicates a lock error.
+    """
+    error_str = str(exception).lower()
+    return any(
+        phrase in error_str
+        for phrase in [
+            "locked",
+            "sqlite_busy",
+            "resource temporarily unavailable",
+            "database is locked",
+        ]
+    )

henchman/rag/repo_id.py

@@ -12,7 +12,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from collections.abc import Sequence
+    pass  # No type-only imports currently needed
 
 
 def get_git_remote_url(git_root: Path) -> str | None:
@@ -90,11 +90,11 @@ def compute_repository_id(git_root: Path) -> str:
     else:
         # No remote, use path with git revision if available
         revision = get_git_revision(git_root)
-        if revision:
-            base = f"{git_root.resolve()}:{revision}"
-        else:
-            # Just use absolute path
-            base = str(git_root.resolve())
+        base = (
+            f"{git_root.resolve()}:{revision}"
+            if revision
+            else str(git_root.resolve())
+        )
 
     # Compute SHA256 hash
     return hashlib.sha256(base.encode()).hexdigest()[:16]  # 16 chars is enough
@@ -196,4 +196,4 @@ def migrate_old_index(git_root: Path, new_index_dir: Path) -> bool:
         except Exception:
             pass
 
-    return migrated
+    return migrated

henchman/rag/store.py

@@ -13,6 +13,8 @@ from typing import TYPE_CHECKING
 import chromadb
 from chromadb.config import Settings as ChromaSettings
 
+from henchman.rag.concurrency import retry_on_locked
+
 if TYPE_CHECKING:
     from henchman.rag.chunker import Chunk
     from henchman.rag.embedder import EmbeddingProvider
@@ -67,6 +69,7 @@ class VectorStore:
         persist_path: Path | str,
         embedder: EmbeddingProvider,
         collection_name: str = "code_chunks",
+        max_retries: int = 3,
     ) -> None:
         """Initialize the vector store.
 
@@ -74,7 +77,10 @@ class VectorStore:
             persist_path: Path to persist the vector store.
             embedder: Embedding provider for query embedding.
             collection_name: Name of the ChromaDB collection.
+            max_retries: Maximum retries for ChromaDB initialization.
         """
+        import time
+        
         self.persist_path = Path(persist_path)
         self.embedder = embedder
         self.collection_name = collection_name
@@ -82,18 +88,40 @@ class VectorStore:
         # Ensure persist directory exists
         self.persist_path.mkdir(parents=True, exist_ok=True)
 
-        # Initialize ChromaDB with persistence
-        self.client = chromadb.PersistentClient(
-            path=str(self.persist_path),
-            settings=ChromaSettings(anonymized_telemetry=False),
-        )
-
-        # Get or create collection
-        self.collection = self.client.get_or_create_collection(
-            name=collection_name,
-            metadata={"hnsw:space": "cosine"},  # Use cosine similarity
-        )
+        # Initialize ChromaDB with persistence and retry logic
+        last_error: Exception | None = None
+        for attempt in range(max_retries):
+            try:
+                self.client = chromadb.PersistentClient(
+                    path=str(self.persist_path),
+                    settings=ChromaSettings(anonymized_telemetry=False),
+                )
 
+                # Get or create collection
+                self.collection = self.client.get_or_create_collection(
+                    name=collection_name,
+                    metadata={"hnsw:space": "cosine"},  # Use cosine similarity
+                )
+                # Success - break out of retry loop
+                break
+            except Exception as e:
+                last_error = e
+                error_str = str(e).lower()
+                # Retry on HNSW/compactor errors (concurrent access issues)
+                if any(phrase in error_str for phrase in [
+                    "hnsw", "compactor", "segment", "backfill", "locked"
+                ]):
+                    if attempt < max_retries - 1:
+                        time.sleep(0.5 * (attempt + 1))  # Backoff
+                        continue
+                # Re-raise non-retryable errors immediately
+                raise
+        else:
+            # All retries exhausted
+            if last_error:
+                raise last_error
+
+    @retry_on_locked(max_retries=3, delay=0.1)
     def add_chunks(self, chunks: list[Chunk], embeddings: list[list[float]]) -> None:
         """Add chunks with their embeddings to the store.
 
@@ -119,6 +147,7 @@ class VectorStore:
             ],
         )
 
+    @retry_on_locked(max_retries=3, delay=0.1)
     def search(self, query: str, top_k: int = 5) -> list[SearchResult]:
         """Search for similar chunks.
 
@@ -168,6 +197,7 @@ class VectorStore:
 
         return search_results
 
+    @retry_on_locked(max_retries=3, delay=0.1)
     def delete_by_file(self, file_path: str) -> None:
         """Delete all chunks from a specific file.
 
@@ -183,6 +213,7 @@ class VectorStore:
         if results["ids"]:
             self.collection.delete(ids=results["ids"])
 
+    @retry_on_locked(max_retries=3, delay=0.1)
     def delete_by_ids(self, chunk_ids: list[str]) -> None:
         """Delete chunks by their IDs.
 
@@ -192,6 +223,7 @@ class VectorStore:
         if chunk_ids:
             self.collection.delete(ids=chunk_ids)
 
+    @retry_on_locked(max_retries=3, delay=0.1)
     def get_all_file_paths(self) -> set[str]:
         """Get all unique file paths in the store.
 
@@ -206,6 +238,7 @@ class VectorStore:
                     file_paths.add(str(metadata["file_path"]))
         return file_paths
 
+    @retry_on_locked(max_retries=3, delay=0.1)
     def count(self) -> int:
         """Get the total number of chunks in the store.
 
@@ -214,6 +247,7 @@ class VectorStore:
         """
         return self.collection.count()
 
+    @retry_on_locked(max_retries=3, delay=0.1)
     def clear(self) -> None:
         """Clear all chunks from the store."""
         # Delete and recreate the collection

henchman/rag/system.py

@@ -6,6 +6,7 @@ the RAG system in the CLI.
 
 from __future__ import annotations
 
+import asyncio
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -17,6 +18,7 @@ if TYPE_CHECKING:
     from henchman.rag.store import VectorStore
     from henchman.tools.builtins.rag_search import RagSearchTool
 
+from henchman.rag.concurrency import RagLock
 from henchman.rag.repo_id import (
     get_repository_index_dir,
     get_repository_manifest_path,
@@ -59,12 +61,14 @@ class RagSystem:
         self,
         git_root: Path,
         settings: RagSettings,
+        read_only: bool = False,
     ) -> None:
         """Initialize the RAG system.
 
         Args:
             git_root: Root directory of the git repository.
             settings: RAG settings from configuration.
+            read_only: If True, skip indexing (for concurrent instances).
         """
         from henchman.rag.chunker import TextChunker
         from henchman.rag.embedder import FastEmbedProvider
@@ -74,14 +78,29 @@ class RagSystem:
 
         self.git_root = git_root
         self.settings = settings
+        self.read_only = read_only
+        self.is_indexing = False
 
         # Get cache directory
         cache_dir = Path(settings.cache_dir) if settings.cache_dir else None
-        
+
         # Get repository-specific index directory
         self.index_dir = get_repository_index_dir(git_root, cache_dir)
         self.manifest_path = get_repository_manifest_path(git_root, cache_dir)
 
+        # Initialize lock for this RAG index
+        self._lock = RagLock(self.index_dir / ".rag.lock")
+        self._init_lock_held = False
+
+        # Acquire lock during initialization to prevent ChromaDB conflicts
+        # This is especially important when multiple instances start simultaneously
+        if not read_only:
+            if self._lock.acquire(timeout=10.0):
+                self._init_lock_held = True
+            else:
+                # Another instance is initializing, switch to read-only mode
+                self.read_only = True
+
         # Initialize embedder
         self._embedder = FastEmbedProvider(model_name=settings.embedding_model)
 
@@ -115,6 +134,12 @@ class RagSystem:
             top_k=settings.top_k,
         )
 
+        # Release lock after initialization if we held it
+        # (indexing will re-acquire it)
+        if self._init_lock_held:
+            self._lock.release()
+            self._init_lock_held = False
+
     @property
     def store(self) -> VectorStore:
         """Get the vector store."""
@@ -134,17 +159,73 @@ class RagSystem:
         self,
         console: Console | None = None,
         force: bool = False,
-    ) -> IndexStats:
-        """Run indexing operation.
+        skip_if_locked: bool = True,
+    ) -> IndexStats | None:
+        """Run indexing operation with locking.
 
         Args:
             console: Rich console for progress display.
             force: If True, force full reindex.
+            skip_if_locked: If True and lock cannot be acquired,
+                skip indexing and return None.
+
+        Returns:
+            Statistics about the indexing operation, or None if
+            indexing was skipped due to lock contention.
+        """
+        # Skip indexing if in read-only mode
+        if self.read_only:
+            if console:
+                console.print("[dim]RAG: Read-only mode, skipping indexing[/dim]")
+            return None
+        
+        # Try to acquire lock
+        if not self._lock.acquire(timeout=5.0):
+            if skip_if_locked:
+                if console:
+                    console.print(
+                        "[dim]RAG index is locked by another instance, "
+                        "skipping indexing[/dim]"
+                    )
+                return None
+            else:
+                # This would raise LockTimeoutError from the context manager
+                # if we were using `with self._lock:`
+                raise RuntimeError(
+                    f"Could not acquire RAG lock at {self._lock.lock_path}"
+                )
+        
+        self.is_indexing = True
+        try:
+            # Run indexing with lock held
+            return self._indexer.index(console=console, force=force)
+        finally:
+            # Always release the lock
+            self._lock.release()
+            self.is_indexing = False
+
+    async def index_async(
+        self,
+        console: Console | None = None,
+        force: bool = False,
+        skip_if_locked: bool = True,
+    ) -> IndexStats | None:
+        """Run indexing operation asynchronously in a separate thread.
+
+        Args:
+            console: Rich console for progress display.
+            force: If True, force full reindex.
+            skip_if_locked: If True and lock cannot be acquired,
+                skip indexing and return None.
 
         Returns:
             Statistics about the indexing operation.
         """
-        return self._indexer.index(console=console, force=force)
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self.index(console=console, force=force, skip_if_locked=skip_if_locked)
+        )
 
     def get_stats(self) -> IndexStats:
         """Get current index statistics.
@@ -166,6 +247,7 @@ def initialize_rag(
     settings: RagSettings,
     console: Console | None = None,
     git_root: Path | None = None,
+    index: bool = True,
 ) -> RagSystem | None:
     """Initialize the RAG system if in a git repository.
 
@@ -173,6 +255,7 @@ def initialize_rag(
         settings: RAG settings from configuration.
         console: Rich console for output.
         git_root: Optional pre-computed git root.
+        index: Whether to run indexing immediately (blocking).
 
     Returns:
         RagSystem instance if successful, None if not in a git repo
@@ -189,17 +272,20 @@ def initialize_rag(
         # Check for and migrate old index
         cache_dir = Path(settings.cache_dir) if settings.cache_dir else None
         new_index_dir = get_repository_index_dir(root, cache_dir)
-        
+
         migrated = migrate_old_index(root, new_index_dir)
         if migrated and console:
             console.print(
                 "[dim]Migrated RAG index from project directory to "
-                f"~/.henchman/rag_indices/[/dim]"
+                "~/.henchman/rag_indices/[/dim]"
             )
 
         rag_system = RagSystem(git_root=root, settings=settings)
 
-        # Run indexing
+        if not index:
+            return rag_system
+
+        # Run indexing (blocking)
         stats = rag_system.index(console=console)
 
         # Show summary

henchman/utils/compaction.py

@@ -259,13 +259,14 @@ class ContextCompactor:
             )
             protected_tokens = TokenCounter.count_messages(protected_msgs)
 
-        # Group unprotected messages into atomic sequences
-        sequences = self._group_into_sequences(unprotected_msgs)
-
         # Separate system messages (always kept)
         system_msgs = [msg for msg in unprotected_msgs if msg.role == "system"]
         system_tokens = TokenCounter.count_messages(system_msgs)
 
+        # Group non-system unprotected messages into atomic sequences
+        non_system_unprotected = [msg for msg in unprotected_msgs if msg.role != "system"]
+        sequences = self._group_into_sequences(non_system_unprotected)
+
         # Calculate budget for unprotected sequences
         # Must fit: system + kept sequences + protected zone
         budget = self.max_tokens - system_tokens - protected_tokens

henchman/version.py

@@ -1,6 +1,6 @@
 """Version information for Henchman-AI."""
 
-VERSION_TUPLE = (0, 1, 10)
+VERSION_TUPLE = (0, 1, 11)
 VERSION = ".".join(str(v) for v in VERSION_TUPLE)
 
 __all__ = ["VERSION", "VERSION_TUPLE"]

{henchman_ai-0.1.10.dist-info → henchman_ai-0.1.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: henchman-ai
-Version: 0.1.10
+Version: 0.1.12
 Summary: A model-agnostic AI agent CLI - your AI henchman for the terminal
 Project-URL: Homepage, https://github.com/MGPowerlytics/henchman-ai
 Project-URL: Repository, https://github.com/MGPowerlytics/henchman-ai

{henchman_ai-0.1.10.dist-info → henchman_ai-0.1.12.dist-info}/RECORD

@@ -1,22 +1,22 @@
 henchman/__init__.py,sha256=P_jCbtgAVbk2hn6uMum2UYkE7ptT361mWRkUZz0xKvk,148
 henchman/__main__.py,sha256=3oRWZvoWON5ErlJFYOOSU5p1PERRyK6MkT2LGEnbb2o,131
-henchman/version.py,sha256=ivhUTH7E77KPW-8v6tUSf4uHIMSYQEqrO7y8iXk_Pxw,161
+henchman/version.py,sha256=UFJFO9ixJBEALb9BGtb2TE9cid8MpfI03n3BvBeWoiA,161
 henchman/cli/__init__.py,sha256=Gv86a_heuBLqUd-y46JZUyzUaDl5H-9RtcWGr3rMwBw,673
-henchman/cli/app.py,sha256=7fZI6ta4h6FT-EixItDrje4fKUHYc2hpQgL8UZs9Hpk,6682
-henchman/cli/console.py,sha256=TOuGBSNUaxxQypmmzC0P1IY7tBNlaTgAZesKy8uuZN4,7850
-henchman/cli/input.py,sha256=0qW36f7f06ct4XXca7ooxkTShID-QXkLtmROh_xso04,4632
+henchman/cli/app.py,sha256=ausKDDrRJ5KgiespK2P9vhX1yn-DxdJhYyBJ6tB5sb4,11507
+henchman/cli/console.py,sha256=S4Jvq0UTmu9KtOkLNsIsvG_8X9eg1Guc6NAh8T_JeNI,8017
+henchman/cli/input.py,sha256=oMKMF1CQCZrON5gqy8mtbYqIoGUvXcBEiDZeTxC9B6s,7129
 henchman/cli/json_output.py,sha256=9kP9S5q0xBgP4HQGTT4P6DDT76F9VVTdEY_KiEpoZnI,2669
-henchman/cli/prompts.py,sha256=AxUN-JfWSetOgIwhVxgouQetNqY8hTc7FnLO5jb00LI,5402
-henchman/cli/repl.py,sha256=0dsho4rMZbyxnYMOzURoM46dyBfYDLquD_dO9_HZ6yM,19843
+henchman/cli/prompts.py,sha256=m3Velzi2tXBIHinN9jIpU9kDMYL80ngYQsv2EYo7IZU,6647
+henchman/cli/repl.py,sha256=fkeaMEGnFaFZ-HIjBLI1DUfos9ebGkHrPUUNMWS_LLU,26535
 henchman/cli/repl.py.backup,sha256=3iagruUgsvtcfpDv1mTAYg4I14X4CaNSEeMQjj91src,15638
 henchman/cli/repl.py.backup2,sha256=-zgSUrnobd_sHq3jG-8NbwPTVlPc3FaqSkv32gAFdPo,11328
-henchman/cli/commands/__init__.py,sha256=vxx0lzcLUbNvkvDGpONSCevKbUR-wKQEtxsaIjMbJMU,3755
-henchman/cli/commands/builtins.py,sha256=d4wgb3VeWwaWmKtk0MKr5NAvo-OWVgfxAQKpWkJGBFU,5136
-henchman/cli/commands/chat.py,sha256=rrw1ZGVDdfJiNiPSSow2Q2v6I1uU4wnrfFHj9mZOACc,5550
+henchman/cli/commands/__init__.py,sha256=8s6NBCPlc4jKTCdvnKJCmdLwRCQ4QLCARjQbr7ICipw,3828
+henchman/cli/commands/builtins.py,sha256=-XOAY0EzvyHYnoOc6QMwVve7aMEWPYiMUUjor4OzBqg,5439
+henchman/cli/commands/chat.py,sha256=ePPRh68ZHHS_l1Uj7fUtjBQrVKOx6WvZQsuIzXdxgjY,6204
 henchman/cli/commands/extensions.py,sha256=r7PfvbBjwBr5WhF8G49p29z7FKx6geRJiR-R67pj6i0,1758
 henchman/cli/commands/mcp.py,sha256=bbW1J9-fIpvDBIba3L1MAkNqCjFBTZnZLNIgf6LjJEA,3554
 henchman/cli/commands/plan.py,sha256=5ZXePoMVIKBxugSnDB6N2TEDpl2xZszQDz9wTQffzpY,2486
-henchman/cli/commands/rag.py,sha256=9naERQLKdrfl_Pct-GvSzH18aI2_Ab0Oop3LOklmyPE,7151
+henchman/cli/commands/rag.py,sha256=sXY7MCZ4UMVzNX2ALVM8wt7q82PZovwVHOSMDfot8jQ,7308
 henchman/cli/commands/skill.py,sha256=azXb6-KXjtZKwHiBV-Ppk6CdJQKZhetr46hNgZ_r45Q,8096
 henchman/cli/commands/unlimited.py,sha256=eFMTwrcUFWbfJnXpwBcRqviYt66tDz4xAYBDcton50Y,2101
 henchman/config/__init__.py,sha256=28UtrhPye0MEmbdvi1jCqO3uIXfmqSAZVWvnpJv-qTo,637
@@ -28,7 +28,7 @@ henchman/core/agent.py,sha256=l9BJO8Zw4bMdUyTDjcZKG84WdZ1Kndm3Y09oUAZFYp0,13475
 henchman/core/agent.py.backup,sha256=Tq0IhWAPMRQTxjETeH7WTosEmzuUVz7um0YbCnuNbLQ,7417
 henchman/core/events.py,sha256=Uijv3NGNV8yJnQfY48u0pBBvEauAEczAbkGARJy8mfI,1423
 henchman/core/session.py,sha256=NkwEG2ZS2uh2ZeX8_LkSN7MwQlBxwhTXjx0BoNUZLDw,12475
-henchman/core/turn.py,sha256=DoSWqIifrrkhzr4KD3zmA1Sq-csNCBflGGEKOc7PfOs,8165
+henchman/core/turn.py,sha256=iRaTr_8hGSGQUt0vqmUE8w5D-drvkLeZlNEHmNUfX0M,8617
 henchman/extensions/__init__.py,sha256=C7LrK50uiHwmLlOGkQyngbFvuUYdCcZEb6ucOklY_ws,310
 henchman/extensions/base.py,sha256=cHUzWu4OGFju9Wr1xAiGHZOOW7eQbcC1-dqEd2Oe3QM,2290
 henchman/extensions/manager.py,sha256=xHxMo0-BxzyFfD3fZgvsiovORYpMM6sPnDPOTfULZSU,6666
@@ -47,11 +47,12 @@ henchman/providers/openai_compat.py.backup,sha256=Gmi5k1-DjUt8Kx5UaXmiSNKSDBGh0G
 henchman/providers/registry.py,sha256=xsOaYuaemgDOOi-JLi6URbto0dQP77y-Lo__zzUuEGU,2758
 henchman/rag/__init__.py,sha256=5Gbo7SZYPrZK8YLFn3wqfPJ_PlPV9uVHYy3NOGwjPok,1102
 henchman/rag/chunker.py,sha256=3fc9OuGb7AgkT0Qy5fOQcwa3eCiJOcffAx133I2lfuQ,6040
+henchman/rag/concurrency.py,sha256=-CQUm-N4K-xujSjLZAwwI1y3kdf8OLstBQ6T7KWuRoI,6689
 henchman/rag/embedder.py,sha256=J2-cIEIoS2iUh4k6PM-rgl7wkTOXSG1NrOQvXHTQPho,4080
 henchman/rag/indexer.py,sha256=6oVOkv4lD_elACivPL9Noe5zgpterYDZ3f1XlLyyULc,11806
-henchman/rag/repo_id.py,sha256=_L_WLTWmMHV7XUEFT_BKf2Ge88XelIwN8HRD1zhvuZY,5775
-henchman/rag/store.py,sha256=0l8RyGTtYDg0tzPN5wqQJR4YwVQe2P5fpPq9s5c1ofw,7369
-henchman/rag/system.py,sha256=uQD2vO8NX9GYQFO0BlGMoRZHEcgOBfHnoHzsYj2nuio,6676
+henchman/rag/repo_id.py,sha256=ZRPKM8fzwmETgrOYwE1PGjRp3c8XQFrR493BrDZlbd8,5755
+henchman/rag/store.py,sha256=eN0Rj2Lo6zJp2iWCXsJ-q24l2T_pnlTF3Oeea60gnfs,8826
+henchman/rag/system.py,sha256=uEftMJJCy0wlHvt09j2YP7xDdN0if8eCYD4MnS7_Xvc,9869
 henchman/skills/__init__.py,sha256=cvCl6HRxsUdag-RTpMP__Ww_hee37ggpAXQ41wXemEU,149
 henchman/skills/executor.py,sha256=sYss_83zduFLB_AACTSXMZHLA_lv-T1iKHSxelpv13U,1105
 henchman/skills/learner.py,sha256=lzIrLU5_oLbqDYF673F-rwb1IaWeeOqjzcsBGC-IKlM,1644
@@ -72,12 +73,12 @@ henchman/tools/builtins/rag_search.py,sha256=yk0z0mIVRH-yl47uteNXTy76aXP8PLxBq51
 henchman/tools/builtins/shell.py,sha256=Gx8x1jBq1NvERFnc-kUNMovFoWg_i4IrV_askSECfEM,4134
 henchman/tools/builtins/web_fetch.py,sha256=uwgZm0ye3yDuS2U2DPV4D-8bjviYDTKN-cNi7mCMRpw,3370
 henchman/utils/__init__.py,sha256=ayu2XRNx3Fw0z8vbIne63A3gBjxu779QE8sUQsjNnm4,240
-henchman/utils/compaction.py,sha256=jPpJ5tQm-IBn4YChiGrKy8u_K4OJ23lk3Jvq8sNbQYc,22763
+henchman/utils/compaction.py,sha256=ARS0jUDI2adsoCTfJjygRom31N16QtWbRzNXDKzX6cA,22871
 henchman/utils/retry.py,sha256=sobZk9LLGxglSJw_jeNaBYCrvH14YNFrBVyp_OwLWcw,4993
 henchman/utils/tokens.py,sha256=D9H4ciFNH7l1b05IGbw0U0tmy2yF5aItFZyDufGF53k,5665
 henchman/utils/validation.py,sha256=moj4LQXVXt2J-3_pWVH_0-EabyRYApOU2Oh5JSTIua8,4146
-henchman_ai-0.1.10.dist-info/METADATA,sha256=0qO8cg63N87mlJLtC-TgGwhBFwyYen8mlvnM2aupdyk,3552
-henchman_ai-0.1.10.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-henchman_ai-0.1.10.dist-info/entry_points.txt,sha256=dtPyd6BzK3A8lmrj1KXTFlHBplIWcWMdryjtR0jw5iU,51
-henchman_ai-0.1.10.dist-info/licenses/LICENSE,sha256=TMoSCCG1I1vCMK-Bjtvxe80E8kIdSdrtuQXYHc_ahqg,1064
-henchman_ai-0.1.10.dist-info/RECORD,,
+henchman_ai-0.1.12.dist-info/METADATA,sha256=Ht1dV7MGoqu7E2XAubPT9sZbNxFepLvA9jGQxw2KTas,3552
+henchman_ai-0.1.12.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+henchman_ai-0.1.12.dist-info/entry_points.txt,sha256=dtPyd6BzK3A8lmrj1KXTFlHBplIWcWMdryjtR0jw5iU,51
+henchman_ai-0.1.12.dist-info/licenses/LICENSE,sha256=TMoSCCG1I1vCMK-Bjtvxe80E8kIdSdrtuQXYHc_ahqg,1064
+henchman_ai-0.1.12.dist-info/RECORD,,