Fix: replace Celery dispatch with asyncio.create_task for ingestion - books now properly marked ready + chatbot responds correctly

app/api/ingest.py

@@ -77,15 +77,22 @@ async def upload_book(
     })
     await db.commit()
 
-    # R-082: Dispatch to Celery for crash resilience, retries, and worker isolation
-    from app.tasks.ingestion_task import process_document
-    process_document.delay(
-        document_id=doc.id,
-        author_id=current_user.id,
-        book_id=book.id,
-        file_path=str(tmp_path),
-        file_extension=suffix.lstrip("."),
-    )
+    # No Celery worker on HF Spaces — run ingestion as asyncio background task
+    import asyncio
+    from app.dependencies import _get_session_factory
+
+    async def _background():
+        async with _get_session_factory()() as bg_db:
+            await _run_ingestion(
+                file_path=str(tmp_path),
+                book_id=book.id,
+                author_id=current_user.id,
+                title=title or filename.rsplit(".", 1)[0],
+                redis=redis,
+                db=bg_db,
+            )
+
+    asyncio.create_task(_background())
 
     return {"book_id": book.id, "doc_id": doc.id, "status": "processing"}
 
@@ -149,9 +156,11 @@ async def _run_ingestion(
     redis,
     db: AsyncSession,
 ) -> None:
-    """Full async ingestion: validate → parse → chunk → embed → summarize."""
+    """Full async ingestion: validate → parse → chunk → embed → summarize → mark ready."""
     channel = f"ingestion:{author_id}:{book_id}"
     book_repo = BookRepository(db)
+    from app.repositories.document_repo import DocumentRepository
+    doc_repo = DocumentRepository(db)
 
     try:
         await _publish(redis, channel, "validating", 5)
@@ -162,6 +171,7 @@ async def _run_ingestion(
         from app.services.parser import parse_document
         parse_result = parse_document(file_path, ext)
         text = parse_result.text if hasattr(parse_result, "text") else str(parse_result)
+        page_count = getattr(parse_result, "page_count", 0)
 
         await _publish(redis, channel, "chunking", 40)
         from app.services.chunker import chunk_document
@@ -175,24 +185,28 @@ async def _run_ingestion(
         from app.services.summarizer import summarize_book
         summary = await summarize_book(text[:3000])
 
+        # Mark book as ready — matches rag_pipeline.py status check
         await book_repo.update(book_id, author_id, {
-            "status": "active",
+            "status": "ready",
             "chroma_collection_id": collection_name,
             "ai_summary": summary,
             "chunk_count": len(chunks),
+            "page_count": page_count,
         })
         await db.commit()
         await _publish(redis, channel, "complete", 100)
 
     except Exception as e:
-        await book_repo.update(book_id, author_id, {"status": "failed"})
+        import structlog as _log
+        _log.get_logger(__name__).error("Ingestion failed", book_id=book_id, error=str(e))
+        await book_repo.update(book_id, author_id, {"status": "error"})
         await db.commit()
         await _publish(redis, channel, "error", 0, str(e))
 
     finally:
-        # Clean up temp file
         try:
             if os.path.exists(file_path):
                 os.remove(file_path)
         except Exception:
             pass
+

app/services/rag_pipeline.py

@@ -764,7 +764,7 @@ async def _no_context_response(
 
     if len(books) == 1:
         book = books[0]
-        if book.status != "ready":
+        if book.status not in ("ready", "active"):
             text = (
                 f"{book.title} is still being indexed — give it a minute and ask again. "
                 "I'll be able to answer detailed questions once processing finishes."