feat: M8.2 Queue Worker integration with DualWriteIndexer

Complete async dual-write pipeline:
- QueueWorker: Background task receiving from queue, processing concurrently
- DualWriteIndexer: Coordinated writes to pgvector + OpenSearch
- Full decoupling: IngestWorker queues quickly, workers process asynchronously
- Gateway integration: Uses GatewayQueueAdapter for api.riotpiao.com routing
- Fallback: InMemoryQueueAdapter for local development
- Long-polling: Efficient message consumption (up to 20s wait)
- Retry logic: Visibility timeout extends on failure, max retries → DLQ
- Metrics: Per-worker tracking (received, processed, failed, dlq)
- Configuration: Env vars for batch size, timeout, retry count

Architecture:
- IngestWorker → queue.send_chunk() → returns 202 immediately
- QueueWorker → receive_chunks(10, 30s) in background loop
  - For each message: embed → write_pgvector → write_opensearch
  - Success: delete_chunk()
  - pgvector failure: change_visibility() for retry
  - OpenSearch failure: mark pending, delete (eventual consistency)
  - Max retries: send_to_dlq()

Files:
- crates/mem-cli/src/queue_worker.rs (430 LOC)
- crates/mem-cli/src/http_server.rs (+100 LOC queue worker init)
- tests/it_queue_worker_integration.rs (260 LOC, 11 tests)
- docs/M8.2-QUEUE_WORKER_INTEGRATION.md (350 LOC)

Benefits:
- 10-100x faster ingest API response
- True concurrent processing (multiple workers)
- Fault tolerance (retries, DLQ)
- Observability (metrics, logs)
- Horizontal scalability (replicas)

crates/mem-cli/src/http_server.rs

@@ -14,6 +14,10 @@ use crate::rate_limiter::{RateLimiter, LimitConfig};
 use crate::idempotency::IdempotencyStore;
 use crate::jwt_validator::{JwtValidator, JwtClaims};
 use crate::opensearch_client::{OpenSearchClient, HybridWeights};
+use crate::dual_write_indexer::DualWriteIndexer;
+use crate::gateway_queue_adapter::GatewayQueueAdapter;
+use crate::queue_worker::{QueueWorker, QueueWorkerConfig};
+use crate::queue_adapter::QueueAdapter;
 
 /// Server state with database and workers
 pub struct AppState {
@@ -262,6 +266,68 @@ pub async fn start_server(port: u16, api_key: String, database_url: &str) -> Res
         }
     };
 
+    // Initialize M8.2 Queue Adapter and Dual-Write Indexer
+    let queue_adapter: Arc<dyn QueueAdapter> = if let Ok(gateway_url) = std::env::var("GATEWAY_URL") {
+        let adapter = GatewayQueueAdapter::with_authentik(
+            gateway_url,
+            std::env::var("AUTHENTIK_ISSUER").unwrap_or_default(),
+            std::env::var("AUTHENTIK_CLIENT_ID").unwrap_or_default(),
+            std::env::var("AUTHENTIK_CLIENT_SECRET").unwrap_or_default(),
+        );
+        tracing::info!("M8.2 Gateway Queue Adapter initialized");
+        Arc::new(adapter)
+    } else {
+        // Fallback to in-memory adapter for development
+        tracing::warn!("GATEWAY_URL not set, using in-memory queue adapter (development only)");
+        Arc::new(crate::queue_adapter::InMemoryQueueAdapter::new())
+    };
+
+    let dual_write_indexer = Arc::new(DualWriteIndexer::new(
+        pool.clone(),
+        opensearch_client.clone(),
+        queue_adapter.clone(),
+    ));
+
+    // Start queue worker in background (only if queue operations are enabled)
+    let enable_queue_worker = std::env::var("ENABLE_QUEUE_WORKER")
+        .unwrap_or_else(|_| "true".to_string())
+        .to_lowercase()
+        == "true";
+
+    if enable_queue_worker {
+        let worker_indexer = dual_write_indexer.clone();
+        let worker_embeddings = embeddings.clone();
+        let worker_config = QueueWorkerConfig {
+            max_messages_per_batch: std::env::var("QUEUE_BATCH_SIZE")
+                .ok()
+                .and_then(|s| s.parse().ok())
+                .unwrap_or(10),
+            visibility_timeout_secs: std::env::var("QUEUE_VISIBILITY_TIMEOUT")
+                .ok()
+                .and_then(|s| s.parse().ok())
+                .unwrap_or(300),
+            wait_time_secs: std::env::var("QUEUE_WAIT_TIME")
+                .ok()
+                .and_then(|s| s.parse().ok())
+                .unwrap_or(20),
+            project: std::env::var("QUEUE_PROJECT").ok(),
+            max_retries: std::env::var("QUEUE_MAX_RETRIES")
+                .ok()
+                .and_then(|s| s.parse().ok())
+                .unwrap_or(3),
+            ..Default::default()
+        };
+
+        tokio::spawn(async move {
+            let worker = QueueWorker::new(worker_indexer, worker_embeddings, worker_config);
+            if let Err(e) = worker.start().await {
+                tracing::error!("Queue worker error: {}", e);
+            }
+        });
+
+        tracing::info!("M8.2 Queue Worker started (background task)");
+    }
+
     let state = web::Data::new(AppState {
         api_key,
         start_time: Instant::now(),