agent-brain-rag 2.0.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

{agent_brain_rag-2.0.0.dist-info → agent_brain_rag-3.0.0.dist-info}/METADATA

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: agent-brain-rag
-Version: 2.0.0
+Version: 3.0.0
 Summary: Agent Brain RAG - Intelligent document indexing and semantic search server that gives AI agents long-term memory
+Home-page: https://github.com/SpillwaveSolutions/agent-brain
 License: MIT
 Keywords: agent-brain,rag,semantic-search,ai-memory,llm-memory,documentation,indexing,llama-index,chromadb,ai-agent,claude-code,agent-memory
 Author: Spillwave Solutions
@@ -13,7 +14,6 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Documentation
 Classifier: Topic :: Text Processing :: Indexing
 Provides-Extra: graphrag
@@ -42,7 +42,6 @@ Requires-Dist: tiktoken (>=0.8.0,<0.9.0)
 Requires-Dist: tree-sitter-language-pack (>=0.7.3,<0.8.0)
 Requires-Dist: uvicorn[standard] (>=0.32.0,<0.33.0)
 Project-URL: Documentation, https://github.com/SpillwaveSolutions/agent-brain/wiki
-Project-URL: Homepage, https://github.com/SpillwaveSolutions/agent-brain
 Project-URL: Repository, https://github.com/SpillwaveSolutions/agent-brain
 Description-Content-Type: text/markdown
 

{agent_brain_rag-2.0.0.dist-info → agent_brain_rag-3.0.0.dist-info}/RECORD

@@ -1,27 +1,33 @@
-agent_brain_server/__init__.py,sha256=W5Jm_aOWbsUD605_og-pejqYr3kW_gh5Mf7e4kLOviU,95
+agent_brain_server/__init__.py,sha256=Wjd2w3VnDYURTECaKxFQ5x324-7tZ_vK2Qv3yKfxRGg,95
 agent_brain_server/api/__init__.py,sha256=nvTvO_ahHAAsRDlV3dL_JlNruSdan4kav_P5sT_1PFk,93
-agent_brain_server/api/main.py,sha256=KMPrhH9EsvuFa6aAZlui3og8wm6WoxLwZkj4LTKRiHM,12894
-agent_brain_server/api/routers/__init__.py,sha256=Z3PUKDwxeI8T88xMQeTcQ8nq1bQnu0nYjRnqNIsDUyY,254
-agent_brain_server/api/routers/health.py,sha256=xzgjFlSndRx9jT_G4kOl79MiWv06ZUcXTAE7z2jjANs,3538
-agent_brain_server/api/routers/index.py,sha256=jTfeY8EIbM1tksJY6jNDw6qkmKBMaAi1ufDIdrg80WQ,6756
+agent_brain_server/api/main.py,sha256=TEb4lMSFm8eqNYOhXvoF6Xwi_r20RMuO8HL0zQxKfhY,16086
+agent_brain_server/api/routers/__init__.py,sha256=EQ5xXSTEIqRaZu-CKiOxeR05BMzUVgATMir_PV6zJ-Q,313
+agent_brain_server/api/routers/health.py,sha256=lTk0VXvTIvAV8YyOKAcPvZXhBeZ8jnENCDkZG3xk9Bg,6015
+agent_brain_server/api/routers/index.py,sha256=89_SrTByqEhQuQxsP7SXWiocXgQh2sgJ9n0Y_kNEWjA,9397
+agent_brain_server/api/routers/jobs.py,sha256=GYoZtTUc2BE2_u1HoUSGqUVDg7MAjhs6dG9-gjKoztw,3329
 agent_brain_server/api/routers/query.py,sha256=TAbpuCybjacUo_-7Zm3Jt8EW8EMDTYJDLv6aGtjaUzQ,2793
 agent_brain_server/config/__init__.py,sha256=zzDErZGUBwUm5Fk43OHJN7eWpeIw_1kWdnhsN6QQqSc,84
-agent_brain_server/config/provider_config.py,sha256=6c1CaE-_Az8PGglSxJVJjR0ns2ljEYyTSJyUxAVgZO4,9552
-agent_brain_server/config/settings.py,sha256=cXVsHeCQjGf9I_N1FfkMFBBHEeukqQOdJ7zMIMAWOXg,3380
+agent_brain_server/config/provider_config.py,sha256=-uHj28i8OvAhQxlZ0JudYPAyibdJWmEJfvOYuRAdSHw,11535
+agent_brain_server/config/settings.py,sha256=XfkAi-5aV_vqbk4ltkG8mkJnPARPwl5g6JxvE0ngDjo,3726
 agent_brain_server/indexing/__init__.py,sha256=tQiFW4945h-ENd0pmMoGhCbm1Fz3AaREKBgajHeW-Us,1169
-agent_brain_server/indexing/bm25_index.py,sha256=CIeGZIa8PwvOm_Fnz3EMgETvM2Mu6GzANWeUims0P0Q,5268
+agent_brain_server/indexing/bm25_index.py,sha256=_CZdTF1zoLyILTJ1nTLSmovIqN2NVQuYUiMEWh4o3-o,5740
 agent_brain_server/indexing/chunking.py,sha256=kW-ZOdwOS-PfXuPAYb8qL4-7yAY-rpY9a1el2YCN9CA,29848
-agent_brain_server/indexing/document_loader.py,sha256=D6U3mDl_2jFfT_JxD-5yudtqlJW8Fh0zj5lhz0V0tPs,16090
+agent_brain_server/indexing/document_loader.py,sha256=l43Z5xHEykr6hbQqkMWXZGlT_CDz_tdhkI3PsxTMsgQ,17543
 agent_brain_server/indexing/embedding.py,sha256=i3bN3SivvVB8iNiYDjrDeB8nF3WkFoOy5wHrDaNosGs,7410
 agent_brain_server/indexing/graph_extractors.py,sha256=XEWBqlqDffxbs5ZLaijGICXeaptGtkUGNEhJblP3jBU,19339
 agent_brain_server/indexing/graph_index.py,sha256=ZKwICIqR2stcPEqNQ_SSuSk-O0Hj1lUmiUMxm5udhjg,18584
-agent_brain_server/locking.py,sha256=yRpswpBem4964gTh1VH4VUPT-vBIRnNEVgWdorJA4Hg,3365
-agent_brain_server/models/__init__.py,sha256=5KAkdcB8rR5B0Z9IY2ZxtrUGSglFtxNeu6ZwGHTVDAU,737
+agent_brain_server/job_queue/__init__.py,sha256=8aUjeXygbB_u76AqPTrlrwFDVVdqfiaWM9ROUAslKM4,240
+agent_brain_server/job_queue/job_service.py,sha256=BAzG_NMCnbHNHluKtKI1lMJxl1MF03G7Rv9mKEcgkWc,10660
+agent_brain_server/job_queue/job_store.py,sha256=xHWZh9rITUeCIAZwWmoEYDtSGCEfQuveduB9ET3L4zU,13699
+agent_brain_server/job_queue/job_worker.py,sha256=bh7pV9XKiCrK_bc1jeESh35DEcgfsiiAsrXo_ihwcLw,17566
+agent_brain_server/locking.py,sha256=ANgzY8aczB6W9OeWEv8zEZ8iOhXlBCOYlZH60xZsiHU,6249
+agent_brain_server/models/__init__.py,sha256=8tCr8Gmx6ieVx-CgX6W_a7s8doqAzWtDs8Jk5lrYmRA,1105
 agent_brain_server/models/graph.py,sha256=YzdjJj_X7hueJt4v8Gsoly4C-qquJLZi1d9epIh_Mos,7973
-agent_brain_server/models/health.py,sha256=kwSuR64ldDnrim7PO_4tZLhejdFRKbqkdu4mDf6Z7gQ,4160
+agent_brain_server/models/health.py,sha256=ppvDF_yUaddzYPe0BPc9emVDrR17TVlQLW6ggsOOzPo,4592
 agent_brain_server/models/index.py,sha256=pjDv7phLS6dpiHLlEtcAuXQN_aHIfA_4lMkAZ-NkXZQ,5400
-agent_brain_server/models/query.py,sha256=mrb8Kjvg6DQZJs8aGEqic54FpzSr62qrSPDFXZeUfpM,6613
-agent_brain_server/project_root.py,sha256=HIY5NMRDYWYIT7K6B_UMOGo1zXn9zwAdGI6ApViKI_8,2194
+agent_brain_server/models/job.py,sha256=OkNO8tHFFyV82kLJAocs4jKKI7Hde93y7KH8q_mfVyI,11194
+agent_brain_server/models/query.py,sha256=hCdcXIOPhW4wXrSQGunEXkIgiugD3lBXnS4F6fOCe_Q,6613
+agent_brain_server/project_root.py,sha256=js9ju-AhQ2SyC6wlfFhbMHhkNMJ3VNDdGZ3OJONUFjs,2196
 agent_brain_server/providers/__init__.py,sha256=04wJ_QhGKRM55R4yrbw3J3kCtKX44_FHzh6xZq1xFdc,1670
 agent_brain_server/providers/base.py,sha256=yLIpz9W0xlilBXxuFJRNP_gbGDsZ9HeRSqEnIsVGQjU,6933
 agent_brain_server/providers/embedding/__init__.py,sha256=WRUAkOLLgQB9AR9I-_m3QWa55hSeC5tDdp3gZQFfMRM,982
@@ -36,15 +42,15 @@ agent_brain_server/providers/summarization/gemini.py,sha256=t2pOC4R2ae7WQAq7WCy8
 agent_brain_server/providers/summarization/grok.py,sha256=nK3i46NbUcVxBqWNbJ-IifahB450Blnqm0rBhSQnQOw,2875
 agent_brain_server/providers/summarization/ollama.py,sha256=mw4zvx6o2nC4xoz1W6F47x3fk7gidl7aeh1uAnSTHO8,3673
 agent_brain_server/providers/summarization/openai.py,sha256=HjZJIjwc0usHejRAFW3JT6a7cmM_Ib2FdC05y_iEwA4,2632
-agent_brain_server/runtime.py,sha256=bcchfDBt_tn2_r-lFhxqKp0RncKrz152D-oM5RcKGrU,3076
+agent_brain_server/runtime.py,sha256=SVQa-8rgNFBeHyJe23bvzZ49Gf-4PqkuSJ-kJ1FPkSM,3081
 agent_brain_server/services/__init__.py,sha256=E4VPN9Rqa2mxGQQEQn-5IYj63LSPTrA8aIx8ENO5xcc,296
 agent_brain_server/services/indexing_service.py,sha256=d_oj3n7gNgua7nmiLNTM-hDp4wvcrkos9kCRuOTzlpc,20338
 agent_brain_server/services/query_service.py,sha256=oc_BNqTNjAtz17y_F7r-egP7Z0GozmP_mlfSs1jKbMM,22910
 agent_brain_server/storage/__init__.py,sha256=xYk4MfrEj-IpGZ0n4myfy5dwyjKEvprS7h68bet0ooU,557
 agent_brain_server/storage/graph_store.py,sha256=boW6_L0suvHuOdfZdPMdSNSb8U-am7KLelsa3K2bKl4,18168
 agent_brain_server/storage/vector_store.py,sha256=rcI--g6g7mqUbZzewOsaMdb7uqw173bAZau1p0oYZ68,12135
-agent_brain_server/storage_paths.py,sha256=OvCXjSDu_L_udlxWo4OoOd_J-mcBcfoCSNwHRCnFHHk,1844
-agent_brain_rag-2.0.0.dist-info/METADATA,sha256=KLRRJQO2nCyqwvZuuovxSh-IrBmb7LUtgOnx-0EqcQs,8155
-agent_brain_rag-2.0.0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-agent_brain_rag-2.0.0.dist-info/entry_points.txt,sha256=r6kfBauVV9OtMXQ7trM9ofbW5N_kdzqTouoJ9zc31-I,122
-agent_brain_rag-2.0.0.dist-info/RECORD,,
+agent_brain_server/storage_paths.py,sha256=FOpcFu21mlxPY-TCjWg6bMmREYEYDkVru7NumztGZWw,1850
+agent_brain_rag-3.0.0.dist-info/METADATA,sha256=C5ad5HVow94PzzSYAYcHx2gR4z9NelnZk3D7SIqwC7g,8092
+agent_brain_rag-3.0.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+agent_brain_rag-3.0.0.dist-info/entry_points.txt,sha256=Ig6JVYNKNNNnE96d8LefHRUdg11HUIGWfVQ1sAYI47c,69
+agent_brain_rag-3.0.0.dist-info/RECORD,,

{agent_brain_rag-2.0.0.dist-info → agent_brain_rag-3.0.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.1
+Generator: poetry-core 1.8.1
 Root-Is-Purelib: true
 Tag: py3-none-any

{agent_brain_rag-2.0.0.dist-info → agent_brain_rag-3.0.0.dist-info}/entry_points.txt

@@ -1,4 +1,3 @@
 [console_scripts]
 agent-brain-serve=agent_brain_server.api.main:cli
-doc-serve=agent_brain_server.api.main:cli_deprecated
 

agent_brain_server/__init__.py

@@ -1,3 +1,3 @@
 """Doc-Serve Server - RAG-based document indexing and query service."""
 
-__version__ = "2.0.0"
+__version__ = "3.0.0"

agent_brain_server/api/main.py

@@ -1,15 +1,16 @@
 """FastAPI application entry point.
 
 This module provides the Agent Brain RAG server, a FastAPI application
-for document indexing and semantic search. The primary entry point is
-`agent-brain-serve`, with `doc-serve` provided for backward compatibility.
+for document indexing and semantic search.
+
+Note: This server assumes a single uvicorn worker process. If running
+multiple workers, ensure only one worker handles indexing jobs by using
+the single-worker model or a separate job processor service.
 """
 
 import logging
 import os
 import socket
-import sys
-import warnings
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from pathlib import Path
@@ -23,10 +24,12 @@ from fastapi.middleware.cors import CORSMiddleware
 from agent_brain_server import __version__
 from agent_brain_server.config import settings
 from agent_brain_server.config.provider_config import (
+    clear_settings_cache,
     load_provider_settings,
     validate_provider_config,
 )
 from agent_brain_server.indexing.bm25_index import BM25IndexManager
+from agent_brain_server.job_queue import JobQueueService, JobQueueStore, JobWorker
 from agent_brain_server.locking import (
     acquire_lock,
     cleanup_stale,
@@ -39,7 +42,7 @@ from agent_brain_server.services import IndexingService, QueryService
 from agent_brain_server.storage import VectorStoreManager
 from agent_brain_server.storage_paths import resolve_state_dir, resolve_storage_paths
 
-from .routers import health_router, index_router, query_router
+from .routers import health_router, index_router, jobs_router, query_router
 
 # Configure logging
 logging.basicConfig(
@@ -52,6 +55,9 @@ logger = logging.getLogger(__name__)
 _runtime_state: Optional[RuntimeState] = None
 _state_dir: Optional[Path] = None
 
+# Module-level reference to job worker for cleanup
+_job_worker: Optional[JobWorker] = None
+
 
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncIterator[None]:
@@ -64,13 +70,16 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
     - Resolves project root and state directory
     - Acquires lock (with stale detection)
     - Writes runtime.json with server info
+    - Initializes job queue system
     - Cleans up on shutdown
     """
-    global _runtime_state, _state_dir
+    global _runtime_state, _state_dir, _job_worker
 
     logger.info("Starting Agent Brain RAG server...")
 
     # Load and validate provider configuration
+    # Clear cache first to ensure we pick up env vars set by CLI
+    clear_settings_cache()
     try:
         provider_settings = load_provider_settings()
         validation_errors = validate_provider_config(provider_settings)
@@ -98,8 +107,14 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
         os.environ["OPENAI_API_KEY"] = settings.OPENAI_API_KEY
 
     # Determine mode and resolve paths
-    mode = settings.DOC_SERVE_MODE
-    state_dir = _state_dir  # May be set by CLI
+    mode = settings.AGENT_BRAIN_MODE
+    state_dir = _state_dir  # May be set by run() function
+
+    # If not set via run(), check environment variable (set by CLI subprocess)
+    if state_dir is None and settings.AGENT_BRAIN_STATE_DIR:
+        state_dir = Path(settings.AGENT_BRAIN_STATE_DIR).resolve()
+        logger.info(f"Using state directory from environment: {state_dir}")
+
     storage_paths: Optional[dict[str, Path]] = None
 
     if state_dir is not None:
@@ -114,13 +129,19 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
         # Acquire exclusive lock
         if not acquire_lock(state_dir):
             raise RuntimeError(
-                f"Another doc-serve instance is already running for {state_dir}"
+                f"Another Agent Brain instance is already running for {state_dir}"
             )
 
         # Resolve storage paths (creates directories)
         storage_paths = resolve_storage_paths(state_dir)
         logger.info(f"State directory: {state_dir}")
 
+    # Determine project root for path validation
+    project_root: Optional[Path] = None
+    if state_dir is not None:
+        # Project root is 3 levels up from .claude/agent-brain
+        project_root = state_dir.parent.parent.parent
+
     try:
         # Determine persistence directories
         chroma_dir = (
@@ -149,10 +170,28 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
         app.state.bm25_manager = bm25_manager
         logger.info("BM25 index manager initialized")
 
+        # Load project config for exclude patterns
+        exclude_patterns = None
+        if state_dir:
+            from agent_brain_server.config.settings import load_project_config
+
+            project_config = load_project_config(state_dir)
+            exclude_patterns = project_config.get("exclude_patterns")
+            if exclude_patterns:
+                logger.info(
+                    f"Using exclude patterns from config: {exclude_patterns[:3]}..."
+                )
+
+        # Create document loader with exclude patterns
+        from agent_brain_server.indexing import DocumentLoader
+
+        document_loader = DocumentLoader(exclude_patterns=exclude_patterns)
+
         # Create indexing service with injected deps
         indexing_service = IndexingService(
             vector_store=vector_store,
             bm25_manager=bm25_manager,
+            document_loader=document_loader,
         )
         app.state.indexing_service = indexing_service
 
@@ -163,6 +202,57 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
         )
         app.state.query_service = query_service
 
+        # Initialize job queue system (Feature 115)
+        if state_dir is not None:
+            # Initialize job queue store
+            job_store = JobQueueStore(state_dir)
+            await job_store.initialize()
+            logger.info("Job queue store initialized")
+
+            # Initialize job queue service
+            job_service = JobQueueService(
+                store=job_store,
+                project_root=project_root,
+            )
+            app.state.job_service = job_service
+            logger.info("Job queue service initialized")
+
+            # Initialize and start job worker
+            _job_worker = JobWorker(
+                job_store=job_store,
+                indexing_service=indexing_service,
+                max_runtime_seconds=settings.AGENT_BRAIN_JOB_TIMEOUT,
+                progress_checkpoint_interval=settings.AGENT_BRAIN_CHECKPOINT_INTERVAL,
+            )
+            await _job_worker.start()
+            logger.info("Job worker started")
+        else:
+            # No state directory - create minimal job service for backward compat
+            # Jobs will not be persisted in this mode
+            logger.warning(
+                "No state directory configured - job queue persistence disabled"
+            )
+            # Create in-memory store with temp directory
+            import tempfile
+
+            temp_dir = Path(tempfile.mkdtemp(prefix="agent-brain-"))
+            job_store = JobQueueStore(temp_dir)
+            await job_store.initialize()
+
+            job_service = JobQueueService(
+                store=job_store,
+                project_root=project_root,
+            )
+            app.state.job_service = job_service
+
+            _job_worker = JobWorker(
+                job_store=job_store,
+                indexing_service=indexing_service,
+                max_runtime_seconds=settings.AGENT_BRAIN_JOB_TIMEOUT,
+                progress_checkpoint_interval=settings.AGENT_BRAIN_CHECKPOINT_INTERVAL,
+            )
+            await _job_worker.start()
+
         # Set multi-instance metadata on app.state for health endpoint
         app.state.mode = mode
         app.state.instance_id = _runtime_state.instance_id if _runtime_state else None
@@ -180,6 +270,12 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
 
     logger.info("Shutting down Agent Brain RAG server...")
 
+    # Stop job worker gracefully
+    if _job_worker is not None:
+        await _job_worker.stop()
+        logger.info("Job worker stopped")
+        _job_worker = None
+
     # Cleanup for per-project mode
     if state_dir is not None:
         delete_runtime(state_dir)
@@ -194,7 +290,7 @@ app = FastAPI(
         "RAG-based document indexing and semantic search API. "
         "Index documents from folders and query them using natural language."
     ),
-    version="2.0.0",
+    version=__version__,
     lifespan=lifespan,
     docs_url="/docs",
     redoc_url="/redoc",
@@ -213,6 +309,7 @@ app.add_middleware(
 # Include routers
 app.include_router(health_router, prefix="/health", tags=["Health"])
 app.include_router(index_router, prefix="/index", tags=["Indexing"])
+app.include_router(jobs_router, prefix="/index/jobs", tags=["Jobs"])
 app.include_router(query_router, prefix="/query", tags=["Querying"])
 
 
@@ -221,7 +318,7 @@ async def root() -> dict[str, str]:
     """Root endpoint redirects to docs."""
     return {
         "name": "Agent Brain RAG API",
-        "version": "2.0.0",
+        "version": __version__,
         "docs": "/docs",
         "health": "/health",
     }
@@ -271,7 +368,7 @@ def run(
         # Create runtime state
         _runtime_state = RuntimeState(
             mode="project",
-            project_root=str(_state_dir.parent.parent.parent),  # .claude/doc-serve
+            project_root=str(_state_dir.parent.parent.parent),  # .claude/agent-brain
             bind_host=resolved_host,
             port=resolved_port,
             pid=os.getpid(),
@@ -323,7 +420,7 @@ def run(
     "--project-dir",
     "-d",
     default=None,
-    help="Project directory (auto-resolves state-dir to .claude/doc-serve)",
+    help="Project directory (auto-resolves state-dir to .claude/agent-brain)",
 )
 def cli(
     host: Optional[str],
@@ -344,15 +441,15 @@ def cli(
       agent-brain-serve --host 0.0.0.0            # Bind to all interfaces
       agent-brain-serve --reload                  # Enable auto-reload
       agent-brain-serve --project-dir /my/project # Per-project mode
-      agent-brain-serve --state-dir /path/.claude/doc-serve  # Explicit state dir
+      agent-brain-serve --state-dir /path/.claude/agent-brain  # Explicit state dir
 
     \b
     Environment Variables:
-      API_HOST              Server host (default: 127.0.0.1)
-      API_PORT              Server port (default: 8000)
-      DEBUG                 Enable debug mode (default: false)
-      DOC_SERVE_STATE_DIR   Override state directory
-      DOC_SERVE_MODE        Instance mode: 'project' or 'shared'
+      API_HOST                Server host (default: 127.0.0.1)
+      API_PORT                Server port (default: 8000)
+      DEBUG                   Enable debug mode (default: false)
+      AGENT_BRAIN_STATE_DIR   Override state directory
+      AGENT_BRAIN_MODE        Instance mode: 'project' or 'shared'
     """
     # Resolve state directory from options
     resolved_state_dir = state_dir
@@ -361,36 +458,12 @@ def cli(
         # Auto-resolve state-dir from project directory
         project_root = resolve_project_root(Path(project_dir))
         resolved_state_dir = str(resolve_state_dir(project_root))
-    elif settings.DOC_SERVE_STATE_DIR and not state_dir:
+    elif settings.AGENT_BRAIN_STATE_DIR and not state_dir:
         # Use environment variable if set
-        resolved_state_dir = settings.DOC_SERVE_STATE_DIR
+        resolved_state_dir = settings.AGENT_BRAIN_STATE_DIR
 
     run(host=host, port=port, reload=reload, state_dir=resolved_state_dir)
 
 
-def cli_deprecated() -> None:
-    """Deprecated entry point for doc-serve command.
-
-    Shows a deprecation warning and then runs the main CLI.
-    """
-    warnings.warn(
-        "\n"
-        "WARNING: 'doc-serve' is deprecated and will be removed in v2.0.\n"
-        "Please use 'agent-brain-serve' instead.\n"
-        "\n"
-        "Migration guide: docs/MIGRATION.md\n"
-        "Online: https://github.com/SpillwaveSolutions/agent-brain/blob/main/docs/MIGRATION.md\n",
-        DeprecationWarning,
-        stacklevel=1,
-    )
-    # Print to stderr for visibility since warnings may be filtered
-    print(
-        "\033[93mWARNING: 'doc-serve' is deprecated. "
-        "Use 'agent-brain-serve' instead. See docs/MIGRATION.md\033[0m",
-        file=sys.stderr,
-    )
-    cli()
-
-
 if __name__ == "__main__":
     cli()

agent_brain_server/api/routers/__init__.py

@@ -2,10 +2,12 @@
 
 from .health import router as health_router
 from .index import router as index_router
+from .jobs import router as jobs_router
 from .query import router as query_router
 
 __all__ = [
     "health_router",
     "index_router",
+    "jobs_router",
     "query_router",
 ]

agent_brain_server/api/routers/health.py

@@ -1,4 +1,4 @@
-"""Health check endpoints."""
+"""Health check endpoints with non-blocking queue status."""
 
 from datetime import datetime, timezone
 from typing import Literal
@@ -20,6 +20,8 @@ router = APIRouter()
 async def health_check(request: Request) -> HealthStatus:
     """Check server health status.
 
+    This endpoint never blocks and always returns quickly.
+
     Returns:
         HealthStatus with current status:
         - healthy: Server is running and ready for queries
@@ -27,20 +29,35 @@ async def health_check(request: Request) -> HealthStatus:
         - degraded: Server is up but some services are unavailable
         - unhealthy: Server is not operational
     """
-    indexing_service = request.app.state.indexing_service
     vector_store = request.app.state.vector_store
+    job_service = getattr(request.app.state, "job_service", None)
 
-    # Determine status
+    # Determine status using queue service (non-blocking)
     status: Literal["healthy", "indexing", "degraded", "unhealthy"]
-    if indexing_service.is_indexing:
+    message: str
+
+    # Check queue status (non-blocking)
+    is_indexing = False
+    current_folder = None
+    if job_service:
+        try:
+            queue_stats = await job_service.get_queue_stats()
+            is_indexing = queue_stats.running > 0
+            if is_indexing and queue_stats.current_job_id:
+                # Get current job details for message
+                current_job = await job_service.get_job(queue_stats.current_job_id)
+                if current_job:
+                    current_folder = current_job.folder_path
+        except Exception:
+            # Non-blocking: don't fail health check if queue service errors
+            pass
+
+    if is_indexing:
         status = "indexing"
-        message = f"Indexing in progress: {indexing_service.state.folder_path}"
+        message = f"Indexing in progress: {current_folder or 'unknown'}"
     elif not vector_store.is_initialized:
         status = "degraded"
         message = "Vector store not initialized"
-    elif indexing_service.state.error:
-        status = "degraded"
-        message = f"Last indexing failed: {indexing_service.state.error}"
     else:
         status = "healthy"
         message = "Server is running and ready for queries"
@@ -67,36 +84,82 @@ async def health_check(request: Request) -> HealthStatus:
     "/status",
     response_model=IndexingStatus,
     summary="Indexing Status",
-    description="Returns detailed indexing status information.",
+    description="Returns detailed indexing status information. Never blocks.",
 )
 async def indexing_status(request: Request) -> IndexingStatus:
     """Get detailed indexing status.
 
+    This endpoint never blocks and always returns quickly, even during indexing.
+
     Returns:
         IndexingStatus with:
         - total_documents: Number of documents indexed
         - total_chunks: Number of chunks in vector store
         - indexing_in_progress: Boolean indicating active indexing
+        - queue_pending: Number of pending jobs
+        - queue_running: Number of running jobs (0 or 1)
+        - current_job_running_time_ms: How long current job has been running
         - last_indexed_at: Timestamp of last indexing operation
         - indexed_folders: List of folders that have been indexed
     """
     indexing_service = request.app.state.indexing_service
-    status = await indexing_service.get_status()
+    vector_store = request.app.state.vector_store
+    job_service = getattr(request.app.state, "job_service", None)
+
+    # Get vector store count (non-blocking read)
+    try:
+        total_chunks = (
+            await vector_store.get_count() if vector_store.is_initialized else 0
+        )
+    except Exception:
+        total_chunks = 0
+
+    # Get queue status (non-blocking)
+    queue_pending = 0
+    queue_running = 0
+    current_job_id = None
+    current_job_running_time_ms = None
+    progress_percent = 0.0
+
+    if job_service:
+        try:
+            queue_stats = await job_service.get_queue_stats()
+            queue_pending = queue_stats.pending
+            queue_running = queue_stats.running
+            current_job_id = queue_stats.current_job_id
+            current_job_running_time_ms = queue_stats.current_job_running_time_ms
+
+            # Get progress from current job
+            if current_job_id:
+                current_job = await job_service.get_job(current_job_id)
+                if current_job and current_job.progress:
+                    progress_percent = current_job.progress.percent_complete
+        except Exception:
+            # Non-blocking: don't fail status if queue service errors
+            pass
+
+    # Get indexing service status for historical data
+    # This is read-only and non-blocking
+    service_status = await indexing_service.get_status()
 
     return IndexingStatus(
-        total_documents=status["total_documents"],
-        total_chunks=status["total_chunks"],
-        total_doc_chunks=status.get("total_doc_chunks", 0),
-        total_code_chunks=status.get("total_code_chunks", 0),
-        indexing_in_progress=status["is_indexing"],
-        current_job_id=status["current_job_id"],
-        progress_percent=status["progress_percent"],
+        total_documents=service_status.get("total_documents", 0),
+        total_chunks=total_chunks,
+        total_doc_chunks=service_status.get("total_doc_chunks", 0),
+        total_code_chunks=service_status.get("total_code_chunks", 0),
+        indexing_in_progress=queue_running > 0,
+        current_job_id=current_job_id,
+        progress_percent=progress_percent,
         last_indexed_at=(
-            datetime.fromisoformat(status["completed_at"])
-            if status["completed_at"]
+            datetime.fromisoformat(service_status["completed_at"])
+            if service_status.get("completed_at")
             else None
         ),
-        indexed_folders=status["indexed_folders"],
-        supported_languages=status.get("supported_languages", []),
-        graph_index=status.get("graph_index"),
+        indexed_folders=service_status.get("indexed_folders", []),
+        supported_languages=service_status.get("supported_languages", []),
+        graph_index=service_status.get("graph_index"),
+        # Queue status (Feature 115)
+        queue_pending=queue_pending,
+        queue_running=queue_running,
+        current_job_running_time_ms=current_job_running_time_ms,
     )