diff --git a/Cargo.toml b/Cargo.toml
index 61731e0a..aafb3262 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -235,11 +235,3 @@ incremental = false
 inherits = "dev"
 debug = true
 
-# core2 0.4.0 is yanked on crates.io but no 0.4.1+ exists, and libflate /
-# libflate_lz77 (pulled in via the `jieba` feature of nodedb-fts →
-# include-flate → include-flate-compress) still require `core2 ^0.4`.
-# Point cargo at the upstream git source so fresh resolution (CI without
-# a committed lockfile) succeeds — git sources bypass the registry's yank
-# check. Safe to remove once libflate releases a bump off core2.
-[patch.crates-io]
-core2 = { git = "https://github.com/technocreatives/core2", rev = "545e84bcb0f235b12e21351e0c69767958efe2a7" }
diff --git a/nodedb-fts/Cargo.toml b/nodedb-fts/Cargo.toml
index 95a4c662..0e6ea20e 100644
--- a/nodedb-fts/Cargo.toml
+++ b/nodedb-fts/Cargo.toml
@@ -12,7 +12,10 @@ homepage.workspace = true
 [features]
 default = []
 lang-ja = ["dep:lindera"]
-lang-zh = ["dep:jieba-rs"]
+# lang-zh currently falls back to CJK bigrams. The previous dictionary-based
+# implementation pulled jieba-rs → include-flate → libflate → yanked core2,
+# which breaks `cargo publish`. Re-enable once the upstream chain is fixed.
+lang-zh = []
 lang-ko = ["dep:lindera"]
 lang-th = ["dep:icu_segmenter"]
 lang-detect = ["dep:whatlang"]
@@ -29,7 +32,6 @@ thiserror = { workspace = true }
 
 # Optional: dictionary-based CJK segmentation
 lindera = { version = "2.3", optional = true }
-jieba-rs = { version = "0.9", optional = true }
 icu_segmenter = { version = "1", optional = true }
 whatlang = { version = "0.18", optional = true }
 
diff --git a/nodedb-fts/src/analyzer/language/cjk/segmenter.rs b/nodedb-fts/src/analyzer/language/cjk/segmenter.rs
index 91447056..9f973d13 100644
--- a/nodedb-fts/src/analyzer/language/cjk/segmenter.rs
+++ b/nodedb-fts/src/analyzer/language/cjk/segmenter.rs
@@ -6,7 +6,7 @@
 //!
 //! Feature gates:
 //! - `lang-ja`: lindera with IPADIC for Japanese
-//! - `lang-zh`: jieba-rs for Chinese
+//! - `lang-zh`: currently falls back to CJK bigrams (see Cargo.toml)
 //! - `lang-ko`: lindera with ko-dic for Korean
 //! - `lang-th`: icu_segmenter for Thai
 
@@ -37,16 +37,9 @@ fn segment_japanese(text: &str) -> Vec<String> {
     }
 }
 
-/// Chinese segmentation: jieba when `lang-zh` is enabled, bigrams otherwise.
+/// Chinese segmentation: CJK bigrams (dictionary segmentation temporarily disabled).
 fn segment_chinese(text: &str) -> Vec<String> {
-    #[cfg(feature = "lang-zh")]
-    {
-        jieba_segment(text)
-    }
-    #[cfg(not(feature = "lang-zh"))]
-    {
-        tokenize_cjk(text)
-    }
+    tokenize_cjk(text)
 }
 
 /// Korean segmentation: lindera/ko-dic when `lang-ko` is enabled, bigrams otherwise.
@@ -92,18 +85,6 @@ fn lindera_segment(text: &str, _dict: &str) -> Vec<String> {
         .collect()
 }
 
-#[cfg(feature = "lang-zh")]
-fn jieba_segment(text: &str) -> Vec<String> {
-    use jieba_rs::Jieba;
-    let jieba = Jieba::new();
-    jieba
-        .cut(text, false)
-        .into_iter()
-        .map(|s| s.to_string())
-        .filter(|s| !s.trim().is_empty())
-        .collect()
-}
-
 #[cfg(feature = "lang-th")]
 fn icu_segment_thai(text: &str) -> Vec<String> {
     use icu_segmenter::WordSegmenter;
@@ -124,21 +105,11 @@ mod tests {
     use super::*;
 
     #[test]
-    #[cfg(not(feature = "lang-zh"))]
-    fn fallback_to_bigrams_chinese() {
-        // Without lang-zh feature, should use CJK bigrams.
+    fn bigrams_chinese() {
         let tokens = segment("全文検索", "zh");
         assert_eq!(tokens, vec!["全文", "文検", "検索"]);
     }
 
-    #[test]
-    #[cfg(feature = "lang-zh")]
-    fn dictionary_segmentation_chinese() {
-        // With lang-zh feature, jieba produces dictionary-based tokens.
-        let tokens = segment("全文検索", "zh");
-        assert!(!tokens.is_empty());
-    }
-
     #[test]
     #[cfg(not(feature = "lang-ja"))]
     fn fallback_to_bigrams_japanese() {
diff --git a/nodedb/src/control/server/pgwire/ddl/dsl.rs b/nodedb/src/control/server/pgwire/ddl/dsl.rs
deleted file mode 100644
index 95f173cf..00000000
--- a/nodedb/src/control/server/pgwire/ddl/dsl.rs
+++ /dev/null
@@ -1,594 +0,0 @@
-//! NodeDB DSL extensions — custom SQL-like commands beyond standard SQL.
-//!
-//! - SEARCH <collection> USING VECTOR(<field>, ARRAY[...], <k>)
-//! - SEARCH <collection> USING VECTOR(...) WITH FILTER <predicate>
-//! - SEARCH <collection> USING FUSION(vector=..., graph=..., top_k=...)
-//! - CREATE VECTOR INDEX <name> ON <collection> [METRIC cosine|l2] [M <m>] [EF_CONSTRUCTION <ef>]
-//! - CREATE FULLTEXT INDEX <name> ON <collection> (<field>)
-//! - CRDT MERGE INTO <collection> FROM <source_id> TO <target_id>
-
-use std::sync::Arc;
-use std::time::Duration;
-
-use futures::stream;
-use pgwire::api::results::{DataRowEncoder, QueryResponse, Response, Tag};
-use pgwire::error::PgWireResult;
-
-use crate::bridge::envelope::PhysicalPlan;
-use crate::bridge::physical_plan::{CrdtOp, GraphOp, VectorOp};
-use crate::control::security::identity::AuthenticatedIdentity;
-use crate::control::state::SharedState;
-
-use super::super::types::{sqlstate_error, text_field};
-
-// ── SEARCH USING VECTOR ─────────────────────────────────────────────
-
-/// SEARCH <collection> USING VECTOR(ARRAY[...], <k>)
-/// SEARCH <collection> USING VECTOR(ARRAY[...], <k>) WITH FILTER <field> <op> <value>
-pub async fn search_vector(
-    state: &SharedState,
-    identity: &AuthenticatedIdentity,
-    sql: &str,
-) -> PgWireResult<Vec<Response>> {
-    // Extract collection name.
-    let parts: Vec<&str> = sql.split_whitespace().collect();
-    if parts.len() < 4 {
-        return Err(sqlstate_error(
-            "42601",
-            "syntax: SEARCH <collection> USING VECTOR(ARRAY[...], <k>)",
-        ));
-    }
-    let collection = parts[1];
-    let tenant_id = identity.tenant_id;
-
-    // Parse field name and ARRAY[...] from VECTOR(field, ARRAY[...], k) or VECTOR(ARRAY[...], k).
-    let vector_paren = sql.find("VECTOR(").or_else(|| sql.find("vector("));
-    let vector_paren = match vector_paren {
-        Some(i) => i + 7,
-        None => {
-            return Err(sqlstate_error(
-                "42601",
-                "expected VECTOR(...) in SEARCH USING VECTOR",
-            ));
-        }
-    };
-
-    // Extract field name if present before ARRAY[.
-    let array_start = sql.find("ARRAY[").or_else(|| sql.find("array["));
-    let array_start = match array_start {
-        Some(i) => i + 6,
-        None => {
-            return Err(sqlstate_error(
-                "42601",
-                "expected ARRAY[...] in SEARCH USING VECTOR",
-            ));
-        }
-    };
-
-    // Field name is between VECTOR( and ARRAY[ (trimmed, comma-stripped).
-    let field_name = sql[vector_paren..array_start - 6]
-        .trim()
-        .trim_end_matches(',')
-        .trim()
-        .to_string();
-
-    let array_end = sql[array_start..].find(']').map(|i| i + array_start);
-    let array_end = match array_end {
-        Some(i) => i,
-        None => {
-            return Err(sqlstate_error("42601", "unterminated ARRAY["));
-        }
-    };
-
-    let vector_str = &sql[array_start..array_end];
-    let query_vector: Vec<f32> = vector_str
-        .split(',')
-        .filter_map(|s| s.trim().parse::<f32>().ok())
-        .collect();
-
-    if query_vector.is_empty() {
-        return Err(sqlstate_error("42601", "empty query vector"));
-    }
-
-    // Parse top_k: number after the closing bracket.
-    let after_array = &sql[array_end + 1..];
-    let top_k = after_array
-        .split(|c: char| !c.is_ascii_digit())
-        .find(|s| !s.is_empty())
-        .and_then(|s| s.parse::<usize>().ok())
-        .unwrap_or(10);
-
-    // Future: parse WITH FILTER predicates, evaluate against documents, build Roaring bitmap.
-    let filter_bitmap: Option<std::sync::Arc<[u8]>> = None;
-
-    let plan = PhysicalPlan::Vector(VectorOp::Search {
-        collection: collection.to_string(),
-        query_vector: Arc::from(query_vector.as_slice()),
-        top_k,
-        ef_search: 0,
-        filter_bitmap,
-        field_name,
-        rls_filters: Vec::new(),
-    });
-
-    let payload = super::sync_dispatch::dispatch_async(
-        state,
-        tenant_id,
-        collection,
-        plan,
-        Duration::from_secs(state.tuning.network.default_deadline_secs),
-    )
-    .await
-    .map_err(|e| sqlstate_error("XX000", &e.to_string()))?;
-
-    let schema = Arc::new(vec![text_field("result")]);
-    let text = crate::data::executor::response_codec::decode_payload_to_json(&payload);
-    let mut encoder = DataRowEncoder::new(schema.clone());
-    encoder
-        .encode_field(&text)
-        .map_err(|e| sqlstate_error("XX000", &e.to_string()))?;
-    let row = encoder.take_row();
-
-    Ok(vec![Response::Query(QueryResponse::new(
-        schema,
-        stream::iter(vec![Ok(row)]),
-    ))])
-}
-
-// ── SEARCH USING FUSION ─────────────────────────────────────────────
-
-/// SEARCH <collection> USING FUSION(VECTOR(ARRAY[...], <k>), GRAPH(<label>, <depth>), TOP <n>)
-pub async fn search_fusion(
-    state: &SharedState,
-    identity: &AuthenticatedIdentity,
-    sql: &str,
-) -> PgWireResult<Vec<Response>> {
-    let parts: Vec<&str> = sql.split_whitespace().collect();
-    if parts.len() < 4 {
-        return Err(sqlstate_error(
-            "42601",
-            "syntax: SEARCH <collection> USING FUSION(...)",
-        ));
-    }
-    let collection = parts[1];
-    let tenant_id = identity.tenant_id;
-
-    // Parse query vector from ARRAY[...].
-    let array_start = sql.find("ARRAY[").or_else(|| sql.find("array["));
-    let array_start = match array_start {
-        Some(i) => i + 6,
-        None => {
-            return Err(sqlstate_error("42601", "expected ARRAY[...] in FUSION"));
-        }
-    };
-    let array_end = sql[array_start..].find(']').map(|i| i + array_start);
-    let array_end = match array_end {
-        Some(i) => i,
-        None => {
-            return Err(sqlstate_error("42601", "unterminated ARRAY["));
-        }
-    };
-
-    let vector_str = &sql[array_start..array_end];
-    let query_vector: Vec<f32> = vector_str
-        .split(',')
-        .filter_map(|s| s.trim().parse::<f32>().ok())
-        .collect();
-
-    if query_vector.is_empty() {
-        return Err(sqlstate_error("42601", "empty query vector in FUSION"));
-    }
-
-    // Extract numeric parameters (vector_top_k, expansion_depth, final_top_k).
-    let upper = sql.to_uppercase();
-    let vector_top_k = extract_param(&upper, "VECTOR_TOP_K").unwrap_or(20);
-    let expansion_depth = extract_param(&upper, "DEPTH").unwrap_or(2);
-    let final_top_k = extract_param(&upper, "TOP").unwrap_or(10);
-
-    // Extract edge label if specified.
-    let edge_label = extract_string_param(sql, "LABEL");
-
-    let plan = PhysicalPlan::Graph(GraphOp::RagFusion {
-        collection: collection.to_string(),
-        query_vector: Arc::from(query_vector.as_slice()),
-        vector_top_k,
-        edge_label,
-        direction: crate::engine::graph::edge_store::Direction::Out,
-        expansion_depth,
-        final_top_k,
-        rrf_k: (60.0, 60.0),
-        options: crate::engine::graph::traversal_options::GraphTraversalOptions::default(),
-    });
-
-    let payload = super::sync_dispatch::dispatch_async(
-        state,
-        tenant_id,
-        collection,
-        plan,
-        Duration::from_secs(state.tuning.network.default_deadline_secs),
-    )
-    .await
-    .map_err(|e| sqlstate_error("XX000", &e.to_string()))?;
-
-    let schema = Arc::new(vec![text_field("result")]);
-    let text = crate::data::executor::response_codec::decode_payload_to_json(&payload);
-    let mut encoder = DataRowEncoder::new(schema.clone());
-    encoder
-        .encode_field(&text)
-        .map_err(|e| sqlstate_error("XX000", &e.to_string()))?;
-    let row = encoder.take_row();
-
-    Ok(vec![Response::Query(QueryResponse::new(
-        schema,
-        stream::iter(vec![Ok(row)]),
-    ))])
-}
-
-// ── CREATE VECTOR INDEX ─────────────────────────────────────────────
-
-/// CREATE VECTOR INDEX <name> ON <collection> [METRIC cosine|l2|hamming] [M <m>] [EF_CONSTRUCTION <ef>] [DIM <dim>]
-pub async fn create_vector_index(
-    state: &SharedState,
-    identity: &AuthenticatedIdentity,
-    parts: &[&str],
-) -> PgWireResult<Vec<Response>> {
-    // CREATE VECTOR INDEX <name> ON <collection> [options...]
-    if parts.len() < 6 {
-        return Err(sqlstate_error(
-            "42601",
-            "syntax: CREATE VECTOR INDEX <name> ON <collection> [METRIC cosine|l2] [M <m>] [EF_CONSTRUCTION <ef>] [DIM <dim>]",
-        ));
-    }
-
-    let index_name = parts[3];
-    if !parts[4].eq_ignore_ascii_case("ON") {
-        return Err(sqlstate_error("42601", "expected ON after index name"));
-    }
-    let collection = parts[5];
-    let tenant_id = identity.tenant_id;
-
-    // Parse optional parameters.
-    let upper_parts: Vec<String> = parts.iter().map(|p| p.to_uppercase()).collect();
-
-    let metric = find_param_str(&upper_parts, "METRIC").unwrap_or_else(|| "COSINE".into());
-    let m = find_param_usize(&upper_parts, "M").unwrap_or(16);
-    let ef_construction = find_param_usize(&upper_parts, "EF_CONSTRUCTION").unwrap_or(200);
-    let dim = find_param_usize(&upper_parts, "DIM").unwrap_or(0);
-
-    super::owner_propose::propose_owner(
-        state,
-        "vector_index",
-        tenant_id,
-        index_name,
-        &identity.username,
-    )?;
-
-    // Dispatch SetParams to the Data Plane so vector_params is populated.
-    // This enables schemaless collections to index vector fields on INSERT.
-    let vshard = crate::types::VShardId::from_collection(collection);
-    let set_params_plan = crate::bridge::envelope::PhysicalPlan::Vector(
-        crate::bridge::physical_plan::VectorOp::SetParams {
-            collection: collection.to_string(),
-            m,
-            ef_construction,
-            metric: metric.to_lowercase(),
-            index_type: String::new(),
-            pq_m: 0,
-            ivf_cells: 0,
-            ivf_nprobe: 0,
-        },
-    );
-    let _ = crate::control::server::dispatch_utils::dispatch_to_data_plane(
-        state,
-        tenant_id,
-        vshard,
-        set_params_plan,
-        0,
-    )
-    .await;
-
-    state.audit_record(
-        crate::control::security::audit::AuditEvent::AdminAction,
-        Some(tenant_id),
-        &identity.username,
-        &format!(
-            "created vector index '{index_name}' on '{collection}' (metric={metric}, m={m}, ef_construction={ef_construction}, dim={dim})"
-        ),
-    );
-
-    Ok(vec![Response::Execution(Tag::new("CREATE VECTOR INDEX"))])
-}
-
-// ── CREATE FULLTEXT INDEX ───────────────────────────────────────────
-
-/// CREATE FULLTEXT INDEX <name> ON <collection> (<field>)
-pub fn create_fulltext_index(
-    state: &SharedState,
-    identity: &AuthenticatedIdentity,
-    parts: &[&str],
-) -> PgWireResult<Vec<Response>> {
-    if parts.len() < 7 {
-        return Err(sqlstate_error(
-            "42601",
-            "syntax: CREATE FULLTEXT INDEX <name> ON <collection> (<field>)",
-        ));
-    }
-
-    let index_name = parts[3];
-    if !parts[4].eq_ignore_ascii_case("ON") {
-        return Err(sqlstate_error("42601", "expected ON after index name"));
-    }
-    let collection = parts[5];
-    let field = parts[6].trim_matches(|c| c == '(' || c == ')');
-    let tenant_id = identity.tenant_id;
-
-    super::owner_propose::propose_owner(
-        state,
-        "fulltext_index",
-        tenant_id,
-        index_name,
-        &identity.username,
-    )?;
-
-    state.audit_record(
-        crate::control::security::audit::AuditEvent::AdminAction,
-        Some(tenant_id),
-        &identity.username,
-        &format!("created fulltext index '{index_name}' on '{collection}' ({field})"),
-    );
-
-    Ok(vec![Response::Execution(Tag::new("CREATE FULLTEXT INDEX"))])
-}
-
-// ── CREATE SEARCH INDEX ────────────────────────────────────────────
-
-/// CREATE SEARCH INDEX ON <collection> FIELDS <field1>[, <field2>...] [ANALYZER '<name>'] [FUZZY true|false]
-///
-/// Higher-level alias for CREATE FULLTEXT INDEX. Auto-generates an index name,
-/// accepts multiple fields and optional analyzer/fuzzy configuration.
-pub fn create_search_index(
-    state: &SharedState,
-    identity: &AuthenticatedIdentity,
-    sql: &str,
-) -> PgWireResult<Vec<Response>> {
-    let upper = sql.to_uppercase();
-
-    // Extract collection name: ON <collection> FIELDS ...
-    let on_pos = upper.find(" ON ").ok_or_else(|| {
-        sqlstate_error(
-            "42601",
-            "syntax: CREATE SEARCH INDEX ON <collection> FIELDS <field> [ANALYZER 'name'] [FUZZY true]",
-        )
-    })?;
-    let after_on = sql[on_pos + 4..].trim_start();
-    let fields_pos = upper.find(" FIELDS ").ok_or_else(|| {
-        sqlstate_error(
-            "42601",
-            "syntax: CREATE SEARCH INDEX ON <collection> FIELDS <field> [ANALYZER 'name'] [FUZZY true]",
-        )
-    })?;
-
-    let collection = after_on[..fields_pos - on_pos - 4].trim().to_lowercase();
-    if collection.is_empty() {
-        return Err(sqlstate_error("42601", "missing collection name"));
-    }
-
-    // Extract fields: comma-separated until ANALYZER or FUZZY or end.
-    let after_fields = &sql[fields_pos + 8..];
-    let fields_end = upper[fields_pos + 8..]
-        .find(" ANALYZER ")
-        .or_else(|| upper[fields_pos + 8..].find(" FUZZY "))
-        .unwrap_or(after_fields.len());
-    let fields_str = after_fields[..fields_end].trim();
-    let fields: Vec<&str> = fields_str.split(',').map(|s| s.trim()).collect();
-
-    if fields.is_empty() || fields[0].is_empty() {
-        return Err(sqlstate_error("42601", "missing field list"));
-    }
-
-    let tenant_id = identity.tenant_id;
-
-    // Register fulltext index for each field.
-    for field in &fields {
-        let index_name = format!("fts_{}_{}", collection, field);
-
-        super::owner_propose::propose_owner(
-            state,
-            "fulltext_index",
-            tenant_id,
-            &index_name,
-            &identity.username,
-        )?;
-
-        state.audit_record(
-            crate::control::security::audit::AuditEvent::AdminAction,
-            Some(tenant_id),
-            &identity.username,
-            &format!("created search index '{index_name}' on '{collection}' ({field})"),
-        );
-    }
-
-    Ok(vec![Response::Execution(Tag::new("CREATE SEARCH INDEX"))])
-}
-
-// ── CREATE SPARSE INDEX ─────────────────────────────────────────────
-
-/// CREATE SPARSE INDEX [name] ON <collection> (<field>)
-pub fn create_sparse_index(
-    state: &SharedState,
-    identity: &AuthenticatedIdentity,
-    parts: &[&str],
-) -> PgWireResult<Vec<Response>> {
-    // CREATE SPARSE INDEX <name> ON <collection> (<field>)
-    // or: CREATE SPARSE INDEX ON <collection> (<field>)
-    if parts.len() < 6 {
-        return Err(sqlstate_error(
-            "42601",
-            "syntax: CREATE SPARSE INDEX [name] ON <collection> (<field>)",
-        ));
-    }
-
-    // Determine if name is provided or omitted.
-    let (index_name, on_idx) = if parts[3].eq_ignore_ascii_case("ON") {
-        // No name: CREATE SPARSE INDEX ON collection (field)
-        ("_auto_sparse".to_string(), 3)
-    } else {
-        // Named: CREATE SPARSE INDEX name ON collection (field)
-        if parts.len() < 7 || !parts[4].eq_ignore_ascii_case("ON") {
-            return Err(sqlstate_error("42601", "expected ON after index name"));
-        }
-        (parts[3].to_string(), 4)
-    };
-
-    let collection = parts
-        .get(on_idx + 1)
-        .ok_or_else(|| sqlstate_error("42601", "expected collection name after ON"))?;
-
-    let field = parts
-        .get(on_idx + 2)
-        .map(|s| s.trim_matches(|c| c == '(' || c == ')'))
-        .unwrap_or("_sparse");
-
-    let tenant_id = identity.tenant_id;
-
-    super::owner_propose::propose_owner(
-        state,
-        "sparse_index",
-        tenant_id,
-        &index_name,
-        &identity.username,
-    )?;
-
-    state.audit_record(
-        crate::control::security::audit::AuditEvent::AdminAction,
-        Some(tenant_id),
-        &identity.username,
-        &format!("created sparse index '{index_name}' on '{collection}' ({field})"),
-    );
-
-    Ok(vec![Response::Execution(Tag::new("CREATE SPARSE INDEX"))])
-}
-
-// ── CRDT MERGE INTO ─────────────────────────────────────────────────
-
-/// CRDT MERGE INTO <collection> FROM '<source_id>' TO '<target_id>'
-pub async fn crdt_merge(
-    state: &SharedState,
-    identity: &AuthenticatedIdentity,
-    parts: &[&str],
-) -> PgWireResult<Vec<Response>> {
-    // CRDT MERGE INTO <collection> FROM '<source>' TO '<target>'
-    if parts.len() < 7 {
-        return Err(sqlstate_error(
-            "42601",
-            "syntax: CRDT MERGE INTO <collection> FROM '<source_id>' TO '<target_id>'",
-        ));
-    }
-
-    let collection = parts[3];
-    let tenant_id = identity.tenant_id;
-
-    let from_idx = parts
-        .iter()
-        .position(|p| p.eq_ignore_ascii_case("FROM"))
-        .ok_or_else(|| sqlstate_error("42601", "expected FROM keyword"))?;
-    let to_idx = parts
-        .iter()
-        .position(|p| p.eq_ignore_ascii_case("TO"))
-        .ok_or_else(|| sqlstate_error("42601", "expected TO keyword"))?;
-
-    let source_id = parts
-        .get(from_idx + 1)
-        .map(|s| s.trim_matches('\'').trim_matches('"'))
-        .ok_or_else(|| sqlstate_error("42601", "missing source document ID"))?;
-    let target_id = parts
-        .get(to_idx + 1)
-        .map(|s| s.trim_matches('\'').trim_matches('"'))
-        .ok_or_else(|| sqlstate_error("42601", "missing target document ID"))?;
-
-    // Read source CRDT state.
-    let source_plan = PhysicalPlan::Crdt(CrdtOp::Read {
-        collection: collection.to_string(),
-        document_id: source_id.to_string(),
-    });
-
-    let source_bytes = super::sync_dispatch::dispatch_async(
-        state,
-        tenant_id,
-        collection,
-        source_plan,
-        Duration::from_secs(state.tuning.network.default_deadline_secs),
-    )
-    .await
-    .map_err(|e| sqlstate_error("XX000", &e.to_string()))?;
-    if source_bytes.is_empty() {
-        return Err(sqlstate_error(
-            "02000",
-            &format!("source document '{source_id}' not found"),
-        ));
-    }
-
-    // Apply source state as a delta to target.
-    let apply_plan = PhysicalPlan::Crdt(CrdtOp::Apply {
-        collection: collection.to_string(),
-        document_id: target_id.to_string(),
-        delta: source_bytes,
-        peer_id: identity.user_id,
-        mutation_id: 0,
-    });
-
-    super::sync_dispatch::dispatch_async(
-        state,
-        tenant_id,
-        collection,
-        apply_plan,
-        Duration::from_secs(state.tuning.network.default_deadline_secs),
-    )
-    .await
-    .map_err(|e| sqlstate_error("XX000", &e.to_string()))?;
-
-    state.audit_record(
-        crate::control::security::audit::AuditEvent::AdminAction,
-        Some(tenant_id),
-        &identity.username,
-        &format!("CRDT merge: {source_id} → {target_id} in '{collection}'"),
-    );
-
-    Ok(vec![Response::Execution(Tag::new("CRDT MERGE"))])
-}
-
-// ── Helpers ─────────────────────────────────────────────────────────
-
-fn extract_param(upper: &str, name: &str) -> Option<usize> {
-    let idx = upper.find(name)?;
-    let rest = &upper[idx + name.len()..];
-    rest.split(|c: char| !c.is_ascii_digit())
-        .find(|s| !s.is_empty())
-        .and_then(|s| s.parse().ok())
-}
-
-fn extract_string_param(sql: &str, name: &str) -> Option<String> {
-    let upper = sql.to_uppercase();
-    let idx = upper.find(name)?;
-    let rest = &sql[idx + name.len()..];
-    let rest = rest.trim();
-    if rest.starts_with('\'') || rest.starts_with('"') {
-        let quote = rest.chars().next()?;
-        let end = rest[1..].find(quote)?;
-        Some(rest[1..end + 1].to_string())
-    } else {
-        rest.split_whitespace().next().map(|s| s.to_string())
-    }
-}
-
-fn find_param_str(upper_parts: &[String], name: &str) -> Option<String> {
-    let idx = upper_parts.iter().position(|p| p == name)?;
-    upper_parts.get(idx + 1).cloned()
-}
-
-fn find_param_usize(upper_parts: &[String], name: &str) -> Option<usize> {
-    let idx = upper_parts.iter().position(|p| p == name)?;
-    upper_parts
-        .get(idx + 1)
-        .and_then(|s| s.parse::<usize>().ok())
-}
diff --git a/nodedb/src/control/server/pgwire/ddl/dsl/crdt_merge.rs b/nodedb/src/control/server/pgwire/ddl/dsl/crdt_merge.rs
new file mode 100644
index 00000000..a7d0e3d0
--- /dev/null
+++ b/nodedb/src/control/server/pgwire/ddl/dsl/crdt_merge.rs
@@ -0,0 +1,95 @@
+//! `CRDT MERGE INTO` DSL handler.
+
+use std::time::Duration;
+
+use pgwire::api::results::{Response, Tag};
+use pgwire::error::PgWireResult;
+
+use crate::bridge::envelope::PhysicalPlan;
+use crate::bridge::physical_plan::CrdtOp;
+use crate::control::security::identity::AuthenticatedIdentity;
+use crate::control::server::pgwire::types::sqlstate_error;
+use crate::control::state::SharedState;
+
+/// CRDT MERGE INTO <collection> FROM '<source_id>' TO '<target_id>'
+pub async fn crdt_merge(
+    state: &SharedState,
+    identity: &AuthenticatedIdentity,
+    parts: &[&str],
+) -> PgWireResult<Vec<Response>> {
+    if parts.len() < 7 {
+        return Err(sqlstate_error(
+            "42601",
+            "syntax: CRDT MERGE INTO <collection> FROM '<source_id>' TO '<target_id>'",
+        ));
+    }
+
+    let collection = parts[3];
+    let tenant_id = identity.tenant_id;
+
+    let from_idx = parts
+        .iter()
+        .position(|p| p.eq_ignore_ascii_case("FROM"))
+        .ok_or_else(|| sqlstate_error("42601", "expected FROM keyword"))?;
+    let to_idx = parts
+        .iter()
+        .position(|p| p.eq_ignore_ascii_case("TO"))
+        .ok_or_else(|| sqlstate_error("42601", "expected TO keyword"))?;
+
+    let source_id = parts
+        .get(from_idx + 1)
+        .map(|s| s.trim_matches('\'').trim_matches('"'))
+        .ok_or_else(|| sqlstate_error("42601", "missing source document ID"))?;
+    let target_id = parts
+        .get(to_idx + 1)
+        .map(|s| s.trim_matches('\'').trim_matches('"'))
+        .ok_or_else(|| sqlstate_error("42601", "missing target document ID"))?;
+
+    let source_plan = PhysicalPlan::Crdt(CrdtOp::Read {
+        collection: collection.to_string(),
+        document_id: source_id.to_string(),
+    });
+
+    let source_bytes = crate::control::server::pgwire::ddl::sync_dispatch::dispatch_async(
+        state,
+        tenant_id,
+        collection,
+        source_plan,
+        Duration::from_secs(state.tuning.network.default_deadline_secs),
+    )
+    .await
+    .map_err(|e| sqlstate_error("XX000", &e.to_string()))?;
+    if source_bytes.is_empty() {
+        return Err(sqlstate_error(
+            "02000",
+            &format!("source document '{source_id}' not found"),
+        ));
+    }
+
+    let apply_plan = PhysicalPlan::Crdt(CrdtOp::Apply {
+        collection: collection.to_string(),
+        document_id: target_id.to_string(),
+        delta: source_bytes,
+        peer_id: identity.user_id,
+        mutation_id: 0,
+    });
+
+    crate::control::server::pgwire::ddl::sync_dispatch::dispatch_async(
+        state,
+        tenant_id,
+        collection,
+        apply_plan,
+        Duration::from_secs(state.tuning.network.default_deadline_secs),
+    )
+    .await
+    .map_err(|e| sqlstate_error("XX000", &e.to_string()))?;
+
+    state.audit_record(
+        crate::control::security::audit::AuditEvent::AdminAction,
+        Some(tenant_id),
+        &identity.username,
+        &format!("CRDT merge: {source_id} → {target_id} in '{collection}'"),
+    );
+
+    Ok(vec![Response::Execution(Tag::new("CRDT MERGE"))])
+}
diff --git a/nodedb/src/control/server/pgwire/ddl/dsl/fulltext_index.rs b/nodedb/src/control/server/pgwire/ddl/dsl/fulltext_index.rs
new file mode 100644
index 00000000..ce32373f
--- /dev/null
+++ b/nodedb/src/control/server/pgwire/ddl/dsl/fulltext_index.rs
@@ -0,0 +1,47 @@
+//! `CREATE FULLTEXT INDEX` DSL handler.
+
+use pgwire::api::results::{Response, Tag};
+use pgwire::error::PgWireResult;
+
+use crate::control::security::identity::AuthenticatedIdentity;
+use crate::control::server::pgwire::types::sqlstate_error;
+use crate::control::state::SharedState;
+
+/// CREATE FULLTEXT INDEX <name> ON <collection> (<field>)
+pub fn create_fulltext_index(
+    state: &SharedState,
+    identity: &AuthenticatedIdentity,
+    parts: &[&str],
+) -> PgWireResult<Vec<Response>> {
+    if parts.len() < 7 {
+        return Err(sqlstate_error(
+            "42601",
+            "syntax: CREATE FULLTEXT INDEX <name> ON <collection> (<field>)",
+        ));
+    }
+
+    let index_name = parts[3];
+    if !parts[4].eq_ignore_ascii_case("ON") {
+        return Err(sqlstate_error("42601", "expected ON after index name"));
+    }
+    let collection = parts[5];
+    let field = parts[6].trim_matches(|c| c == '(' || c == ')');
+    let tenant_id = identity.tenant_id;
+
+    super::super::owner_propose::propose_owner(
+        state,
+        "fulltext_index",
+        tenant_id,
+        index_name,
+        &identity.username,
+    )?;
+
+    state.audit_record(
+        crate::control::security::audit::AuditEvent::AdminAction,
+        Some(tenant_id),
+        &identity.username,
+        &format!("created fulltext index '{index_name}' on '{collection}' ({field})"),
+    );
+
+    Ok(vec![Response::Execution(Tag::new("CREATE FULLTEXT INDEX"))])
+}
diff --git a/nodedb/src/control/server/pgwire/ddl/dsl/helpers.rs b/nodedb/src/control/server/pgwire/ddl/dsl/helpers.rs
new file mode 100644
index 00000000..c17297ef
--- /dev/null
+++ b/nodedb/src/control/server/pgwire/ddl/dsl/helpers.rs
@@ -0,0 +1,35 @@
+//! Shared parameter-extraction helpers for DSL handlers.
+
+pub(super) fn extract_param(upper: &str, name: &str) -> Option<usize> {
+    let idx = upper.find(name)?;
+    let rest = &upper[idx + name.len()..];
+    rest.split(|c: char| !c.is_ascii_digit())
+        .find(|s| !s.is_empty())
+        .and_then(|s| s.parse().ok())
+}
+
+pub(super) fn extract_string_param(sql: &str, name: &str) -> Option<String> {
+    let upper = sql.to_uppercase();
+    let idx = upper.find(name)?;
+    let rest = &sql[idx + name.len()..];
+    let rest = rest.trim();
+    if rest.starts_with('\'') || rest.starts_with('"') {
+        let quote = rest.chars().next()?;
+        let end = rest[1..].find(quote)?;
+        Some(rest[1..end + 1].to_string())
+    } else {
+        rest.split_whitespace().next().map(|s| s.to_string())
+    }
+}
+
+pub(super) fn find_param_str(upper_parts: &[String], name: &str) -> Option<String> {
+    let idx = upper_parts.iter().position(|p| p == name)?;
+    upper_parts.get(idx + 1).cloned()
+}
+
+pub(super) fn find_param_usize(upper_parts: &[String], name: &str) -> Option<usize> {
+    let idx = upper_parts.iter().position(|p| p == name)?;
+    upper_parts
+        .get(idx + 1)
+        .and_then(|s| s.parse::<usize>().ok())
+}
diff --git a/nodedb/src/control/server/pgwire/ddl/dsl/mod.rs b/nodedb/src/control/server/pgwire/ddl/dsl/mod.rs
new file mode 100644
index 00000000..0b256430
--- /dev/null
+++ b/nodedb/src/control/server/pgwire/ddl/dsl/mod.rs
@@ -0,0 +1,27 @@
+//! NodeDB DSL extensions — custom SQL-like commands beyond standard SQL.
+//!
+//! - SEARCH <collection> USING VECTOR(<field>, ARRAY[...], <k>)
+//! - SEARCH <collection> USING FUSION(vector=..., graph=..., top_k=...)
+//! - CREATE VECTOR INDEX <name> ON <collection> [METRIC ...] [M ...] [EF_CONSTRUCTION ...] [DIM ...]
+//!   [INDEX_TYPE hnsw|hnsw_pq|ivf_pq] [PQ_M ...] [IVF_CELLS ...] [IVF_NPROBE ...]
+//! - CREATE FULLTEXT INDEX <name> ON <collection> (<field>)
+//! - CREATE SEARCH INDEX ON <collection> FIELDS ...
+//! - CREATE SPARSE INDEX [name] ON <collection> (<field>)
+//! - CRDT MERGE INTO <collection> FROM <source_id> TO <target_id>
+
+mod crdt_merge;
+mod fulltext_index;
+mod helpers;
+mod search_fusion;
+mod search_index;
+mod search_vector;
+mod sparse_index;
+mod vector_index;
+
+pub use crdt_merge::crdt_merge;
+pub use fulltext_index::create_fulltext_index;
+pub use search_fusion::search_fusion;
+pub use search_index::create_search_index;
+pub use search_vector::search_vector;
+pub use sparse_index::create_sparse_index;
+pub use vector_index::create_vector_index;
diff --git a/nodedb/src/control/server/pgwire/ddl/dsl/search_fusion.rs b/nodedb/src/control/server/pgwire/ddl/dsl/search_fusion.rs
new file mode 100644
index 00000000..05fd19e9
--- /dev/null
+++ b/nodedb/src/control/server/pgwire/ddl/dsl/search_fusion.rs
@@ -0,0 +1,100 @@
+//! `SEARCH <collection> USING FUSION(...)` DSL (vector + graph fusion).
+
+use std::sync::Arc;
+use std::time::Duration;
+
+use futures::stream;
+use pgwire::api::results::{DataRowEncoder, QueryResponse, Response};
+use pgwire::error::PgWireResult;
+
+use crate::bridge::envelope::PhysicalPlan;
+use crate::bridge::physical_plan::GraphOp;
+use crate::control::security::identity::AuthenticatedIdentity;
+use crate::control::server::pgwire::types::{sqlstate_error, text_field};
+use crate::control::state::SharedState;
+
+use super::helpers::{extract_param, extract_string_param};
+
+/// SEARCH <collection> USING FUSION(VECTOR(ARRAY[...], <k>), GRAPH(<label>, <depth>), TOP <n>)
+pub async fn search_fusion(
+    state: &SharedState,
+    identity: &AuthenticatedIdentity,
+    sql: &str,
+) -> PgWireResult<Vec<Response>> {
+    let parts: Vec<&str> = sql.split_whitespace().collect();
+    if parts.len() < 4 {
+        return Err(sqlstate_error(
+            "42601",
+            "syntax: SEARCH <collection> USING FUSION(...)",
+        ));
+    }
+    let collection = parts[1];
+    let tenant_id = identity.tenant_id;
+
+    let array_start = sql.find("ARRAY[").or_else(|| sql.find("array["));
+    let array_start = match array_start {
+        Some(i) => i + 6,
+        None => {
+            return Err(sqlstate_error("42601", "expected ARRAY[...] in FUSION"));
+        }
+    };
+    let array_end = sql[array_start..].find(']').map(|i| i + array_start);
+    let array_end = match array_end {
+        Some(i) => i,
+        None => {
+            return Err(sqlstate_error("42601", "unterminated ARRAY["));
+        }
+    };
+
+    let vector_str = &sql[array_start..array_end];
+    let query_vector: Vec<f32> = vector_str
+        .split(',')
+        .filter_map(|s| s.trim().parse::<f32>().ok())
+        .collect();
+
+    if query_vector.is_empty() {
+        return Err(sqlstate_error("42601", "empty query vector in FUSION"));
+    }
+
+    let upper = sql.to_uppercase();
+    let vector_top_k = extract_param(&upper, "VECTOR_TOP_K").unwrap_or(20);
+    let expansion_depth = extract_param(&upper, "DEPTH").unwrap_or(2);
+    let final_top_k = extract_param(&upper, "TOP").unwrap_or(10);
+
+    let edge_label = extract_string_param(sql, "LABEL");
+
+    let plan = PhysicalPlan::Graph(GraphOp::RagFusion {
+        collection: collection.to_string(),
+        query_vector: Arc::from(query_vector.as_slice()),
+        vector_top_k,
+        edge_label,
+        direction: crate::engine::graph::edge_store::Direction::Out,
+        expansion_depth,
+        final_top_k,
+        rrf_k: (60.0, 60.0),
+        options: crate::engine::graph::traversal_options::GraphTraversalOptions::default(),
+    });
+
+    let payload = crate::control::server::pgwire::ddl::sync_dispatch::dispatch_async(
+        state,
+        tenant_id,
+        collection,
+        plan,
+        Duration::from_secs(state.tuning.network.default_deadline_secs),
+    )
+    .await
+    .map_err(|e| sqlstate_error("XX000", &e.to_string()))?;
+
+    let schema = Arc::new(vec![text_field("result")]);
+    let text = crate::data::executor::response_codec::decode_payload_to_json(&payload);
+    let mut encoder = DataRowEncoder::new(schema.clone());
+    encoder
+        .encode_field(&text)
+        .map_err(|e| sqlstate_error("XX000", &e.to_string()))?;
+    let row = encoder.take_row();
+
+    Ok(vec![Response::Query(QueryResponse::new(
+        schema,
+        stream::iter(vec![Ok(row)]),
+    ))])
+}
diff --git a/nodedb/src/control/server/pgwire/ddl/dsl/search_index.rs b/nodedb/src/control/server/pgwire/ddl/dsl/search_index.rs
new file mode 100644
index 00000000..62e19f7e
--- /dev/null
+++ b/nodedb/src/control/server/pgwire/ddl/dsl/search_index.rs
@@ -0,0 +1,71 @@
+//! `CREATE SEARCH INDEX` DSL handler (higher-level alias for fulltext).
+
+use pgwire::api::results::{Response, Tag};
+use pgwire::error::PgWireResult;
+
+use crate::control::security::identity::AuthenticatedIdentity;
+use crate::control::server::pgwire::types::sqlstate_error;
+use crate::control::state::SharedState;
+
+/// CREATE SEARCH INDEX ON <collection> FIELDS <field1>[, <field2>...] [ANALYZER '<name>'] [FUZZY true|false]
+pub fn create_search_index(
+    state: &SharedState,
+    identity: &AuthenticatedIdentity,
+    sql: &str,
+) -> PgWireResult<Vec<Response>> {
+    let upper = sql.to_uppercase();
+
+    let on_pos = upper.find(" ON ").ok_or_else(|| {
+        sqlstate_error(
+            "42601",
+            "syntax: CREATE SEARCH INDEX ON <collection> FIELDS <field> [ANALYZER 'name'] [FUZZY true]",
+        )
+    })?;
+    let after_on = sql[on_pos + 4..].trim_start();
+    let fields_pos = upper.find(" FIELDS ").ok_or_else(|| {
+        sqlstate_error(
+            "42601",
+            "syntax: CREATE SEARCH INDEX ON <collection> FIELDS <field> [ANALYZER 'name'] [FUZZY true]",
+        )
+    })?;
+
+    let collection = after_on[..fields_pos - on_pos - 4].trim().to_lowercase();
+    if collection.is_empty() {
+        return Err(sqlstate_error("42601", "missing collection name"));
+    }
+
+    let after_fields = &sql[fields_pos + 8..];
+    let fields_end = upper[fields_pos + 8..]
+        .find(" ANALYZER ")
+        .or_else(|| upper[fields_pos + 8..].find(" FUZZY "))
+        .unwrap_or(after_fields.len());
+    let fields_str = after_fields[..fields_end].trim();
+    let fields: Vec<&str> = fields_str.split(',').map(|s| s.trim()).collect();
+
+    if fields.is_empty() || fields[0].is_empty() {
+        return Err(sqlstate_error("42601", "missing field list"));
+    }
+
+    let tenant_id = identity.tenant_id;
+
+    for field in &fields {
+        let index_name = format!("fts_{}_{}", collection, field);
+
+        super::super::owner_propose::propose_owner(
+            state,
+            "fulltext_index",
+            tenant_id,
+            &index_name,
+            &identity.username,
+        )?;
+
+        state.audit_record(
+            crate::control::security::audit::AuditEvent::AdminAction,
+            Some(tenant_id),
+            &identity.username,
+            &format!("created search index '{index_name}' on '{collection}' ({field})"),
+        );
+    }
+
+    Ok(vec![Response::Execution(Tag::new("CREATE SEARCH INDEX"))])
+}
diff --git a/nodedb/src/control/server/pgwire/ddl/dsl/search_vector.rs b/nodedb/src/control/server/pgwire/ddl/dsl/search_vector.rs
new file mode 100644
index 00000000..7d895a80
--- /dev/null
+++ b/nodedb/src/control/server/pgwire/ddl/dsl/search_vector.rs
@@ -0,0 +1,120 @@
+//! `SEARCH <collection> USING VECTOR(...)` DSL.
+
+use std::sync::Arc;
+use std::time::Duration;
+
+use futures::stream;
+use pgwire::api::results::{DataRowEncoder, QueryResponse, Response};
+use pgwire::error::PgWireResult;
+
+use crate::bridge::envelope::PhysicalPlan;
+use crate::bridge::physical_plan::VectorOp;
+use crate::control::security::identity::AuthenticatedIdentity;
+use crate::control::server::pgwire::types::{sqlstate_error, text_field};
+use crate::control::state::SharedState;
+
+/// SEARCH <collection> USING VECTOR(ARRAY[...], <k>)
+/// SEARCH <collection> USING VECTOR(ARRAY[...], <k>) WITH FILTER <field> <op> <value>
+pub async fn search_vector(
+    state: &SharedState,
+    identity: &AuthenticatedIdentity,
+    sql: &str,
+) -> PgWireResult<Vec<Response>> {
+    let parts: Vec<&str> = sql.split_whitespace().collect();
+    if parts.len() < 4 {
+        return Err(sqlstate_error(
+            "42601",
+            "syntax: SEARCH <collection> USING VECTOR(ARRAY[...], <k>)",
+        ));
+    }
+    let collection = parts[1];
+    let tenant_id = identity.tenant_id;
+
+    let vector_paren = sql.find("VECTOR(").or_else(|| sql.find("vector("));
+    let vector_paren = match vector_paren {
+        Some(i) => i + 7,
+        None => {
+            return Err(sqlstate_error(
+                "42601",
+                "expected VECTOR(...) in SEARCH USING VECTOR",
+            ));
+        }
+    };
+
+    let array_start = sql.find("ARRAY[").or_else(|| sql.find("array["));
+    let array_start = match array_start {
+        Some(i) => i + 6,
+        None => {
+            return Err(sqlstate_error(
+                "42601",
+                "expected ARRAY[...] in SEARCH USING VECTOR",
+            ));
+        }
+    };
+
+    let field_name = sql[vector_paren..array_start - 6]
+        .trim()
+        .trim_end_matches(',')
+        .trim()
+        .to_string();
+
+    let array_end = sql[array_start..].find(']').map(|i| i + array_start);
+    let array_end = match array_end {
+        Some(i) => i,
+        None => {
+            return Err(sqlstate_error("42601", "unterminated ARRAY["));
+        }
+    };
+
+    let vector_str = &sql[array_start..array_end];
+    let query_vector: Vec<f32> = vector_str
+        .split(',')
+        .filter_map(|s| s.trim().parse::<f32>().ok())
+        .collect();
+
+    if query_vector.is_empty() {
+        return Err(sqlstate_error("42601", "empty query vector"));
+    }
+
+    let after_array = &sql[array_end + 1..];
+    let top_k = after_array
+        .split(|c: char| !c.is_ascii_digit())
+        .find(|s| !s.is_empty())
+        .and_then(|s| s.parse::<usize>().ok())
+        .unwrap_or(10);
+
+    let filter_bitmap: Option<std::sync::Arc<[u8]>> = None;
+
+    let plan = PhysicalPlan::Vector(VectorOp::Search {
+        collection: collection.to_string(),
+        query_vector: Arc::from(query_vector.as_slice()),
+        top_k,
+        ef_search: 0,
+        filter_bitmap,
+        field_name,
+        rls_filters: Vec::new(),
+    });
+
+    let payload = crate::control::server::pgwire::ddl::sync_dispatch::dispatch_async(
+        state,
+        tenant_id,
+        collection,
+        plan,
+        Duration::from_secs(state.tuning.network.default_deadline_secs),
+    )
+    .await
+    .map_err(|e| sqlstate_error("XX000", &e.to_string()))?;
+
+    let schema = Arc::new(vec![text_field("result")]);
+    let text = crate::data::executor::response_codec::decode_payload_to_json(&payload);
+    let mut encoder = DataRowEncoder::new(schema.clone());
+    encoder
+        .encode_field(&text)
+        .map_err(|e| sqlstate_error("XX000", &e.to_string()))?;
+    let row = encoder.take_row();
+
+    Ok(vec![Response::Query(QueryResponse::new(
+        schema,
+        stream::iter(vec![Ok(row)]),
+    ))])
+}
diff --git a/nodedb/src/control/server/pgwire/ddl/dsl/sparse_index.rs b/nodedb/src/control/server/pgwire/ddl/dsl/sparse_index.rs
new file mode 100644
index 00000000..41b32e20
--- /dev/null
+++ b/nodedb/src/control/server/pgwire/ddl/dsl/sparse_index.rs
@@ -0,0 +1,59 @@
+//! `CREATE SPARSE INDEX` DSL handler.
+
+use pgwire::api::results::{Response, Tag};
+use pgwire::error::PgWireResult;
+
+use crate::control::security::identity::AuthenticatedIdentity;
+use crate::control::server::pgwire::types::sqlstate_error;
+use crate::control::state::SharedState;
+
+/// CREATE SPARSE INDEX [name] ON <collection> (<field>)
+pub fn create_sparse_index(
+    state: &SharedState,
+    identity: &AuthenticatedIdentity,
+    parts: &[&str],
+) -> PgWireResult<Vec<Response>> {
+    if parts.len() < 6 {
+        return Err(sqlstate_error(
+            "42601",
+            "syntax: CREATE SPARSE INDEX [name] ON <collection> (<field>)",
+        ));
+    }
+
+    let (index_name, on_idx) = if parts[3].eq_ignore_ascii_case("ON") {
+        ("_auto_sparse".to_string(), 3)
+    } else {
+        if parts.len() < 7 || !parts[4].eq_ignore_ascii_case("ON") {
+            return Err(sqlstate_error("42601", "expected ON after index name"));
+        }
+        (parts[3].to_string(), 4)
+    };
+
+    let collection = parts
+        .get(on_idx + 1)
+        .ok_or_else(|| sqlstate_error("42601", "expected collection name after ON"))?;
+
+    let field = parts
+        .get(on_idx + 2)
+        .map(|s| s.trim_matches(|c| c == '(' || c == ')'))
+        .unwrap_or("_sparse");
+
+    let tenant_id = identity.tenant_id;
+
+    super::super::owner_propose::propose_owner(
+        state,
+        "sparse_index",
+        tenant_id,
+        &index_name,
+        &identity.username,
+    )?;
+
+    state.audit_record(
+        crate::control::security::audit::AuditEvent::AdminAction,
+        Some(tenant_id),
+        &identity.username,
+        &format!("created sparse index '{index_name}' on '{collection}' ({field})"),
+    );
+
+    Ok(vec![Response::Execution(Tag::new("CREATE SPARSE INDEX"))])
+}
diff --git a/nodedb/src/control/server/pgwire/ddl/dsl/vector_index.rs b/nodedb/src/control/server/pgwire/ddl/dsl/vector_index.rs
new file mode 100644
index 00000000..8a7872ad
--- /dev/null
+++ b/nodedb/src/control/server/pgwire/ddl/dsl/vector_index.rs
@@ -0,0 +1,151 @@
+//! `CREATE VECTOR INDEX` DSL handler.
+//!
+//! Parses the full quantization-parameter surface advertised in `docs/vectors.md`:
+//! INDEX_TYPE (hnsw | hnsw_pq | ivf_pq), PQ_M, IVF_CELLS, IVF_NPROBE. Unknown
+//! INDEX_TYPE values are rejected at the DDL layer; invalid combinations
+//! (e.g. PQ_M that does not divide DIM) are rejected before reaching the engine.
+
+use pgwire::api::results::{Response, Tag};
+use pgwire::error::PgWireResult;
+
+use crate::bridge::envelope::PhysicalPlan;
+use crate::bridge::physical_plan::VectorOp;
+use crate::control::security::identity::AuthenticatedIdentity;
+use crate::control::server::pgwire::types::sqlstate_error;
+use crate::control::state::SharedState;
+
+use super::helpers::{find_param_str, find_param_usize};
+
+/// Supported INDEX_TYPE keywords — kept in sync with
+/// `nodedb_vector::index_config::IndexType`.
+const KNOWN_INDEX_TYPES: &[&str] = &["hnsw", "hnsw_pq", "ivf_pq"];
+
+/// CREATE VECTOR INDEX <name> ON <collection>
+///   [METRIC cosine|l2|inner_product|...] [M <m>] [EF_CONSTRUCTION <ef>] [DIM <dim>]
+///   [INDEX_TYPE hnsw|hnsw_pq|ivf_pq] [PQ_M <m>] [IVF_CELLS <n>] [IVF_NPROBE <n>]
+pub async fn create_vector_index(
+    state: &SharedState,
+    identity: &AuthenticatedIdentity,
+    parts: &[&str],
+) -> PgWireResult<Vec<Response>> {
+    if parts.len() < 6 {
+        return Err(sqlstate_error(
+            "42601",
+            "syntax: CREATE VECTOR INDEX <name> ON <collection> \
+             [METRIC cosine|l2] [M <m>] [EF_CONSTRUCTION <ef>] [DIM <dim>] \
+             [INDEX_TYPE hnsw|hnsw_pq|ivf_pq] [PQ_M <m>] [IVF_CELLS <n>] [IVF_NPROBE <n>]",
+        ));
+    }
+
+    let index_name = parts[3];
+    if !parts[4].eq_ignore_ascii_case("ON") {
+        return Err(sqlstate_error("42601", "expected ON after index name"));
+    }
+    let collection = parts[5];
+    let tenant_id = identity.tenant_id;
+
+    let upper_parts: Vec<String> = parts.iter().map(|p| p.to_uppercase()).collect();
+
+    let metric = find_param_str(&upper_parts, "METRIC").unwrap_or_else(|| "COSINE".into());
+    let m = find_param_usize(&upper_parts, "M").unwrap_or(16);
+    let ef_construction = find_param_usize(&upper_parts, "EF_CONSTRUCTION").unwrap_or(200);
+    let dim = find_param_usize(&upper_parts, "DIM").unwrap_or(0);
+
+    // Quantization parameters (advertised in docs/vectors.md).
+    let index_type = find_param_str(&upper_parts, "INDEX_TYPE")
+        .map(|s| s.to_lowercase())
+        .unwrap_or_default();
+    let pq_m = find_param_usize(&upper_parts, "PQ_M").unwrap_or(0);
+    let ivf_cells = find_param_usize(&upper_parts, "IVF_CELLS").unwrap_or(0);
+    let ivf_nprobe = find_param_usize(&upper_parts, "IVF_NPROBE").unwrap_or(0);
+
+    validate_quantization(&index_type, dim, pq_m, ivf_cells, ivf_nprobe)?;
+
+    super::super::owner_propose::propose_owner(
+        state,
+        "vector_index",
+        tenant_id,
+        index_name,
+        &identity.username,
+    )?;
+
+    let vshard = crate::types::VShardId::from_collection(collection);
+    let set_params_plan = PhysicalPlan::Vector(VectorOp::SetParams {
+        collection: collection.to_string(),
+        m,
+        ef_construction,
+        metric: metric.to_lowercase(),
+        index_type: index_type.clone(),
+        pq_m,
+        ivf_cells,
+        ivf_nprobe,
+    });
+    let _ = crate::control::server::dispatch_utils::dispatch_to_data_plane(
+        state,
+        tenant_id,
+        vshard,
+        set_params_plan,
+        0,
+    )
+    .await;
+
+    state.audit_record(
+        crate::control::security::audit::AuditEvent::AdminAction,
+        Some(tenant_id),
+        &identity.username,
+        &format!(
+            "created vector index '{index_name}' on '{collection}' \
+             (metric={metric}, m={m}, ef_construction={ef_construction}, dim={dim}, \
+             index_type={}, pq_m={pq_m}, ivf_cells={ivf_cells}, ivf_nprobe={ivf_nprobe})",
+            if index_type.is_empty() {
+                "hnsw"
+            } else {
+                &index_type
+            }
+        ),
+    );
+
+    Ok(vec![Response::Execution(Tag::new("CREATE VECTOR INDEX"))])
+}
+
+fn validate_quantization(
+    index_type: &str,
+    dim: usize,
+    pq_m: usize,
+    ivf_cells: usize,
+    ivf_nprobe: usize,
+) -> PgWireResult<()> {
+    if !index_type.is_empty() && !KNOWN_INDEX_TYPES.contains(&index_type) {
+        return Err(sqlstate_error(
+            "42601",
+            &format!(
+                "unknown index_type '{index_type}'; supported: {}",
+                KNOWN_INDEX_TYPES.join(", ")
+            ),
+        ));
+    }
+
+    let uses_pq = matches!(index_type, "hnsw_pq" | "ivf_pq");
+    if uses_pq && pq_m > 0 && dim > 0 && !dim.is_multiple_of(pq_m) {
+        return Err(sqlstate_error(
+            "42601",
+            &format!("pq_m ({pq_m}) must divide dim ({dim}) evenly"),
+        ));
+    }
+
+    if !uses_pq && (pq_m > 0 || ivf_cells > 0 || ivf_nprobe > 0) {
+        return Err(sqlstate_error(
+            "42601",
+            "pq_m / ivf_cells / ivf_nprobe require INDEX_TYPE hnsw_pq or ivf_pq",
+        ));
+    }
+
+    if index_type == "ivf_pq" && ivf_nprobe > 0 && ivf_cells > 0 && ivf_nprobe > ivf_cells {
+        return Err(sqlstate_error(
+            "42601",
+            &format!("ivf_nprobe ({ivf_nprobe}) must not exceed ivf_cells ({ivf_cells})"),
+        ));
+    }
+
+    Ok(())
+}
diff --git a/nodedb/src/control/server/pgwire/ddl/maintenance/vector_index.rs b/nodedb/src/control/server/pgwire/ddl/maintenance/vector_index.rs
index 1c6bd108..725b0f35 100644
--- a/nodedb/src/control/server/pgwire/ddl/maintenance/vector_index.rs
+++ b/nodedb/src/control/server/pgwire/ddl/maintenance/vector_index.rs
@@ -151,7 +151,17 @@ pub async fn handle_alter_vector_index_compact(
     Ok(vec![Response::Execution(Tag::new("COMPACT"))])
 }
 
-/// Handle `ALTER VECTOR INDEX ON collection.column SET (m = 32, ef_construction = 400)`.
+/// Handle `ALTER VECTOR INDEX ON collection.column SET (...)`.
+///
+/// Supported keys: `m`, `m0`, `ef_construction`, `index_type`, `pq_m`,
+/// `ivf_cells`, `ivf_nprobe`. Quantization-shape keys (`index_type`, `pq_m`,
+/// `ivf_cells`, `ivf_nprobe`) route through `VectorOp::SetParams`, which
+/// updates the stored `IndexConfig` before the collection materializes. HNSW
+/// parameter keys (`m`, `m0`, `ef_construction`) route through
+/// `VectorOp::Rebuild`, which performs an in-place index rebuild against the
+/// already-materialized collection. A single ALTER may specify both groups —
+/// they are dispatched independently. Zero / omitted fields preserve the
+/// existing stored values (see `execute_set_vector_params`).
 pub async fn handle_alter_vector_index_set(
     state: &SharedState,
     identity: &AuthenticatedIdentity,
@@ -179,12 +189,16 @@ pub async fn handle_alter_vector_index_set(
     let mut m = 0usize;
     let mut m0 = 0usize;
     let mut ef_construction = 0usize;
+    let mut index_type: Option<String> = None;
+    let mut pq_m = 0usize;
+    let mut ivf_cells = 0usize;
+    let mut ivf_nprobe = 0usize;
 
     for pair in inner.split(',') {
         let pair = pair.trim();
         if let Some((key, val)) = pair.split_once('=') {
             let key = key.trim().to_lowercase();
-            let val = val.trim();
+            let val = val.trim().trim_matches('\'').trim_matches('"');
             match key.as_str() {
                 "m" => {
                     m = val.parse().map_err(|_| {
@@ -204,20 +218,54 @@ pub async fn handle_alter_vector_index_set(
                         )
                     })?;
                 }
+                "index_type" => {
+                    let lower = val.to_lowercase();
+                    if !matches!(lower.as_str(), "hnsw" | "hnsw_pq" | "ivf_pq") {
+                        return Err(sqlstate_error(
+                            "42601",
+                            &format!(
+                                "unknown index_type '{val}'; supported: hnsw, hnsw_pq, ivf_pq"
+                            ),
+                        ));
+                    }
+                    index_type = Some(lower);
+                }
+                "pq_m" => {
+                    pq_m = val.parse().map_err(|_| {
+                        sqlstate_error("22023", &format!("invalid value for pq_m: {val}"))
+                    })?;
+                }
+                "ivf_cells" => {
+                    ivf_cells = val.parse().map_err(|_| {
+                        sqlstate_error("22023", &format!("invalid value for ivf_cells: {val}"))
+                    })?;
+                }
+                "ivf_nprobe" => {
+                    ivf_nprobe = val.parse().map_err(|_| {
+                        sqlstate_error("22023", &format!("invalid value for ivf_nprobe: {val}"))
+                    })?;
+                }
                 other => {
                     return Err(sqlstate_error(
                         "42601",
-                        &format!("unknown parameter '{other}'; supported: m, m0, ef_construction"),
+                        &format!(
+                            "unknown parameter '{other}'; supported: m, m0, ef_construction, \
+                             index_type, pq_m, ivf_cells, ivf_nprobe"
+                        ),
                     ));
                 }
             }
         }
     }
 
-    if m == 0 && m0 == 0 && ef_construction == 0 {
+    let has_rebuild = m > 0 || m0 > 0 || ef_construction > 0;
+    let has_quantization = index_type.is_some() || pq_m > 0 || ivf_cells > 0 || ivf_nprobe > 0;
+
+    if !has_rebuild && !has_quantization {
         return Err(sqlstate_error(
             "42601",
-            "SET clause must specify at least one parameter (m, m0, ef_construction)",
+            "SET clause must specify at least one parameter (m, m0, ef_construction, \
+             index_type, pq_m, ivf_cells, ivf_nprobe)",
         ));
     }
 
@@ -229,19 +277,44 @@ pub async fn handle_alter_vector_index_set(
     let tenant_id = identity.tenant_id;
     let vshard = crate::types::VShardId::from_collection(&collection);
 
-    let plan = PhysicalPlan::Vector(VectorOp::Rebuild {
-        collection,
-        field_name,
-        m,
-        m0,
-        ef_construction,
-    });
+    // Quantization changes route through SetParams (updates stored IndexConfig
+    // before the collection materializes). HNSW parameter changes route through
+    // Rebuild (in-place index rebuild).
+    if has_quantization {
+        // Zero / empty = preserve existing stored value. The handler reads the
+        // current IndexConfig and only overrides fields that were explicitly set.
+        let set_plan = PhysicalPlan::Vector(VectorOp::SetParams {
+            collection: collection.clone(),
+            m,
+            ef_construction,
+            metric: String::new(),
+            index_type: index_type.unwrap_or_default(),
+            pq_m,
+            ivf_cells,
+            ivf_nprobe,
+        });
+        crate::control::server::dispatch_utils::dispatch_to_data_plane(
+            state, tenant_id, vshard, set_plan, 0,
+        )
+        .await
+        .map_err(|e| sqlstate_error("XX000", &e.to_string()))?;
+    }
 
-    crate::control::server::dispatch_utils::dispatch_to_data_plane(
-        state, tenant_id, vshard, plan, 0,
-    )
-    .await
-    .map_err(|e| sqlstate_error("XX000", &e.to_string()))?;
+    if has_rebuild {
+        let plan = PhysicalPlan::Vector(VectorOp::Rebuild {
+            collection,
+            field_name,
+            m,
+            m0,
+            ef_construction,
+        });
+
+        crate::control::server::dispatch_utils::dispatch_to_data_plane(
+            state, tenant_id, vshard, plan, 0,
+        )
+        .await
+        .map_err(|e| sqlstate_error("XX000", &e.to_string()))?;
+    }
 
     Ok(vec![Response::Execution(Tag::new("ALTER VECTOR INDEX"))])
 }
diff --git a/nodedb/src/data/executor/handlers/vector.rs b/nodedb/src/data/executor/handlers/vector.rs
index e9b6265a..ff9f68ae 100644
--- a/nodedb/src/data/executor/handlers/vector.rs
+++ b/nodedb/src/data/executor/handlers/vector.rs
@@ -269,7 +269,33 @@ impl CoreLoop {
             );
         }
 
-        let metric_enum = match metric {
+        // Zero / empty inputs mean "preserve existing value if present, else default".
+        // This keeps ALTER SET (index_type = ...) from clobbering m / ef_construction
+        // that were set at CREATE time but not re-specified in the ALTER clause.
+        let existing = self.index_configs.get(&index_key).cloned();
+
+        let resolved_metric_str: String = if metric.is_empty() {
+            existing
+                .as_ref()
+                .map(|c| {
+                    match c.hnsw.metric {
+                        DistanceMetric::L2 => "l2",
+                        DistanceMetric::Cosine => "cosine",
+                        DistanceMetric::InnerProduct => "inner_product",
+                        DistanceMetric::Manhattan => "manhattan",
+                        DistanceMetric::Chebyshev => "chebyshev",
+                        DistanceMetric::Hamming => "hamming",
+                        DistanceMetric::Jaccard => "jaccard",
+                        DistanceMetric::Pearson => "pearson",
+                    }
+                    .to_string()
+                })
+                .unwrap_or_else(|| "cosine".into())
+        } else {
+            metric.to_string()
+        };
+
+        let metric_enum = match resolved_metric_str.as_str() {
             "l2" | "euclidean" => DistanceMetric::L2,
             "cosine" => DistanceMetric::Cosine,
             "inner_product" | "ip" | "dot" => DistanceMetric::InnerProduct,
@@ -283,40 +309,76 @@ impl CoreLoop {
                     task,
                     ErrorCode::RejectedConstraint {
                         constraint: format!(
-                            "unknown metric '{metric}'; supported: l2, cosine, inner_product, manhattan, chebyshev, hamming, jaccard, pearson"
+                            "unknown metric '{resolved_metric_str}'; supported: l2, cosine, inner_product, manhattan, chebyshev, hamming, jaccard, pearson"
                         ),
                     },
                 );
             }
         };
 
-        let idx_type = match crate::engine::vector::index_config::IndexType::parse(index_type) {
-            Some(t) => t,
-            None => {
-                return self.response_error(
-                    task,
-                    ErrorCode::RejectedConstraint {
-                        constraint: format!(
-                            "unknown index_type '{index_type}'; supported: hnsw, hnsw_pq, ivf_pq"
-                        ),
-                    },
-                );
+        let idx_type = if index_type.is_empty() {
+            existing
+                .as_ref()
+                .map(|c| c.index_type.clone())
+                .unwrap_or_default()
+        } else {
+            match crate::engine::vector::index_config::IndexType::parse(index_type) {
+                Some(t) => t,
+                None => {
+                    return self.response_error(
+                        task,
+                        ErrorCode::RejectedConstraint {
+                            constraint: format!(
+                                "unknown index_type '{index_type}'; supported: hnsw, hnsw_pq, ivf_pq"
+                            ),
+                        },
+                    );
+                }
             }
         };
 
+        let resolved_m = if m > 0 {
+            m
+        } else {
+            existing.as_ref().map(|c| c.hnsw.m).unwrap_or(16)
+        };
+        let resolved_ef = if ef_construction > 0 {
+            ef_construction
+        } else {
+            existing
+                .as_ref()
+                .map(|c| c.hnsw.ef_construction)
+                .unwrap_or(200)
+        };
+        let resolved_pq_m = if pq_m > 0 {
+            pq_m
+        } else {
+            existing.as_ref().map(|c| c.pq_m).unwrap_or(8)
+        };
+        let resolved_ivf_cells = if ivf_cells > 0 {
+            ivf_cells
+        } else {
+            existing.as_ref().map(|c| c.ivf_cells).unwrap_or(256)
+        };
+        let resolved_ivf_nprobe = if ivf_nprobe > 0 {
+            ivf_nprobe
+        } else {
+            existing.as_ref().map(|c| c.ivf_nprobe).unwrap_or(16)
+        };
+
         let params = HnswParams {
-            m,
-            m0: m * 2,
-            ef_construction,
+            m: resolved_m,
+            m0: resolved_m * 2,
+            ef_construction: resolved_ef,
             metric: metric_enum,
         };
 
         let config = crate::engine::vector::index_config::IndexConfig {
             hnsw: params.clone(),
             index_type: idx_type,
-            pq_m: if pq_m > 0 { pq_m } else { 8 },
-            ivf_cells: if ivf_cells > 0 { ivf_cells } else { 256 },
-            ivf_nprobe: if ivf_nprobe > 0 { ivf_nprobe } else { 16 },
+            pq_m: resolved_pq_m,
+            ivf_cells: resolved_ivf_cells,
+            ivf_nprobe: resolved_ivf_nprobe,
         };
 
         self.vector_params.insert(index_key.clone(), params);
diff --git a/nodedb/tests/sql_vector_index_ddl.rs b/nodedb/tests/sql_vector_index_ddl.rs
new file mode 100644
index 00000000..66175aa5
--- /dev/null
+++ b/nodedb/tests/sql_vector_index_ddl.rs
@@ -0,0 +1,110 @@
+//! Integration tests for `CREATE VECTOR INDEX` / `ALTER VECTOR INDEX` DDL
+//! quantization parameters: INDEX_TYPE, PQ_M, IVF_CELLS, IVF_NPROBE.
+//!
+//! Asserts that the SQL DDL surface recognizes and validates the quantization
+//! keywords advertised in `docs/vectors.md`. Silent fall-through to FP32 HNSW
+//! (unknown parameters ignored instead of rejected, validation skipped) is the
+//! regression mode these tests guard.
+
+mod common;
+
+use common::pgwire_harness::TestServer;
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn create_vector_index_unknown_index_type_errors() {
+    let server = TestServer::start().await;
+    server
+        .exec("CREATE COLLECTION vi_bogus TYPE document")
+        .await
+        .unwrap();
+
+    // Unknown quantization tier must be rejected at the DDL layer, not silently
+    // downgraded to FP32 HNSW. This is the core fall-through regression guard.
+    server
+        .expect_error(
+            "CREATE VECTOR INDEX idx_vi_bogus ON vi_bogus \
+             METRIC cosine DIM 4 INDEX_TYPE bogus_type",
+            "index_type",
+        )
+        .await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn create_vector_index_hnsw_pq_pq_m_must_divide_dim() {
+    let server = TestServer::start().await;
+    server
+        .exec("CREATE COLLECTION vi_bad_pqm TYPE document")
+        .await
+        .unwrap();
+
+    // PQ subquantizer count must divide the vector dimension evenly — otherwise
+    // the index cannot be constructed. Today this is silently accepted because
+    // PQ_M is never parsed; the engine falls back to PQ_M=8 which also doesn't
+    // divide 6, masking the bug until the first insert. DDL must validate up-front.
+    server
+        .expect_error(
+            "CREATE VECTOR INDEX idx_vi_bad_pqm ON vi_bad_pqm \
+             METRIC cosine DIM 6 INDEX_TYPE hnsw_pq PQ_M 4",
+            "pq_m",
+        )
+        .await;
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn create_vector_index_accepts_valid_hnsw_pq() {
+    let server = TestServer::start().await;
+    server
+        .exec("CREATE COLLECTION vi_hnsw_pq TYPE document")
+        .await
+        .unwrap();
+
+    // Valid hnsw_pq configuration: PQ_M divides DIM. Must be accepted.
+    // Positive lock-in: prevents the fix from over-rejecting valid syntax.
+    server
+        .exec(
+            "CREATE VECTOR INDEX idx_vi_hnsw_pq ON vi_hnsw_pq \
+             METRIC cosine DIM 4 INDEX_TYPE hnsw_pq PQ_M 2",
+        )
+        .await
+        .expect("valid hnsw_pq configuration must be accepted");
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn create_vector_index_accepts_valid_ivf_pq() {
+    let server = TestServer::start().await;
+    server
+        .exec("CREATE COLLECTION vi_ivf_pq TYPE document")
+        .await
+        .unwrap();
+
+    // Valid ivf_pq configuration with IVF_CELLS and IVF_NPROBE.
+    // Positive lock-in for the most memory-efficient documented tier.
+    server
+        .exec(
+            "CREATE VECTOR INDEX idx_vi_ivf_pq ON vi_ivf_pq \
+             METRIC cosine DIM 4 INDEX_TYPE ivf_pq PQ_M 2 IVF_CELLS 64 IVF_NPROBE 8",
+        )
+        .await
+        .expect("valid ivf_pq configuration must be accepted");
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
+async fn alter_vector_index_set_index_type_accepted() {
+    let server = TestServer::start().await;
+    server
+        .exec("CREATE COLLECTION vi_alter TYPE document")
+        .await
+        .unwrap();
+    server
+        .exec("CREATE VECTOR INDEX idx_vi_alter ON vi_alter METRIC cosine DIM 4")
+        .await
+        .unwrap();
+
+    // ALTER must accept the same quantization keyword set as CREATE — otherwise
+    // users who defaulted to FP32 have no SQL migration path to the documented
+    // tiers. Today ALTER errors with "unknown parameter 'index_type'".
+    server
+        .exec("ALTER VECTOR INDEX ON vi_alter SET (index_type = 'hnsw_pq', pq_m = 2)")
+        .await
+        .expect("ALTER VECTOR INDEX SET (index_type = ...) must be accepted");
+}