Phase 11: Embedding versioning — model-proof vector layer

- IndexRegistry: tracks all vector indexes with model metadata
  (model_name, model_version, dimensions, build stats)
- Index metadata persisted as JSON in vectors/meta/
- Rebuilt on startup for crash recovery
- GET /vectors/indexes — list all indexes (filter by source/model)
- GET /vectors/indexes/{name} — get index metadata
- Background jobs auto-register metadata on completion
- Multi-version support: same data, different models, coexist
- Per ADR-014: enables incremental re-embed on model upgrade

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

crates/vectord/src/service.rs

@@ -1,6 +1,6 @@
 use axum::{
     Json, Router,
-    extract::{Path, State},
+    extract::{Path, Query, State},
     http::StatusCode,
     response::IntoResponse,
     routing::{get, post},
@@ -10,19 +10,22 @@ use serde::{Deserialize, Serialize};
 use std::sync::Arc;
 
 use aibridge::client::{AiClient, EmbedRequest};
-use crate::{chunker, jobs, rag, search, store, supervisor};
+use crate::{chunker, index_registry, jobs, rag, search, store, supervisor};
 
 #[derive(Clone)]
 pub struct VectorState {
     pub store: Arc<dyn ObjectStore>,
     pub ai_client: AiClient,
     pub job_tracker: jobs::JobTracker,
+    pub index_registry: index_registry::IndexRegistry,
 }
 
 pub fn router(state: VectorState) -> Router {
     Router::new()
         .route("/health", get(health))
         .route("/index", post(create_index))
+        .route("/indexes", get(list_indexes))
+        .route("/indexes/{name}", get(get_index_meta))
         .route("/jobs", get(list_jobs))
         .route("/jobs/{id}", get(get_job))
         .route("/search", post(search_index))
@@ -88,17 +91,42 @@ async fn create_index(
     let tracker = state.job_tracker.clone();
     let ai_client = state.ai_client.clone();
     let obj_store = state.store.clone();
+    let registry = state.index_registry.clone();
     let jid = job_id.clone();
+    let source_name = req.source.clone();
+    let idx_name = req.index_name.clone();
 
     tokio::spawn(async move {
+        let start_time = std::time::Instant::now();
         let config = supervisor::SupervisorConfig::default();
         let result = supervisor::run_supervised(
-            &jid, &index_name, chunks, &ai_client, &obj_store, &tracker, config,
+            &jid, &idx_name, chunks, &ai_client, &obj_store, &tracker, config,
         ).await;
         match result {
             Ok(key) => {
+                let elapsed = start_time.elapsed().as_secs_f32();
+                let rate = if elapsed > 0.0 { n_chunks as f32 / elapsed } else { 0.0 };
+
+                // Register index metadata with model version info
+                let meta = index_registry::IndexMeta {
+                    index_name: idx_name.clone(),
+                    source: source_name,
+                    model_name: "nomic-embed-text".to_string(), // from sidecar config
+                    model_version: "latest".to_string(),
+                    dimensions: 768,
+                    chunk_count: n_chunks,
+                    doc_count: n_docs,
+                    chunk_size: chunk_size,
+                    overlap: overlap,
+                    storage_key: key.clone(),
+                    created_at: chrono::Utc::now(),
+                    build_time_secs: elapsed,
+                    chunks_per_sec: rate,
+                };
+                let _ = registry.register(meta).await;
+
                 tracker.complete(&jid, key).await;
-                tracing::info!("job {jid}: completed");
+                tracing::info!("job {jid}: completed — {n_chunks} chunks in {elapsed:.0}s ({rate:.0}/sec)");
             }
             Err(e) => {
                 tracker.fail(&jid, e.clone()).await;
@@ -116,8 +144,37 @@ async fn create_index(
     })))
 }
 
-/// Run the actual embedding work in background.
-async fn run_embedding_job(
+// --- Index Registry ---
+
+#[derive(Deserialize)]
+struct IndexListQuery {
+    source: Option<String>,
+    model: Option<String>,
+}
+
+async fn list_indexes(
+    State(state): State<VectorState>,
+    Query(q): Query<IndexListQuery>,
+) -> impl IntoResponse {
+    let indexes = state.index_registry.list(q.source.as_deref(), q.model.as_deref()).await;
+    Json(indexes)
+}
+
+async fn get_index_meta(
+    State(state): State<VectorState>,
+    Path(name): Path<String>,
+) -> impl IntoResponse {
+    match state.index_registry.get(&name).await {
+        Some(meta) => Ok(Json(meta)),
+        None => Err((StatusCode::NOT_FOUND, format!("index not found: {name}"))),
+    }
+}
+
+// --- unused legacy function below, kept for reference ---
+
+#[allow(dead_code)]
+/// Legacy single-pipeline embedding (replaced by supervisor).
+async fn _run_embedding_job_legacy(
     job_id: &str,
     index_name: &str,
     chunks: &[chunker::TextChunk],