diff --git a/elixir-orchestration/lib/verisim/hypatia/scan_ingester.ex b/elixir-orchestration/lib/verisim/hypatia/scan_ingester.ex
index 86d6745..e2694d0 100644
--- a/elixir-orchestration/lib/verisim/hypatia/scan_ingester.ex
+++ b/elixir-orchestration/lib/verisim/hypatia/scan_ingester.ex
@@ -24,7 +24,7 @@ defmodule VeriSim.Hypatia.ScanIngester do
               │
       VeriSimDB storage
               │
-      Hypatia VQL queries
+      Hypatia VCL queries
 
   ## Usage
 
diff --git a/elixir-orchestration/lib/verisim/query/vql_bridge.ex b/elixir-orchestration/lib/verisim/query/vcl_bridge.ex
similarity index 93%
rename from elixir-orchestration/lib/verisim/query/vql_bridge.ex
rename to elixir-orchestration/lib/verisim/query/vcl_bridge.ex
index 80c2caf..c7891c2 100644
--- a/elixir-orchestration/lib/verisim/query/vql_bridge.ex
+++ b/elixir-orchestration/lib/verisim/query/vcl_bridge.ex
@@ -1,30 +1,30 @@
 # SPDX-License-Identifier: MPL-2.0
 
-defmodule VeriSim.Query.VQLBridge do
+defmodule VeriSim.Query.VCLBridge do
   @moduledoc """
-  Bridge between the ReScript VQL parser and Elixir VQL executor.
+  Bridge between the ReScript VCL parser and Elixir VCL executor.
 
   Manages a long-running Deno/Node process that runs the compiled ReScript
-  VQL parser. Communication uses JSON over stdin/stdout with length-prefixed
+  VCL parser. Communication uses JSON over stdin/stdout with length-prefixed
   framing for reliable message boundaries.
 
   ## Architecture
 
-      VQL String ──► VQLBridge (GenServer)
+      VCL String ──► VCLBridge (GenServer)
                         │
                         ▼
                      Port (stdin/stdout JSON)
                         │
                         ▼
-                     Deno process running compiled VQLParser.res
+                     Deno process running compiled VCLParser.res
                         │
                         ▼
-                     Parsed AST (JSON) ──► VQLExecutor
+                     Parsed AST (JSON) ──► VCLExecutor
 
   ## Usage
 
-      {:ok, ast} = VQLBridge.parse("SELECT GRAPH, VECTOR FROM HEXAD abc-123")
-      {:ok, results} = VQLExecutor.execute(ast)
+      {:ok, ast} = VCLBridge.parse("SELECT GRAPH, VECTOR FROM HEXAD abc-123")
+      {:ok, results} = VCLExecutor.execute(ast)
   """
 
   use GenServer
@@ -42,9 +42,9 @@ defmodule VeriSim.Query.VQLBridge do
   end
 
   @doc """
-  Parse a VQL query string into an AST map.
+  Parse a VCL query string into an AST map.
 
-  Returns `{:ok, ast}` where ast is a map matching the VQLParser.AST types,
+  Returns `{:ok, ast}` where ast is a map matching the VCLParser.AST types,
   or `{:error, reason}` on parse failure.
   """
   def parse(query_string, timeout \\ @default_timeout) do
@@ -66,44 +66,44 @@ defmodule VeriSim.Query.VQLBridge do
   end
 
   @doc """
-  Parse a VQL mutation (INSERT / UPDATE / DELETE).
+  Parse a VCL mutation (INSERT / UPDATE / DELETE).
   """
   def parse_mutation(query_string, timeout \\ @default_timeout) do
     GenServer.call(__MODULE__, {:parse_mutation, query_string}, timeout)
   end
 
   @doc """
-  Parse a VQL statement (query or mutation).
+  Parse a VCL statement (query or mutation).
   """
   def parse_statement(query_string, timeout \\ @default_timeout) do
     GenServer.call(__MODULE__, {:parse_statement, query_string}, timeout)
   end
 
   @doc """
-  Parse and execute a VQL query string in one call.
-  Combines VQLBridge.parse/1 with VQLExecutor.execute/2.
+  Parse and execute a VCL query string in one call.
+  Combines VCLBridge.parse/1 with VCLExecutor.execute/2.
   """
   def parse_and_execute(query_string, opts \\ []) do
     case parse(query_string) do
-      {:ok, ast} -> VeriSim.Query.VQLExecutor.execute(ast, opts)
+      {:ok, ast} -> VeriSim.Query.VCLExecutor.execute(ast, opts)
       {:error, _} = error -> error
     end
   end
 
   @doc """
-  Parse and execute a VQL statement (query or mutation).
+  Parse and execute a VCL statement (query or mutation).
   """
   def parse_and_execute_statement(query_string, opts \\ []) do
     case parse_statement(query_string) do
-      {:ok, ast} -> VeriSim.Query.VQLExecutor.execute_statement(ast, opts)
+      {:ok, ast} -> VeriSim.Query.VCLExecutor.execute_statement(ast, opts)
       {:error, _} = error -> error
     end
   end
 
   @doc """
-  Type-check a parsed VQL-DT AST.
+  Type-check a parsed VCL-DT AST.
 
-  Sends the AST to the ReScript type checker (VQLBidir.synthesizeQuery)
+  Sends the AST to the ReScript type checker (VCLBidir.synthesizeQuery)
   via the Deno/Node subprocess. Returns inferred types, proof obligations,
   and composition strategy.
 
@@ -142,12 +142,12 @@ defmodule VeriSim.Query.VQLBridge do
 
     case start_port(state) do
       {:ok, port} ->
-        Logger.info("VQLBridge started with #{runtime}")
+        Logger.info("VCLBridge started with #{runtime}")
         {:ok, %{state | port: port}}
 
       {:error, reason} ->
         Logger.warning(
-          "VQLBridge: parser process unavailable (#{reason}), falling back to built-in parser"
+          "VCLBridge: parser process unavailable (#{reason}), falling back to built-in parser"
         )
 
         {:ok, state}
@@ -157,7 +157,7 @@ defmodule VeriSim.Query.VQLBridge do
   @impl true
   def handle_call({:typecheck, _ast}, _from, %{port: nil} = state) do
     # Type checking requires the ReScript subprocess — no fallback.
-    # Callers MUST handle this error; silently passing would defeat VQL-DT.
+    # Callers MUST handle this error; silently passing would defeat VCL-DT.
     {:reply, {:error, :type_checker_unavailable}, state}
   end
 
@@ -240,14 +240,14 @@ defmodule VeriSim.Query.VQLBridge do
         end
 
       {:error, _} ->
-        Logger.warning("VQLBridge: received malformed data from parser port")
+        Logger.warning("VCLBridge: received malformed data from parser port")
         {:noreply, state}
     end
   end
 
   @impl true
   def handle_info({port, {:exit_status, status}}, %{port: port} = state) do
-    Logger.warning("VQLBridge: parser process exited with status #{status}")
+    Logger.warning("VCLBridge: parser process exited with status #{status}")
 
     # Reply to all pending requests with error
     for {_id, from} <- state.pending do
@@ -257,7 +257,7 @@ defmodule VeriSim.Query.VQLBridge do
     # Try to restart
     case start_port(state) do
       {:ok, new_port} ->
-        Logger.info("VQLBridge: parser process restarted")
+        Logger.info("VCLBridge: parser process restarted")
         {:noreply, %{state | port: new_port, pending: %{}}}
 
       {:error, _} ->
@@ -486,7 +486,7 @@ defmodule VeriSim.Query.VQLBridge do
 
     # Split multi-proof specs on AND/OR connectors into a list.
     # "EXISTENCE(a) AND PROVENANCE(b)" → [%{raw: "EXISTENCE(a)"}, %{raw: "PROVENANCE(b)"}]
-    specs = VeriSim.Query.VQLTypeChecker.parse_proof_specs(%{raw: raw})
+    specs = VeriSim.Query.VCLTypeChecker.parse_proof_specs(%{raw: raw})
 
     proof =
       case specs do
@@ -556,7 +556,7 @@ defmodule VeriSim.Query.VQLBridge do
 
       :error ->
         raise ArgumentError,
-              "Unknown VQL token #{inspect(str)} — not in @safe_atoms allowlist"
+              "Unknown VCL token #{inspect(str)} — not in @safe_atoms allowlist"
     end
   end
 
diff --git a/elixir-orchestration/lib/verisim/query/vql_executor.ex b/elixir-orchestration/lib/verisim/query/vcl_executor.ex
similarity index 97%
rename from elixir-orchestration/lib/verisim/query/vql_executor.ex
rename to elixir-orchestration/lib/verisim/query/vcl_executor.ex
index 59ed246..39d5e92 100644
--- a/elixir-orchestration/lib/verisim/query/vql_executor.ex
+++ b/elixir-orchestration/lib/verisim/query/vcl_executor.ex
@@ -1,8 +1,8 @@
 # SPDX-License-Identifier: MPL-2.0
 # Copyright (c) Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
-defmodule VeriSim.Query.VQLExecutor do
+defmodule VeriSim.Query.VCLExecutor do
   @moduledoc """
-  VQL Executor - Executes VQL queries and mutations parsed by the ReScript VQL parser.
+  VCL Executor - Executes VCL queries and mutations parsed by the ReScript VCL parser.
 
   Supports three phases:
   1. Dependent-type queries with multi-proof composition
@@ -11,9 +11,9 @@ defmodule VeriSim.Query.VQLExecutor do
 
   ## Execution Pipeline
 
-  1. Parse VQL query (done by ReScript VQLParser)
-  2. Type-check if PROOF clause present (VQLTypeChecker → VQLBidir)
-  3. Generate execution plan (VQLExplain)
+  1. Parse VCL query (done by ReScript VCLParser)
+  2. Type-check if PROOF clause present (VCLTypeChecker → VCLBidir)
+  3. Generate execution plan (VCLExplain)
   4. Classify conditions (pushdown vs cross-modal)
   5. Route to appropriate modality stores
   6. Evaluate cross-modal conditions post-fetch
@@ -23,14 +23,14 @@ defmodule VeriSim.Query.VQLExecutor do
   require Logger
 
   alias VeriSim.{QueryRouter, RustClient, Telemetry}
-  alias VeriSim.Query.VQLProofCertificate
+  alias VeriSim.Query.VCLProofCertificate
 
   @doc """
-  Execute a parsed VQL query.
+  Execute a parsed VCL query.
 
   ## Parameters
 
-  - `query_ast` - Parsed VQL query from ReScript VQLParser
+  - `query_ast` - Parsed VCL query from ReScript VCLParser
   - `opts` - Execution options
 
   ## Options
@@ -56,7 +56,7 @@ defmodule VeriSim.Query.VQLExecutor do
   end
 
   @doc """
-  Execute a VQL mutation (INSERT / UPDATE / DELETE).
+  Execute a VCL mutation (INSERT / UPDATE / DELETE).
   """
   def execute_mutation(mutation_ast, opts \\ []) do
     timeout = Keyword.get(opts, :timeout, 30_000)
@@ -77,7 +77,7 @@ defmodule VeriSim.Query.VQLExecutor do
   end
 
   @doc """
-  Execute a VQL statement (query or mutation).
+  Execute a VCL statement (query or mutation).
   """
   def execute_statement(statement_ast, opts \\ []) do
     case statement_ast do
@@ -91,13 +91,13 @@ defmodule VeriSim.Query.VQLExecutor do
   end
 
   @doc """
-  Execute a VQL query string (includes parsing).
+  Execute a VCL query string (includes parsing).
   """
   def execute_string(query_string, opts \\ []) do
     start_time = System.monotonic_time()
 
     result =
-      case VeriSim.Query.VQLBridge.parse(query_string) do
+      case VeriSim.Query.VCLBridge.parse(query_string) do
         {:ok, ast} -> execute(ast, opts)
         {:error, reason} -> {:error, {:parse_error, reason}}
       end
@@ -165,7 +165,7 @@ defmodule VeriSim.Query.VQLExecutor do
     projections = extract_projections(query_ast)
 
     if proof_specs do
-      # VQL-DT path: type-check → execute → verify proofs → bundle certificate
+      # VCL-DT path: type-check → execute → verify proofs → bundle certificate
       execute_dt_query(
         query_ast,
         proof_specs,
@@ -228,7 +228,7 @@ defmodule VeriSim.Query.VQLExecutor do
     end
   end
 
-  # VQL-DT execution — type check, execute, verify proofs, bundle certificate
+  # VCL-DT execution — type check, execute, verify proofs, bundle certificate
   defp execute_dt_query(
          query_ast,
          proof_specs,
@@ -243,15 +243,15 @@ defmodule VeriSim.Query.VQLExecutor do
          projections,
          timeout
        ) do
-    alias VeriSim.Query.{VQLBridge, VQLTypeChecker}
+    alias VeriSim.Query.{VCLBridge, VCLTypeChecker}
 
     # Step 1: Type-check the query to get proof obligations and composition strategy.
     # Tries three strategies in order:
-    #   1. ReScript bidirectional type checker (VQLBridge.typecheck — full formal system)
-    #   2. Elixir-native type checker (VQLTypeChecker — validates types, generates obligations)
+    #   1. ReScript bidirectional type checker (VCLBridge.typecheck — full formal system)
+    #   2. Elixir-native type checker (VCLTypeChecker — validates types, generates obligations)
     #   3. Bare AST extraction (last resort — no validation, just structuring)
     type_info =
-      case VQLBridge.typecheck(query_ast) do
+      case VCLBridge.typecheck(query_ast) do
         {:ok, info} ->
           info
 
@@ -259,26 +259,26 @@ defmodule VeriSim.Query.VQLExecutor do
           # ReScript subprocess not running. Use the Elixir-native type checker
           # which validates proof types, modality compatibility, and composition.
           Logger.info(
-            "VQL-DT: Using Elixir-native type checker (ReScript subprocess unavailable)"
+            "VCL-DT: Using Elixir-native type checker (ReScript subprocess unavailable)"
           )
 
-          case VQLTypeChecker.typecheck(query_ast) do
+          case VCLTypeChecker.typecheck(query_ast) do
             {:ok, info} ->
               info
 
             {:error, reason} ->
               # Native type checker rejected the query — this is a real type error.
-              Logger.error("VQL-DT: Type checking failed: #{inspect(reason)}")
+              Logger.error("VCL-DT: Type checking failed: #{inspect(reason)}")
               nil
           end
 
         {:error, reason} ->
-          Logger.error("VQL-DT: Type checking failed: #{inspect(reason)}")
+          Logger.error("VCL-DT: Type checking failed: #{inspect(reason)}")
           nil
       end
 
     if is_nil(type_info) do
-      {:error, {:type_check_failed, "VQL-DT query type checking failed"}}
+      {:error, {:type_check_failed, "VCL-DT query type checking failed"}}
     else
       # Step 2: Execute the query (get data)
       {pushdown_conditions, cross_modal_conditions} = classify_conditions(where_clause)
@@ -314,7 +314,7 @@ defmodule VeriSim.Query.VQLExecutor do
                   :conjunction
 
               # Step 4b: Generate independently verifiable certificates for
-              # each proof obligation using VQLProofCertificate. Each artifact
+              # each proof obligation using VCLProofCertificate. Each artifact
               # from the verifier becomes the witness for its corresponding
               # obligation, yielding a hash-sealed certificate.
               verifiable_certificates =
@@ -323,7 +323,7 @@ defmodule VeriSim.Query.VQLExecutor do
                 |> Enum.map(fn {obligation, artifact} ->
                   witness = if is_map(artifact), do: artifact, else: %{raw: artifact}
 
-                  case VQLProofCertificate.generate_certificate(obligation, witness) do
+                  case VCLProofCertificate.generate_certificate(obligation, witness) do
                     {:ok, cert} -> cert
                     {:error, _} -> nil
                   end
@@ -875,7 +875,7 @@ defmodule VeriSim.Query.VQLExecutor do
         else
           # No specific entity — log a warning but allow for global queries.
           Logger.warning(
-            "VQL-DT: Access proof without entity ID — global query, skipping entity-level check"
+            "VCL-DT: Access proof without entity ID — global query, skipping entity-level check"
           )
 
           {:ok, %{type: :access, entity_id: nil, authorized: true, scope: :global}}
@@ -1209,7 +1209,7 @@ defmodule VeriSim.Query.VQLExecutor do
   # ---------------------------------------------------------------------------
 
   # Proof obligation structuring and composition determination are now handled
-  # by VeriSim.Query.VQLTypeChecker, which provides richer validation and
+  # by VeriSim.Query.VCLTypeChecker, which provides richer validation and
   # enrichment (witness fields, circuit names, time estimates).
 
   # ===========================================================================
@@ -2019,7 +2019,7 @@ defmodule VeriSim.Query.VQLExecutor do
         steps = []
 
         # Step 1: Parse (already done)
-        steps = [%{operation: "Parse VQL", cost_ms: 1, notes: "Already completed"} | steps]
+        steps = [%{operation: "Parse VCL", cost_ms: 1, notes: "Already completed"} | steps]
 
         # Step 2: Type check (if proofs present)
         steps =
diff --git a/elixir-orchestration/lib/verisim/query/vql_proof_certificate.ex b/elixir-orchestration/lib/verisim/query/vcl_proof_certificate.ex
similarity index 91%
rename from elixir-orchestration/lib/verisim/query/vql_proof_certificate.ex
rename to elixir-orchestration/lib/verisim/query/vcl_proof_certificate.ex
index ffa03c1..0521298 100644
--- a/elixir-orchestration/lib/verisim/query/vql_proof_certificate.ex
+++ b/elixir-orchestration/lib/verisim/query/vcl_proof_certificate.ex
@@ -1,10 +1,10 @@
 # SPDX-License-Identifier: MPL-2.0
 
-defmodule VeriSim.Query.VQLProofCertificate do
+defmodule VeriSim.Query.VCLProofCertificate do
   @moduledoc """
-  VQL-DT proof certificate generation and verification.
+  VCL-DT proof certificate generation and verification.
 
-  After the VQL type checker validates a query's proof obligations and the
+  After the VCL type checker validates a query's proof obligations and the
   executor verifies the proofs at runtime, this module produces independently
   verifiable certificates. Each certificate bundles the proof obligation,
   witness data, and a SHA-256 integrity hash so that any party can later
@@ -34,14 +34,14 @@ defmodule VeriSim.Query.VQLProofCertificate do
       obligation = %{type: :existence, witness_fields: ["octad_id", "timestamp", "modality_count"], ...}
       witness = %{"octad_id" => "entity-001", "timestamp" => "2026-02-28T12:00:00Z", "modality_count" => 8}
 
-      {:ok, cert} = VQLProofCertificate.generate_certificate(obligation, witness)
-      :ok = VQLProofCertificate.verify_certificate(cert)
+      {:ok, cert} = VCLProofCertificate.generate_certificate(obligation, witness)
+      :ok = VCLProofCertificate.verify_certificate(cert)
 
   ## Batch certificates
 
       obligations_and_witnesses = [{obl1, wit1}, {obl2, wit2}]
-      {:ok, certs} = VQLProofCertificate.generate_batch(obligations_and_witnesses)
-      :ok = VQLProofCertificate.verify_batch(certs)
+      {:ok, certs} = VCLProofCertificate.generate_batch(obligations_and_witnesses)
+      :ok = VCLProofCertificate.verify_batch(certs)
   """
 
   @doc """
@@ -54,7 +54,7 @@ defmodule VeriSim.Query.VQLProofCertificate do
 
   ## Parameters
 
-  - `obligation` — proof obligation map from `VQLTypeChecker.typecheck/1`
+  - `obligation` — proof obligation map from `VCLTypeChecker.typecheck/1`
   - `witness` — witness data map gathered during proof execution
 
   ## Returns
@@ -125,7 +125,7 @@ defmodule VeriSim.Query.VQLProofCertificate do
   @doc """
   Generate certificates for a batch of obligation/witness pairs.
 
-  Useful when a VQL-DT query has multiple PROOF clauses (e.g.,
+  Useful when a VCL-DT query has multiple PROOF clauses (e.g.,
   `PROOF EXISTENCE(x) AND PROVENANCE(x)`).
 
   ## Parameters
diff --git a/elixir-orchestration/lib/verisim/query/vql_type_checker.ex b/elixir-orchestration/lib/verisim/query/vcl_type_checker.ex
similarity index 95%
rename from elixir-orchestration/lib/verisim/query/vql_type_checker.ex
rename to elixir-orchestration/lib/verisim/query/vcl_type_checker.ex
index 45cc0ac..ff91fa4 100644
--- a/elixir-orchestration/lib/verisim/query/vql_type_checker.ex
+++ b/elixir-orchestration/lib/verisim/query/vcl_type_checker.ex
@@ -1,16 +1,16 @@
 # SPDX-License-Identifier: MPL-2.0
 # Copyright (c) Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
-defmodule VeriSim.Query.VQLTypeChecker do
+defmodule VeriSim.Query.VCLTypeChecker do
   @moduledoc """
-  Elixir-native VQL-DT type checker.
+  Elixir-native VCL-DT type checker.
 
-  Provides lightweight type checking for VQL queries with PROOF clauses when the
-  ReScript subprocess (VQLBidir) is unavailable. This ensures that VQL-DT queries
+  Provides lightweight type checking for VCL queries with PROOF clauses when the
+  ReScript subprocess (VCLBidir) is unavailable. This ensures that VCL-DT queries
   are always type-checked before execution — never silently downgraded to slipstream.
 
   ## Design
 
-  The ReScript type checker (VQLBidir.res) is the canonical implementation with
+  The ReScript type checker (VCLBidir.res) is the canonical implementation with
   bidirectional type inference and full subtyping. This Elixir module implements a
   pragmatic subset of the same rules:
 
@@ -20,7 +20,7 @@ defmodule VeriSim.Query.VQLTypeChecker do
   4. **Contract reference validation** — proof specs that need contracts have them
   5. **Proof obligation generation** — structured obligations with witness fields
 
-  Falls back to the ReScript type checker when it's available (via VQLBridge.typecheck/2).
+  Falls back to the ReScript type checker when it's available (via VCLBridge.typecheck/2).
 
   ## Proof Types and Required Modalities
 
@@ -107,7 +107,7 @@ defmodule VeriSim.Query.VQLTypeChecker do
   # ---------------------------------------------------------------------------
 
   @doc """
-  Type-check a VQL-DT query AST.
+  Type-check a VCL-DT query AST.
 
   Validates proof types, modality compatibility, and composition rules.
   Returns structured proof obligations ready for the executor.
@@ -152,13 +152,13 @@ defmodule VeriSim.Query.VQLTypeChecker do
 
   ## Examples
 
-      iex> VQLTypeChecker.parse_proof_specs(%{raw: "EXISTENCE(entity-001) AND PROVENANCE(entity-001)"})
+      iex> VCLTypeChecker.parse_proof_specs(%{raw: "EXISTENCE(entity-001) AND PROVENANCE(entity-001)"})
       [
         %{proofType: "EXISTENCE", contractName: "entity-001", raw: "EXISTENCE(entity-001)"},
         %{proofType: "PROVENANCE", contractName: "entity-001", raw: "PROVENANCE(entity-001)"}
       ]
 
-      iex> VQLTypeChecker.parse_proof_specs(%{raw: "INTEGRITY(my_contract)"})
+      iex> VCLTypeChecker.parse_proof_specs(%{raw: "INTEGRITY(my_contract)"})
       [%{proofType: "INTEGRITY", contractName: "my_contract", raw: "INTEGRITY(my_contract)"}]
   """
   def parse_proof_specs(nil), do: []
@@ -204,7 +204,7 @@ defmodule VeriSim.Query.VQLTypeChecker do
   defp validate_modalities(_modalities), do: :ok
 
   defp validate_proof_specs([]) do
-    {:error, {:missing_proof, "VQL-DT query requires at least one PROOF specification"}}
+    {:error, {:missing_proof, "VCL-DT query requires at least one PROOF specification"}}
   end
 
   defp validate_proof_specs(specs) do
diff --git a/elixir-orchestration/lib/verisim/telemetry.ex b/elixir-orchestration/lib/verisim/telemetry.ex
index afa2f73..f6e44aa 100644
--- a/elixir-orchestration/lib/verisim/telemetry.ex
+++ b/elixir-orchestration/lib/verisim/telemetry.ex
@@ -7,7 +7,7 @@ defmodule VeriSim.Telemetry do
   Defines telemetry events, metric collectors, and supervises the opt-in
   product telemetry collector. The collector aggregates counters and
   distributions for query patterns, modality usage, drift frequency,
-  federation health, and VQL-DT proof adoption.
+  federation health, and VCL-DT proof adoption.
 
   ## Opt-in telemetry
 
diff --git a/elixir-orchestration/lib/verisim/telemetry/collector.ex b/elixir-orchestration/lib/verisim/telemetry/collector.ex
index 3ed5af0..f759179 100644
--- a/elixir-orchestration/lib/verisim/telemetry/collector.ex
+++ b/elixir-orchestration/lib/verisim/telemetry/collector.ex
@@ -20,18 +20,18 @@ defmodule VeriSim.Telemetry.Collector do
 
   | Metric | Type | Source |
   |--------|------|--------|
-  | query_count | counter | VQL executor |
-  | query_duration_sum | sum | VQL executor |
-  | query_duration_min/max | gauge | VQL executor |
-  | modality_usage | counter map | VQL executor / query router |
-  | query_pattern | counter map | VQL executor (SELECT/INSERT/DELETE/SEARCH/SHOW) |
+  | query_count | counter | VCL executor |
+  | query_duration_sum | sum | VCL executor |
+  | query_duration_min/max | gauge | VCL executor |
+  | modality_usage | counter map | VCL executor / query router |
+  | query_pattern | counter map | VCL executor (SELECT/INSERT/DELETE/SEARCH/SHOW) |
   | drift_detected_count | counter | drift monitor |
   | drift_modality_breakdown | counter map | drift monitor |
   | normalise_count | counter | normaliser |
   | normalise_success_count | counter | normaliser |
   | federation_query_count | counter | federation resolver |
   | federation_peer_errors | counter map | federation resolver |
-  | proof_type_usage | counter map | VQL-DT executor |
+  | proof_type_usage | counter map | VCL-DT executor |
   | entity_created_count | counter | entity server |
   | entity_deleted_count | counter | entity server |
   """
diff --git a/elixir-orchestration/lib/verisim/telemetry/reporter.ex b/elixir-orchestration/lib/verisim/telemetry/reporter.ex
index d9f3d8b..139db7a 100644
--- a/elixir-orchestration/lib/verisim/telemetry/reporter.ex
+++ b/elixir-orchestration/lib/verisim/telemetry/reporter.ex
@@ -12,7 +12,7 @@ defmodule VeriSim.Telemetry.Reporter do
   3. **Performance Summary** — query latency percentiles (from distribution)
   4. **Drift Report** — frequency, modality breakdown, normalisation success rate
   5. **Federation Health** — peer error rates
-  6. **VQL-DT Adoption** — proof type usage distribution
+  6. **VCL-DT Adoption** — proof type usage distribution
 
   ## Privacy guarantees
 
@@ -218,7 +218,7 @@ defmodule VeriSim.Telemetry.Reporter do
   end
 
   @doc """
-  Proof type usage — which VQL-DT proof types are used. Tracks adoption
+  Proof type usage — which VCL-DT proof types are used. Tracks adoption
   of dependent type features.
   """
   def proof_type_usage(snapshot \\ nil) do
diff --git a/elixir-orchestration/test/fixtures/vql/basic-select.expected.json b/elixir-orchestration/test/fixtures/vcl/basic-select.expected.json
similarity index 100%
rename from elixir-orchestration/test/fixtures/vql/basic-select.expected.json
rename to elixir-orchestration/test/fixtures/vcl/basic-select.expected.json
diff --git a/elixir-orchestration/test/fixtures/vql/basic-select.vql b/elixir-orchestration/test/fixtures/vcl/basic-select.vcl
similarity index 100%
rename from elixir-orchestration/test/fixtures/vql/basic-select.vql
rename to elixir-orchestration/test/fixtures/vcl/basic-select.vcl
diff --git a/elixir-orchestration/test/fixtures/vql/drift-query.expected.json b/elixir-orchestration/test/fixtures/vcl/drift-query.expected.json
similarity index 100%
rename from elixir-orchestration/test/fixtures/vql/drift-query.expected.json
rename to elixir-orchestration/test/fixtures/vcl/drift-query.expected.json
diff --git a/elixir-orchestration/test/fixtures/vql/drift-query.vql b/elixir-orchestration/test/fixtures/vcl/drift-query.vcl
similarity index 100%
rename from elixir-orchestration/test/fixtures/vql/drift-query.vql
rename to elixir-orchestration/test/fixtures/vcl/drift-query.vcl
diff --git a/elixir-orchestration/test/fixtures/vql/multi-proof.expected.json b/elixir-orchestration/test/fixtures/vcl/multi-proof.expected.json
similarity index 100%
rename from elixir-orchestration/test/fixtures/vql/multi-proof.expected.json
rename to elixir-orchestration/test/fixtures/vcl/multi-proof.expected.json
diff --git a/elixir-orchestration/test/fixtures/vql/multi-proof.vql b/elixir-orchestration/test/fixtures/vcl/multi-proof.vcl
similarity index 100%
rename from elixir-orchestration/test/fixtures/vql/multi-proof.vql
rename to elixir-orchestration/test/fixtures/vcl/multi-proof.vcl
diff --git a/elixir-orchestration/test/fixtures/vql/proof-existence.expected.json b/elixir-orchestration/test/fixtures/vcl/proof-existence.expected.json
similarity index 100%
rename from elixir-orchestration/test/fixtures/vql/proof-existence.expected.json
rename to elixir-orchestration/test/fixtures/vcl/proof-existence.expected.json
diff --git a/elixir-orchestration/test/fixtures/vql/proof-existence.vql b/elixir-orchestration/test/fixtures/vcl/proof-existence.vcl
similarity index 100%
rename from elixir-orchestration/test/fixtures/vql/proof-existence.vql
rename to elixir-orchestration/test/fixtures/vcl/proof-existence.vcl
diff --git a/elixir-orchestration/test/fixtures/vql/vector-search.expected.json b/elixir-orchestration/test/fixtures/vcl/vector-search.expected.json
similarity index 100%
rename from elixir-orchestration/test/fixtures/vql/vector-search.expected.json
rename to elixir-orchestration/test/fixtures/vcl/vector-search.expected.json
diff --git a/elixir-orchestration/test/fixtures/vql/vector-search.vql b/elixir-orchestration/test/fixtures/vcl/vector-search.vcl
similarity index 100%
rename from elixir-orchestration/test/fixtures/vql/vector-search.vql
rename to elixir-orchestration/test/fixtures/vcl/vector-search.vcl
diff --git a/elixir-orchestration/test/integration_test.exs b/elixir-orchestration/test/integration_test.exs
index dfb97f4..ba7771b 100644
--- a/elixir-orchestration/test/integration_test.exs
+++ b/elixir-orchestration/test/integration_test.exs
@@ -7,7 +7,7 @@ defmodule VeriSim.IntegrationTest do
   Tests:
   - Elixir orchestration layer
   - Communication with Rust core
-  - VQL query execution
+  - VCL query execution
   - Drift detection and normalization
   - Cross-modal queries
   """
@@ -20,7 +20,7 @@ defmodule VeriSim.IntegrationTest do
     DriftMonitor,
     SchemaRegistry,
     EntityServer,
-    Query.VQLExecutor
+    Query.VCLExecutor
   }
 
   @moduletag :integration
@@ -185,7 +185,7 @@ defmodule VeriSim.IntegrationTest do
     end
   end
 
-  describe "VQL Executor" do
+  describe "VCL Executor" do
     test "generates explain plans" do
       query_ast = %{
         modalities: [:graph, :vector],
@@ -196,7 +196,7 @@ defmodule VeriSim.IntegrationTest do
         offset: 0
       }
 
-      {:ok, plan} = VQLExecutor.execute(query_ast, explain: true)
+      {:ok, plan} = VCLExecutor.execute(query_ast, explain: true)
 
       assert is_map(plan)
       assert Map.has_key?(plan, :strategy)
@@ -213,7 +213,7 @@ defmodule VeriSim.IntegrationTest do
         offset: 0
       }
 
-      result = VQLExecutor.execute(query_ast)
+      result = VCLExecutor.execute(query_ast)
 
       # Expect error for nonexistent octad
       assert match?({:error, _}, result)
diff --git a/elixir-orchestration/test/support/vql_test_helpers.ex b/elixir-orchestration/test/support/vcl_test_helpers.ex
similarity index 88%
rename from elixir-orchestration/test/support/vql_test_helpers.ex
rename to elixir-orchestration/test/support/vcl_test_helpers.ex
index f6ba292..6c84d25 100644
--- a/elixir-orchestration/test/support/vql_test_helpers.ex
+++ b/elixir-orchestration/test/support/vcl_test_helpers.ex
@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: MPL-2.0
 
-defmodule VeriSim.Test.VQLTestHelpers do
+defmodule VeriSim.Test.VCLTestHelpers do
   @moduledoc """
-  Shared test helpers for VQL integration tests.
+  Shared test helpers for VCL integration tests.
 
   Provides:
-  - VQLBridge startup and teardown
+  - VCLBridge startup and teardown
   - Octad fixtures for each modality combination
   - AST assertion helpers
   - Query execution wrappers with Rust-core-unavailable handling
@@ -13,55 +13,55 @@ defmodule VeriSim.Test.VQLTestHelpers do
 
   ## Usage
 
-      use VeriSim.Test.VQLTestHelpers
+      use VeriSim.Test.VCLTestHelpers
 
-  This imports all helper functions and sets up the VQLBridge GenServer in
+  This imports all helper functions and sets up the VCLBridge GenServer in
   `setup_all`. Tests can then call `parse!/1`, `execute_safely/2`, and
   fixture builders without boilerplate.
   """
 
-  alias VeriSim.Query.{VQLBridge, VQLExecutor}
+  alias VeriSim.Query.{VCLBridge, VCLExecutor}
 
   @doc """
-  Ensure VQLBridge GenServer is running. Returns the PID.
+  Ensure VCLBridge GenServer is running. Returns the PID.
 
   Safe to call multiple times — if already started, returns the existing PID.
   """
   def ensure_bridge_started do
-    case VQLBridge.start_link([]) do
+    case VCLBridge.start_link([]) do
       {:ok, pid} -> pid
       {:error, {:already_started, pid}} -> pid
     end
   end
 
   @doc """
-  Parse a VQL query string, raising on failure.
+  Parse a VCL query string, raising on failure.
 
   Returns the parsed AST map. Useful in tests where a parse failure
   means the test itself is broken, not the feature under test.
   """
   def parse!(query_string) do
-    case VQLBridge.parse(query_string) do
+    case VCLBridge.parse(query_string) do
       {:ok, ast} -> ast
-      {:error, reason} -> raise "VQL parse failed: #{inspect(reason)}\n  Query: #{query_string}"
+      {:error, reason} -> raise "VCL parse failed: #{inspect(reason)}\n  Query: #{query_string}"
     end
   end
 
   @doc """
-  Parse a VQL statement (query or mutation), raising on failure.
+  Parse a VCL statement (query or mutation), raising on failure.
   """
   def parse_statement!(query_string) do
-    case VQLBridge.parse_statement(query_string) do
+    case VCLBridge.parse_statement(query_string) do
       {:ok, ast} ->
         ast
 
       {:error, reason} ->
-        raise "VQL statement parse failed: #{inspect(reason)}\n  Query: #{query_string}"
+        raise "VCL statement parse failed: #{inspect(reason)}\n  Query: #{query_string}"
     end
   end
 
   @doc """
-  Execute a VQL query string, handling Rust-core-unavailable gracefully.
+  Execute a VCL query string, handling Rust-core-unavailable gracefully.
 
   Returns `{:ok, result}`, `{:error, reason}`, or `{:unavailable, reason}`
   when the Rust core is not running (rescues connection errors).
@@ -70,7 +70,7 @@ defmodule VeriSim.Test.VQLTestHelpers do
     opts = Keyword.put_new(opts, :timeout, 2_000)
 
     try do
-      VQLExecutor.execute_string(query_string, opts)
+      VCLExecutor.execute_string(query_string, opts)
     rescue
       e ->
         {:unavailable, Exception.message(e)}
@@ -78,13 +78,13 @@ defmodule VeriSim.Test.VQLTestHelpers do
   end
 
   @doc """
-  Execute a parsed VQL AST, handling Rust-core-unavailable gracefully.
+  Execute a parsed VCL AST, handling Rust-core-unavailable gracefully.
   """
   def execute_ast_safely(ast, opts \\ []) do
     opts = Keyword.put_new(opts, :timeout, 2_000)
 
     try do
-      VQLExecutor.execute(ast, opts)
+      VCLExecutor.execute(ast, opts)
     rescue
       e ->
         {:unavailable, Exception.message(e)}
@@ -92,13 +92,13 @@ defmodule VeriSim.Test.VQLTestHelpers do
   end
 
   @doc """
-  Execute a VQL statement AST (query or mutation), handling errors gracefully.
+  Execute a VCL statement AST (query or mutation), handling errors gracefully.
   """
   def execute_statement_safely(ast, opts \\ []) do
     opts = Keyword.put_new(opts, :timeout, 2_000)
 
     try do
-      VQLExecutor.execute_statement(ast, opts)
+      VCLExecutor.execute_statement(ast, opts)
     rescue
       e ->
         {:unavailable, Exception.message(e)}
@@ -146,7 +146,7 @@ defmodule VeriSim.Test.VQLTestHelpers do
   end
 
   # ===========================================================================
-  # Fixtures: pre-built VQL query strings for common test scenarios
+  # Fixtures: pre-built VCL query strings for common test scenarios
   # ===========================================================================
 
   @doc "All 8 modality names as atoms."
@@ -154,7 +154,7 @@ defmodule VeriSim.Test.VQLTestHelpers do
     [:graph, :vector, :tensor, :semantic, :document, :temporal, :provenance, :spatial]
   end
 
-  @doc "All 8 modality names as uppercase strings (for VQL SELECT)."
+  @doc "All 8 modality names as uppercase strings (for VCL SELECT)."
   def all_modality_names do
     ~w(GRAPH VECTOR TENSOR SEMANTIC DOCUMENT TEMPORAL PROVENANCE SPATIAL)
   end
diff --git a/elixir-orchestration/test/verisim/property/vql_bridge_props_test.exs b/elixir-orchestration/test/verisim/property/vcl_bridge_props_test.exs
similarity index 87%
rename from elixir-orchestration/test/verisim/property/vql_bridge_props_test.exs
rename to elixir-orchestration/test/verisim/property/vcl_bridge_props_test.exs
index f164269..56c3167 100644
--- a/elixir-orchestration/test/verisim/property/vql_bridge_props_test.exs
+++ b/elixir-orchestration/test/verisim/property/vcl_bridge_props_test.exs
@@ -1,8 +1,8 @@
 # SPDX-License-Identifier: MPL-2.0
 
-defmodule VeriSim.Query.VQLBridgePropsTest do
+defmodule VeriSim.Query.VCLBridgePropsTest do
   @moduledoc """
-  Property-based tests for the VQLBridge built-in parser.
+  Property-based tests for the VCLBridge built-in parser.
 
   Invariants verified across the input space:
 
@@ -20,12 +20,12 @@ defmodule VeriSim.Query.VQLBridgePropsTest do
   use ExUnit.Case, async: false
   use ExUnitProperties
 
-  alias VeriSim.Query.VQLBridge
+  alias VeriSim.Query.VCLBridge
 
   setup do
-    case GenServer.whereis(VQLBridge) do
+    case GenServer.whereis(VCLBridge) do
       nil ->
-        {:ok, _pid} = VQLBridge.start_link([])
+        {:ok, _pid} = VCLBridge.start_link([])
         :ok
 
       _pid ->
@@ -59,7 +59,7 @@ defmodule VeriSim.Query.VQLBridgePropsTest do
 
   property "parse never panics on arbitrary UTF-8 input" do
     check all(input <- string(:ascii, max_length: 200)) do
-      result = VQLBridge.parse(input)
+      result = VCLBridge.parse(input)
       assert match?({:ok, _}, result) or match?({:error, _}, result)
     end
   end
@@ -68,7 +68,7 @@ defmodule VeriSim.Query.VQLBridgePropsTest do
     check all(uuid <- uuid_like()) do
       query = "SELECT GRAPH FROM HEXAD #{uuid}"
 
-      case VQLBridge.parse(query) do
+      case VCLBridge.parse(query) do
         {:ok, ast} ->
           assert ast.source == {:octad, uuid}
 
@@ -83,7 +83,7 @@ defmodule VeriSim.Query.VQLBridgePropsTest do
     check all(mods <- list_of(modality_token(), min_length: 1, max_length: 6)) do
       query = "SELECT #{Enum.join(mods, ", ")} FROM HEXAD abc-123"
 
-      case VQLBridge.parse(query) do
+      case VCLBridge.parse(query) do
         {:ok, ast} ->
           parsed_mods = ast.modalities
           # :all is also acceptable (SELECT *) but for explicit token lists
@@ -101,7 +101,7 @@ defmodule VeriSim.Query.VQLBridgePropsTest do
 
   property "SELECT * always produces :all in modalities" do
     check all(uuid <- uuid_like()) do
-      case VQLBridge.parse("SELECT * FROM HEXAD #{uuid}") do
+      case VCLBridge.parse("SELECT * FROM HEXAD #{uuid}") do
         {:ok, ast} -> assert :all in ast.modalities
         {:error, _} -> :ok
       end
@@ -116,8 +116,8 @@ defmodule VeriSim.Query.VQLBridgePropsTest do
       proof_clause = if include_proof, do: " PROOF EXISTENCE(target-1)", else: ""
       query = "SELECT GRAPH FROM HEXAD #{uuid}#{proof_clause}"
 
-      slipstream = VQLBridge.parse_slipstream(query)
-      dependent = VQLBridge.parse_dependent(query)
+      slipstream = VCLBridge.parse_slipstream(query)
+      dependent = VCLBridge.parse_dependent(query)
 
       slipstream_ok? = match?({:ok, _}, slipstream)
       dependent_ok? = match?({:ok, _}, dependent)
@@ -135,7 +135,7 @@ defmodule VeriSim.Query.VQLBridgePropsTest do
     check all(uuid <- uuid_like()) do
       query = "SELECT GRAPH, VECTOR FROM HEXAD #{uuid}"
 
-      case {VQLBridge.parse(query), VQLBridge.parse(query)} do
+      case {VCLBridge.parse(query), VCLBridge.parse(query)} do
         {{:ok, a}, {:ok, b}} ->
           assert a.modalities == b.modalities
           assert a.source == b.source
diff --git a/elixir-orchestration/test/verisim/query/vql_bridge_test.exs b/elixir-orchestration/test/verisim/query/vcl_bridge_test.exs
similarity index 70%
rename from elixir-orchestration/test/verisim/query/vql_bridge_test.exs
rename to elixir-orchestration/test/verisim/query/vcl_bridge_test.exs
index 652c052..10e7eaa 100644
--- a/elixir-orchestration/test/verisim/query/vql_bridge_test.exs
+++ b/elixir-orchestration/test/verisim/query/vcl_bridge_test.exs
@@ -1,9 +1,9 @@
 # SPDX-License-Identifier: MPL-2.0
 
-defmodule VeriSim.Query.VQLBridgeTest do
+defmodule VeriSim.Query.VCLBridgeTest do
   @moduledoc """
-  Tests for VeriSim.Query.VQLBridge — the Elixir↔Deno bridge for the
-  ReScript VQL parser.
+  Tests for VeriSim.Query.VCLBridge — the Elixir↔Deno bridge for the
+  ReScript VCL parser.
 
   When the external Deno/Node subprocess is unavailable (which is the
   common case in CI without those runtimes), the bridge falls back to
@@ -19,12 +19,12 @@ defmodule VeriSim.Query.VQLBridgeTest do
 
   use ExUnit.Case, async: false
 
-  alias VeriSim.Query.VQLBridge
+  alias VeriSim.Query.VCLBridge
 
   setup do
-    case GenServer.whereis(VQLBridge) do
+    case GenServer.whereis(VCLBridge) do
       nil ->
-        {:ok, _pid} = VQLBridge.start_link([])
+        {:ok, _pid} = VCLBridge.start_link([])
         :ok
 
       _pid ->
@@ -36,14 +36,14 @@ defmodule VeriSim.Query.VQLBridgeTest do
 
   describe "parse/2 — built-in fallback" do
     test "parses a simple SELECT query" do
-      assert {:ok, ast} = VQLBridge.parse("SELECT GRAPH FROM HEXAD abc-123")
+      assert {:ok, ast} = VCLBridge.parse("SELECT GRAPH FROM HEXAD abc-123")
       assert is_map(ast)
       assert Map.has_key?(ast, :modalities)
       assert Map.has_key?(ast, :source)
     end
 
     test "parses multi-modality SELECT" do
-      assert {:ok, ast} = VQLBridge.parse("SELECT GRAPH, VECTOR, DOCUMENT FROM HEXAD abc-123")
+      assert {:ok, ast} = VCLBridge.parse("SELECT GRAPH, VECTOR, DOCUMENT FROM HEXAD abc-123")
 
       assert :graph in ast.modalities
       assert :vector in ast.modalities
@@ -51,32 +51,32 @@ defmodule VeriSim.Query.VQLBridgeTest do
     end
 
     test "parses SELECT * as :all" do
-      assert {:ok, ast} = VQLBridge.parse("SELECT * FROM HEXAD abc-123")
+      assert {:ok, ast} = VCLBridge.parse("SELECT * FROM HEXAD abc-123")
       assert :all in ast.modalities
     end
 
     test "captures the source UUID from FROM HEXAD clause" do
-      assert {:ok, ast} = VQLBridge.parse("SELECT GRAPH FROM HEXAD entity-xyz")
+      assert {:ok, ast} = VCLBridge.parse("SELECT GRAPH FROM HEXAD entity-xyz")
       assert match?({:octad, "entity-xyz"}, ast.source)
     end
 
     test "non-SELECT input returns {:error, _}" do
-      assert {:error, _} = VQLBridge.parse("HELLO WORLD")
+      assert {:error, _} = VCLBridge.parse("HELLO WORLD")
     end
 
     test "empty string returns {:error, _}" do
-      assert {:error, _} = VQLBridge.parse("")
+      assert {:error, _} = VCLBridge.parse("")
     end
   end
 
   describe "parse_slipstream/2" do
     test "accepts a query without PROOF" do
-      assert {:ok, _ast} = VQLBridge.parse_slipstream("SELECT GRAPH FROM HEXAD abc-123")
+      assert {:ok, _ast} = VCLBridge.parse_slipstream("SELECT GRAPH FROM HEXAD abc-123")
     end
 
     test "rejects a query with PROOF clause" do
       assert {:error, msg} =
-               VQLBridge.parse_slipstream(
+               VCLBridge.parse_slipstream(
                  "SELECT GRAPH FROM HEXAD abc-123 PROOF EXISTENCE(entity-001)"
                )
 
@@ -87,12 +87,12 @@ defmodule VeriSim.Query.VQLBridgeTest do
 
   describe "parse_dependent/2" do
     test "rejects a query without PROOF clause" do
-      assert {:error, _msg} = VQLBridge.parse_dependent("SELECT GRAPH FROM HEXAD abc-123")
+      assert {:error, _msg} = VCLBridge.parse_dependent("SELECT GRAPH FROM HEXAD abc-123")
     end
 
     test "accepts a query with PROOF clause" do
       assert {:ok, ast} =
-               VQLBridge.parse_dependent(
+               VCLBridge.parse_dependent(
                  "SELECT GRAPH FROM HEXAD abc-123 PROOF EXISTENCE(entity-001)"
                )
 
@@ -103,39 +103,39 @@ defmodule VeriSim.Query.VQLBridgeTest do
   describe "parse_mutation/2" do
     test "parses INSERT statement" do
       assert {:ok, mutation} =
-               VQLBridge.parse_mutation("INSERT HEXAD WITH GRAPH {} AND VECTOR {}")
+               VCLBridge.parse_mutation("INSERT HEXAD WITH GRAPH {} AND VECTOR {}")
 
       assert is_map(mutation)
     end
 
     test "parses UPDATE statement" do
-      assert {:ok, mutation} = VQLBridge.parse_mutation("UPDATE HEXAD abc-123 SET GRAPH {}")
+      assert {:ok, mutation} = VCLBridge.parse_mutation("UPDATE HEXAD abc-123 SET GRAPH {}")
 
       assert is_map(mutation)
     end
 
     test "parses DELETE statement" do
-      assert {:ok, mutation} = VQLBridge.parse_mutation("DELETE HEXAD abc-123")
+      assert {:ok, mutation} = VCLBridge.parse_mutation("DELETE HEXAD abc-123")
       assert is_map(mutation)
     end
 
     test "non-mutation input returns {:error, _}" do
-      assert {:error, _} = VQLBridge.parse_mutation("SELECT GRAPH FROM HEXAD x")
+      assert {:error, _} = VCLBridge.parse_mutation("SELECT GRAPH FROM HEXAD x")
     end
   end
 
   describe "parse_statement/2" do
     test "routes SELECT to Query tag" do
-      assert {:ok, %{TAG: "Query"}} = VQLBridge.parse_statement("SELECT GRAPH FROM HEXAD abc-123")
+      assert {:ok, %{TAG: "Query"}} = VCLBridge.parse_statement("SELECT GRAPH FROM HEXAD abc-123")
     end
 
     test "routes INSERT to Mutation tag" do
       assert {:ok, %{TAG: "Mutation"}} =
-               VQLBridge.parse_statement("INSERT HEXAD WITH GRAPH {} AND VECTOR {}")
+               VCLBridge.parse_statement("INSERT HEXAD WITH GRAPH {} AND VECTOR {}")
     end
 
     test "routes DELETE to Mutation tag" do
-      assert {:ok, %{TAG: "Mutation"}} = VQLBridge.parse_statement("DELETE HEXAD abc-123")
+      assert {:ok, %{TAG: "Mutation"}} = VCLBridge.parse_statement("DELETE HEXAD abc-123")
     end
   end
 
@@ -143,15 +143,15 @@ defmodule VeriSim.Query.VQLBridgeTest do
     test "returns :type_checker_unavailable when no ReScript subprocess" do
       # In test env the Deno/Node subprocess isn't started, so the
       # typecheck handler returns this specific error rather than
-      # silently passing.  Critical for VQL-DT integrity.
+      # silently passing.  Critical for VCL-DT integrity.
       ast = %{modalities: [:graph], source: {:octad, "abc"}}
-      assert {:error, :type_checker_unavailable} = VQLBridge.typecheck(ast)
+      assert {:error, :type_checker_unavailable} = VCLBridge.typecheck(ast)
     end
   end
 
   describe "parse_and_execute/2 — error propagation" do
     test "parse failure propagates" do
-      assert {:error, _} = VQLBridge.parse_and_execute("INVALID GIBBERISH", [])
+      assert {:error, _} = VCLBridge.parse_and_execute("INVALID GIBBERISH", [])
     end
   end
 end
diff --git a/elixir-orchestration/test/verisim/query/vql_crossmodal_test.exs b/elixir-orchestration/test/verisim/query/vcl_crossmodal_test.exs
similarity index 98%
rename from elixir-orchestration/test/verisim/query/vql_crossmodal_test.exs
rename to elixir-orchestration/test/verisim/query/vcl_crossmodal_test.exs
index 9ed4b55..f5eabe2 100644
--- a/elixir-orchestration/test/verisim/query/vql_crossmodal_test.exs
+++ b/elixir-orchestration/test/verisim/query/vcl_crossmodal_test.exs
@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: MPL-2.0
 
-defmodule VeriSim.Query.VQLCrossModalTest do
+defmodule VeriSim.Query.VCLCrossModalTest do
   @moduledoc """
-  Cross-modal condition tests for VQL queries.
+  Cross-modal condition tests for VCL queries.
 
   Exercises the condition classification and cross-modal evaluation logic in
-  `VQLExecutor`. Cross-modal conditions are NOT pushed down to individual
+  `VCLExecutor`. Cross-modal conditions are NOT pushed down to individual
   modality stores — they are evaluated post-fetch by comparing data across
   two or more modalities on the same octad.
 
@@ -33,7 +33,7 @@ defmodule VeriSim.Query.VQLCrossModalTest do
 
   use ExUnit.Case, async: false
 
-  alias VeriSim.Test.VQLTestHelpers, as: H
+  alias VeriSim.Test.VCLTestHelpers, as: H
 
   setup_all do
     pid = H.ensure_bridge_started()
diff --git a/elixir-orchestration/test/verisim/query/vql_dt_integration_test.exs b/elixir-orchestration/test/verisim/query/vcl_dt_integration_test.exs
similarity index 93%
rename from elixir-orchestration/test/verisim/query/vql_dt_integration_test.exs
rename to elixir-orchestration/test/verisim/query/vcl_dt_integration_test.exs
index 9d34ee7..2ea3588 100644
--- a/elixir-orchestration/test/verisim/query/vql_dt_integration_test.exs
+++ b/elixir-orchestration/test/verisim/query/vcl_dt_integration_test.exs
@@ -1,10 +1,10 @@
 # SPDX-License-Identifier: MPL-2.0
 
-defmodule VeriSim.Query.VQLDTIntegrationTest do
+defmodule VeriSim.Query.VCLDTIntegrationTest do
   @moduledoc """
-  VQL-DT (dependent type) integration tests.
+  VCL-DT (dependent type) integration tests.
 
-  Exercises the full VQL-DT pipeline: parse → type-check → execute → verify
+  Exercises the full VCL-DT pipeline: parse → type-check → execute → verify
   proofs → bundle ProvedResult. Tests verify both the happy path (proofs pass
   when data exists) and the error paths (proofs fail correctly).
 
@@ -14,7 +14,7 @@ defmodule VeriSim.Query.VQLDTIntegrationTest do
      the correct Rust endpoint and returns a structured artifact or error
   2. **Multi-proof composition** — multiple proofs in a single query
   3. **Invalid proof rejection** — tampered or malformed data fails verification
-  4. **Proof downgrade rejection** — VQL-DT cannot silently become slipstream
+  4. **Proof downgrade rejection** — VCL-DT cannot silently become slipstream
   5. **ProvedResult structure** — data + proof_certificate with all required fields
   6. **Fallback type extraction** — when type checker unavailable, obligations
      are extracted from the AST directly with correct structure
@@ -25,8 +25,8 @@ defmodule VeriSim.Query.VQLDTIntegrationTest do
 
   use ExUnit.Case, async: false
 
-  alias VeriSim.Query.{VQLBridge, VQLExecutor}
-  alias VeriSim.Test.VQLTestHelpers, as: H
+  alias VeriSim.Query.{VCLBridge, VCLExecutor}
+  alias VeriSim.Test.VCLTestHelpers, as: H
 
   setup_all do
     pid = H.ensure_bridge_started()
@@ -190,8 +190,8 @@ defmodule VeriSim.Query.VQLDTIntegrationTest do
   # ===========================================================================
 
   describe "proof downgrade rejection" do
-    test "VQL-DT query with PROOF clause cannot silently become slipstream" do
-      # A query with PROOF must go through the VQL-DT path and either
+    test "VCL-DT query with PROOF clause cannot silently become slipstream" do
+      # A query with PROOF must go through the VCL-DT path and either
       # return a ProvedResult or fail with a proof-related error.
       query = "SELECT GRAPH.* FROM HEXAD 'entity-001' PROOF EXISTENCE(entity-001)"
 
@@ -202,7 +202,7 @@ defmodule VeriSim.Query.VQLDTIntegrationTest do
           # Must have a proof_certificate — NOT bare data
           assert Map.has_key?(proved_result, :proof_certificate) or
                    Map.has_key?(proved_result, "proof_certificate"),
-                 "VQL-DT result must include proof_certificate, got: #{inspect(Map.keys(proved_result))}"
+                 "VCL-DT result must include proof_certificate, got: #{inspect(Map.keys(proved_result))}"
 
         {:error, _} ->
           # Proof verification error is acceptable (Rust core unavailable)
@@ -214,7 +214,7 @@ defmodule VeriSim.Query.VQLDTIntegrationTest do
     end
 
     test "parse_dependent rejects queries without PROOF clause" do
-      result = VQLBridge.parse_dependent("SELECT GRAPH.* FROM HEXAD 'abc-123'")
+      result = VCLBridge.parse_dependent("SELECT GRAPH.* FROM HEXAD 'abc-123'")
 
       case result do
         {:error, msg} ->
@@ -229,7 +229,7 @@ defmodule VeriSim.Query.VQLDTIntegrationTest do
 
     test "parse_slipstream rejects queries with PROOF clause" do
       result =
-        VQLBridge.parse_slipstream("SELECT GRAPH.* FROM HEXAD 'abc-123' PROOF EXISTENCE(abc-123)")
+        VCLBridge.parse_slipstream("SELECT GRAPH.* FROM HEXAD 'abc-123' PROOF EXISTENCE(abc-123)")
 
       case result do
         {:error, msg} ->
@@ -246,8 +246,8 @@ defmodule VeriSim.Query.VQLDTIntegrationTest do
   # ===========================================================================
 
   describe "ProvedResult structure" do
-    test "VQL-DT result has expected shape with proof_certificate" do
-      # Build a well-formed AST that will go through the VQL-DT path
+    test "VCL-DT result has expected shape with proof_certificate" do
+      # Build a well-formed AST that will go through the VCL-DT path
       ast = %{
         modalities: [:graph],
         source: {:octad, "entity-001"},
@@ -383,16 +383,16 @@ defmodule VeriSim.Query.VQLDTIntegrationTest do
   end
 
   # ===========================================================================
-  # 7. Explain plan for VQL-DT queries
+  # 7. Explain plan for VCL-DT queries
   # ===========================================================================
 
-  describe "VQL-DT explain plan" do
-    test "explain: true on a VQL-DT query returns plan without executing proofs" do
+  describe "VCL-DT explain plan" do
+    test "explain: true on a VCL-DT query returns plan without executing proofs" do
       query = "SELECT GRAPH.* FROM HEXAD 'entity-001' PROOF EXISTENCE(entity-001)"
       ast = H.parse!(query)
 
       # explain: true should return the execution plan, NOT execute proofs
-      {:ok, plan} = VQLExecutor.execute(ast, explain: true)
+      {:ok, plan} = VCLExecutor.execute(ast, explain: true)
 
       assert is_map(plan)
       assert Map.has_key?(plan, :strategy)
diff --git a/elixir-orchestration/test/verisim/query/vql_dt_test.exs b/elixir-orchestration/test/verisim/query/vcl_dt_test.exs
similarity index 88%
rename from elixir-orchestration/test/verisim/query/vql_dt_test.exs
rename to elixir-orchestration/test/verisim/query/vcl_dt_test.exs
index 4e3e04d..e21ea3a 100644
--- a/elixir-orchestration/test/verisim/query/vql_dt_test.exs
+++ b/elixir-orchestration/test/verisim/query/vcl_dt_test.exs
@@ -1,8 +1,8 @@
 # SPDX-License-Identifier: MPL-2.0
 
-defmodule VeriSim.Query.VQLDTTest do
+defmodule VeriSim.Query.VCLDTTest do
   @moduledoc """
-  VQL-DT (dependent type) integration tests.
+  VCL-DT (dependent type) integration tests.
 
   Tests the proof verification pipeline: type checking → execution → proof
   verification → ProvedResult bundling.
@@ -21,10 +21,10 @@ defmodule VeriSim.Query.VQLDTTest do
 
   use ExUnit.Case, async: false
 
-  alias VeriSim.Query.{VQLBridge, VQLExecutor}
+  alias VeriSim.Query.{VCLBridge, VCLExecutor}
 
   setup_all do
-    case VQLBridge.start_link([]) do
+    case VCLBridge.start_link([]) do
       {:ok, pid} -> %{bridge_pid: pid}
       {:error, {:already_started, pid}} -> %{bridge_pid: pid}
     end
@@ -34,24 +34,24 @@ defmodule VeriSim.Query.VQLDTTest do
   # Type checker integration
   # ===========================================================================
 
-  describe "VQLBridge.typecheck/1" do
+  describe "VCLBridge.typecheck/1" do
     test "returns :type_checker_unavailable when no Deno subprocess" do
       # Without the Deno subprocess, typecheck must return an explicit error
-      {:ok, ast} = VQLBridge.parse("SELECT GRAPH.* FROM HEXAD 'abc-123'")
-      result = VQLBridge.typecheck(ast)
+      {:ok, ast} = VCLBridge.parse("SELECT GRAPH.* FROM HEXAD 'abc-123'")
+      result = VCLBridge.typecheck(ast)
       assert result == {:error, :type_checker_unavailable}
     end
   end
 
   # ===========================================================================
-  # VQL-DT query execution (PROOF clause)
+  # VCL-DT query execution (PROOF clause)
   # ===========================================================================
 
-  describe "VQL-DT execution path" do
+  describe "VCL-DT execution path" do
     test "parse_statement handles PROOF clause in AST" do
       # The built-in parser should handle PROOF clauses
       result =
-        VQLBridge.parse_statement("SELECT GRAPH.* FROM HEXAD 'abc-123' PROOF EXISTENCE(abc-123)")
+        VCLBridge.parse_statement("SELECT GRAPH.* FROM HEXAD 'abc-123' PROOF EXISTENCE(abc-123)")
 
       case result do
         {:ok, ast} ->
@@ -64,11 +64,11 @@ defmodule VeriSim.Query.VQLDTTest do
     end
 
     test "execute_string with PROOF returns error when Rust unavailable" do
-      # VQL-DT queries MUST fail if proofs cannot be verified —
+      # VCL-DT queries MUST fail if proofs cannot be verified —
       # they should NOT silently return unproven data.
       result =
         try do
-          VQLExecutor.execute_string(
+          VCLExecutor.execute_string(
             "SELECT GRAPH.* FROM HEXAD 'abc-123' PROOF EXISTENCE(abc-123)",
             timeout: 1_000
           )
@@ -98,7 +98,7 @@ defmodule VeriSim.Query.VQLDTTest do
       # Without Rust core, existence check should fail (not silently pass)
       result =
         try do
-          VQLExecutor.execute_string(
+          VCLExecutor.execute_string(
             "SELECT GRAPH.* FROM HEXAD 'abc-123' PROOF EXISTENCE(abc-123)",
             timeout: 1_000
           )
@@ -112,7 +112,7 @@ defmodule VeriSim.Query.VQLDTTest do
     test "provenance proof fails when Rust core unavailable" do
       result =
         try do
-          VQLExecutor.execute_string(
+          VCLExecutor.execute_string(
             "SELECT PROVENANCE.* FROM HEXAD 'abc-123' PROOF PROVENANCE(abc-123)",
             timeout: 1_000
           )
@@ -127,7 +127,7 @@ defmodule VeriSim.Query.VQLDTTest do
     test "integrity proof fails when Rust core unavailable" do
       result =
         try do
-          VQLExecutor.execute_string(
+          VCLExecutor.execute_string(
             "SELECT GRAPH.* FROM HEXAD 'abc-123' PROOF INTEGRITY(my_contract)",
             timeout: 1_000
           )
@@ -142,7 +142,7 @@ defmodule VeriSim.Query.VQLDTTest do
     test "access proof fails when Rust core unavailable and entity specified" do
       result =
         try do
-          VQLExecutor.execute_string(
+          VCLExecutor.execute_string(
             "SELECT GRAPH.* FROM HEXAD 'abc-123' PROOF ACCESS(abc-123)",
             timeout: 1_000
           )
@@ -156,7 +156,7 @@ defmodule VeriSim.Query.VQLDTTest do
     test "citation proof fails when Rust core unavailable" do
       result =
         try do
-          VQLExecutor.execute_string(
+          VCLExecutor.execute_string(
             "SELECT GRAPH.* FROM HEXAD 'abc-123' PROOF CITATION(my_citation)",
             timeout: 1_000
           )
@@ -170,7 +170,7 @@ defmodule VeriSim.Query.VQLDTTest do
     test "zkp proof fails when Rust core unavailable" do
       result =
         try do
-          VQLExecutor.execute_string(
+          VCLExecutor.execute_string(
             "SELECT GRAPH.* FROM HEXAD 'abc-123' PROOF ZKP(claim_123)",
             timeout: 1_000
           )
@@ -193,7 +193,7 @@ defmodule VeriSim.Query.VQLDTTest do
       # a provenance proof that cannot identify its target entity is meaningless.
       result =
         try do
-          VQLExecutor.execute_string(
+          VCLExecutor.execute_string(
             "SELECT PROVENANCE.* FROM HEXAD 'abc-123' PROOF PROVENANCE(abc-123)",
             timeout: 1_000
           )
@@ -213,7 +213,7 @@ defmodule VeriSim.Query.VQLDTTest do
       # A completely unknown proof type should produce an error.
       result =
         try do
-          VQLExecutor.execute_string(
+          VCLExecutor.execute_string(
             "SELECT GRAPH.* FROM HEXAD 'abc-123' PROOF BOGUS_TYPE(entity)",
             timeout: 1_000
           )
@@ -230,8 +230,8 @@ defmodule VeriSim.Query.VQLDTTest do
   # ===========================================================================
 
   describe "ProvedResult structure" do
-    test "VQL-DT queries should produce proved results with certificate" do
-      # This test documents the expected shape of VQL-DT results.
+    test "VCL-DT queries should produce proved results with certificate" do
+      # This test documents the expected shape of VCL-DT results.
       # In production (with Rust running), the result should be:
       # %{
       #   data: [...],
@@ -246,7 +246,7 @@ defmodule VeriSim.Query.VQLDTTest do
       # For now, we verify the executor code path doesn't crash.
       result =
         try do
-          VQLExecutor.execute_string(
+          VCLExecutor.execute_string(
             "SELECT GRAPH.* FROM HEXAD 'abc-123' PROOF EXISTENCE(abc-123)",
             timeout: 1_000
           )
diff --git a/elixir-orchestration/test/verisim/query/vql_e2e_test.exs b/elixir-orchestration/test/verisim/query/vcl_e2e_test.exs
similarity index 93%
rename from elixir-orchestration/test/verisim/query/vql_e2e_test.exs
rename to elixir-orchestration/test/verisim/query/vcl_e2e_test.exs
index 2f2b51c..2c320f0 100644
--- a/elixir-orchestration/test/verisim/query/vql_e2e_test.exs
+++ b/elixir-orchestration/test/verisim/query/vcl_e2e_test.exs
@@ -1,10 +1,10 @@
 # SPDX-License-Identifier: MPL-2.0
 
-defmodule VeriSim.Query.VQLE2ETest do
+defmodule VeriSim.Query.VCLE2ETest do
   @moduledoc """
-  VQL end-to-end tests exercising the full pipeline:
+  VCL end-to-end tests exercising the full pipeline:
 
-    VQL string → parse → typecheck → plan → execute → result
+    VCL string → parse → typecheck → plan → execute → result
 
   These tests validate the VCL-SPEC contract by exercising every major
   language feature through the complete pipeline. They are designed to
@@ -28,8 +28,8 @@ defmodule VeriSim.Query.VQLE2ETest do
 
   use ExUnit.Case, async: false
 
-  alias VeriSim.Query.{VQLBridge, VQLTypeChecker, VQLProofCertificate}
-  alias VeriSim.Test.VQLTestHelpers, as: H
+  alias VeriSim.Query.{VCLBridge, VCLTypeChecker, VCLProofCertificate}
+  alias VeriSim.Test.VCLTestHelpers, as: H
 
   setup_all do
     pid = H.ensure_bridge_started()
@@ -157,7 +157,7 @@ defmodule VeriSim.Query.VQLE2ETest do
       @pt_upper @pt |> Atom.to_string() |> String.upcase()
 
       test "#{@pt_upper} proof: typecheck → certificate → verify" do
-        # Build a VQL-DT query with this proof type
+        # Build a VCL-DT query with this proof type
         contract =
           if @pt in [:integrity, :citation, :custom, :sanctify] do
             "(my_contract)"
@@ -170,7 +170,7 @@ defmodule VeriSim.Query.VQLE2ETest do
         H.assert_has_proof(ast)
 
         # Type check returns {:ok, %{proof_obligations: [...], ...}}
-        case VQLTypeChecker.typecheck(ast) do
+        case VCLTypeChecker.typecheck(ast) do
           {:ok, tc_result} ->
             obligations = tc_result[:proof_obligations] || tc_result.proof_obligations
             assert is_list(obligations)
@@ -181,7 +181,7 @@ defmodule VeriSim.Query.VQLE2ETest do
 
             # Generate certificate with mock witness data
             witness = build_mock_witness(@pt)
-            {:ok, cert} = VQLProofCertificate.generate_certificate(obligation, witness)
+            {:ok, cert} = VCLProofCertificate.generate_certificate(obligation, witness)
 
             # Certificate structure
             assert cert.type == @pt
@@ -190,7 +190,7 @@ defmodule VeriSim.Query.VQLE2ETest do
             assert byte_size(cert.hash) == 32
 
             # Verify round-trip
-            assert :ok == VQLProofCertificate.verify_certificate(cert)
+            assert :ok == VCLProofCertificate.verify_certificate(cert)
 
           {:error, _reason} ->
             # Some proof types may fail if modality requirements not met
@@ -207,7 +207,7 @@ defmodule VeriSim.Query.VQLE2ETest do
       ast = H.parse!(query)
       H.assert_has_proof(ast)
 
-      {:ok, tc_result} = VQLTypeChecker.typecheck(ast)
+      {:ok, tc_result} = VCLTypeChecker.typecheck(ast)
       obligations = tc_result[:proof_obligations] || tc_result.proof_obligations
       assert is_list(obligations)
       assert length(obligations) >= 2
@@ -218,9 +218,9 @@ defmodule VeriSim.Query.VQLE2ETest do
           {obl, build_mock_witness(obl[:type])}
         end)
 
-      {:ok, certs} = VQLProofCertificate.generate_batch(witnesses)
+      {:ok, certs} = VCLProofCertificate.generate_batch(witnesses)
       assert length(certs) >= 2
-      assert :ok == VQLProofCertificate.verify_batch(certs)
+      assert :ok == VCLProofCertificate.verify_batch(certs)
     end
 
     test "tampered certificate fails verification" do
@@ -239,12 +239,12 @@ defmodule VeriSim.Query.VQLE2ETest do
         "modality_count" => 8
       }
 
-      {:ok, cert} = VQLProofCertificate.generate_certificate(obligation, witness)
-      assert :ok == VQLProofCertificate.verify_certificate(cert)
+      {:ok, cert} = VCLProofCertificate.generate_certificate(obligation, witness)
+      assert :ok == VCLProofCertificate.verify_certificate(cert)
 
       # Tamper with the witness
       tampered = %{cert | witness: Map.put(cert.witness, "modality_count", 999)}
-      assert {:error, :invalid_hash} == VQLProofCertificate.verify_certificate(tampered)
+      assert {:error, :invalid_hash} == VCLProofCertificate.verify_certificate(tampered)
     end
   end
 
@@ -292,19 +292,19 @@ defmodule VeriSim.Query.VQLE2ETest do
 
   describe "error paths" do
     test "empty query string returns parse error" do
-      assert {:error, _reason} = VQLBridge.parse("")
+      assert {:error, _reason} = VCLBridge.parse("")
     end
 
     test "gibberish returns parse error" do
-      assert {:error, _reason} = VQLBridge.parse("FROBNICATE THE WIDGET")
+      assert {:error, _reason} = VCLBridge.parse("FROBNICATE THE WIDGET")
     end
 
     test "unknown proof type is rejected by type checker" do
       query = "SELECT GRAPH.* FROM HEXAD 'entity-001' PROOF TELEPORT(entity-001)"
 
-      case VQLBridge.parse(query) do
+      case VCLBridge.parse(query) do
         {:ok, ast} ->
-          result = VQLTypeChecker.typecheck(ast)
+          result = VCLTypeChecker.typecheck(ast)
           assert {:error, _reason} = result
 
         {:error, _} ->
@@ -316,9 +316,9 @@ defmodule VeriSim.Query.VQLE2ETest do
     test "INTEGRITY proof without semantic modality is rejected" do
       query = "SELECT GRAPH.* FROM HEXAD 'entity-001' PROOF INTEGRITY(my_contract)"
 
-      case VQLBridge.parse(query) do
+      case VCLBridge.parse(query) do
         {:ok, ast} ->
-          case VQLTypeChecker.typecheck(ast) do
+          case VCLTypeChecker.typecheck(ast) do
             {:error, reason} ->
               # reason may be a tuple like {:modality_mismatch, "..."}
               reason_str = inspect(reason)
@@ -337,9 +337,9 @@ defmodule VeriSim.Query.VQLE2ETest do
     test "PROVENANCE proof without provenance modality is rejected" do
       query = "SELECT GRAPH.* FROM HEXAD 'entity-001' PROOF PROVENANCE(entity-001)"
 
-      case VQLBridge.parse(query) do
+      case VCLBridge.parse(query) do
         {:ok, ast} ->
-          case VQLTypeChecker.typecheck(ast) do
+          case VCLTypeChecker.typecheck(ast) do
             {:error, reason} ->
               reason_str = inspect(reason)
               assert reason_str =~ "provenance" or reason_str =~ "modality"
@@ -443,7 +443,7 @@ defmodule VeriSim.Query.VQLE2ETest do
   describe "mutation pipeline" do
     test "INSERT HEXAD parses via parse_statement" do
       query = "INSERT HEXAD WITH DOCUMENT(title = 'Test Entity', body = 'Integration test body')"
-      {:ok, ast} = VQLBridge.parse_statement(query)
+      {:ok, ast} = VCLBridge.parse_statement(query)
 
       # Mutation AST shape: %{TAG: "Mutation", _0: %{TAG: "Insert", ...}}
       assert ast[:TAG] == "Mutation" or ast[:type] == :insert or ast[:mutation_type] == :insert
@@ -456,7 +456,7 @@ defmodule VeriSim.Query.VQLE2ETest do
 
     test "UPDATE HEXAD parses with SET clause" do
       query = "UPDATE HEXAD 'entity-001' SET DOCUMENT.title = 'Updated Title'"
-      {:ok, ast} = VQLBridge.parse_statement(query)
+      {:ok, ast} = VCLBridge.parse_statement(query)
 
       assert ast[:TAG] == "Mutation" or ast[:type] == :update or ast[:mutation_type] == :update
       inner = ast[:_0] || ast
@@ -468,7 +468,7 @@ defmodule VeriSim.Query.VQLE2ETest do
 
     test "DELETE HEXAD parses with entity ID" do
       query = "DELETE HEXAD 'entity-to-delete'"
-      {:ok, ast} = VQLBridge.parse_statement(query)
+      {:ok, ast} = VCLBridge.parse_statement(query)
 
       assert ast[:TAG] == "Mutation" or ast[:type] == :delete or ast[:mutation_type] == :delete
       inner = ast[:_0] || ast
diff --git a/elixir-orchestration/test/verisim/query/vql_executor_test.exs b/elixir-orchestration/test/verisim/query/vcl_executor_test.exs
similarity index 79%
rename from elixir-orchestration/test/verisim/query/vql_executor_test.exs
rename to elixir-orchestration/test/verisim/query/vcl_executor_test.exs
index ae8e7d4..655f1c5 100644
--- a/elixir-orchestration/test/verisim/query/vql_executor_test.exs
+++ b/elixir-orchestration/test/verisim/query/vcl_executor_test.exs
@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: MPL-2.0
 
-defmodule VeriSim.Query.VQLExecutorTest do
+defmodule VeriSim.Query.VCLExecutorTest do
   @moduledoc """
-  Tests for VeriSim.Query.VQLExecutor — the 1812-LOC central executor
-  for parsed VQL queries and mutations.
+  Tests for VeriSim.Query.VCLExecutor — the 1812-LOC central executor
+  for parsed VCL queries and mutations.
 
-  The executor sits between the parser (VQLBridge) and the Rust core
+  The executor sits between the parser (VCLBridge) and the Rust core
   (via RustClient).  In test environments the Rust core is unreachable,
   so most real execution paths bottom out in `{:error, ...}` tuples.
   These tests cover what's testable independently:
@@ -23,12 +23,12 @@ defmodule VeriSim.Query.VQLExecutorTest do
 
   use ExUnit.Case, async: false
 
-  alias VeriSim.Query.VQLExecutor
+  alias VeriSim.Query.VCLExecutor
 
   describe "execute/2 with :explain option" do
     test "returns a structured plan with the documented keys" do
       ast = %{modalities: [:graph], source: {:octad, "abc-123"}}
-      assert {:ok, plan} = VQLExecutor.execute(ast, explain: true)
+      assert {:ok, plan} = VCLExecutor.execute(ast, explain: true)
 
       assert is_map(plan)
       assert Map.has_key?(plan, :strategy)
@@ -41,13 +41,13 @@ defmodule VeriSim.Query.VQLExecutorTest do
 
     test "default strategy is :sequential when no cross-modal conditions" do
       ast = %{modalities: [:graph], source: {:octad, "abc-123"}}
-      assert {:ok, plan} = VQLExecutor.execute(ast, explain: true)
+      assert {:ok, plan} = VCLExecutor.execute(ast, explain: true)
       assert plan.strategy == :sequential
     end
 
     test "octad source produces an 'Octad lookup' step" do
       ast = %{modalities: [:graph], source: {:octad, "entity-xyz"}}
-      {:ok, plan} = VQLExecutor.execute(ast, explain: true)
+      {:ok, plan} = VCLExecutor.execute(ast, explain: true)
 
       ops = Enum.map(plan.steps, & &1.operation)
       assert "Octad lookup" in ops
@@ -59,21 +59,21 @@ defmodule VeriSim.Query.VQLExecutorTest do
         source: {:federation, "/universities/*", :tolerate}
       }
 
-      {:ok, plan} = VQLExecutor.execute(ast, explain: true)
+      {:ok, plan} = VCLExecutor.execute(ast, explain: true)
       ops = Enum.map(plan.steps, & &1.operation)
       assert "Federation fan-out" in ops
     end
 
     test "store source produces a 'Store query' step" do
       ast = %{modalities: [:graph], source: {:store, "store-1"}}
-      {:ok, plan} = VQLExecutor.execute(ast, explain: true)
+      {:ok, plan} = VCLExecutor.execute(ast, explain: true)
       ops = Enum.map(plan.steps, & &1.operation)
       assert "Store query" in ops
     end
 
     test "reflect source produces a REFLECT step" do
       ast = %{modalities: [:graph], source: :reflect}
-      {:ok, plan} = VQLExecutor.execute(ast, explain: true)
+      {:ok, plan} = VCLExecutor.execute(ast, explain: true)
       ops = Enum.map(plan.steps, & &1.operation)
       assert Enum.any?(ops, &String.contains?(&1, "REFLECT"))
     end
@@ -82,8 +82,8 @@ defmodule VeriSim.Query.VQLExecutorTest do
       base_ast = %{modalities: [:graph], source: {:octad, "x"}}
       proof_ast = Map.put(base_ast, :proof, [%{type: "EXISTENCE", target: "y"}])
 
-      {:ok, base} = VQLExecutor.execute(base_ast, explain: true)
-      {:ok, with_proof} = VQLExecutor.execute(proof_ast, explain: true)
+      {:ok, base} = VCLExecutor.execute(base_ast, explain: true)
+      {:ok, with_proof} = VCLExecutor.execute(proof_ast, explain: true)
 
       assert with_proof.total_cost_ms > base.total_cost_ms
       assert with_proof.has_proof == true
@@ -98,8 +98,8 @@ defmodule VeriSim.Query.VQLExecutorTest do
         source: {:octad, "x"}
       }
 
-      {:ok, p1} = VQLExecutor.execute(one, explain: true)
-      {:ok, p5} = VQLExecutor.execute(five, explain: true)
+      {:ok, p1} = VCLExecutor.execute(one, explain: true)
+      {:ok, p5} = VCLExecutor.execute(five, explain: true)
       assert p5.total_cost_ms > p1.total_cost_ms
     end
 
@@ -109,7 +109,7 @@ defmodule VeriSim.Query.VQLExecutorTest do
         source: {:octad, "x"}
       }
 
-      {:ok, plan} = VQLExecutor.execute(ast, explain: true)
+      {:ok, plan} = VCLExecutor.execute(ast, explain: true)
       sum = Enum.reduce(plan.steps, 0, fn s, acc -> acc + Map.get(s, :cost_ms, 0) end)
       assert plan.total_cost_ms == sum
     end
@@ -117,12 +117,12 @@ defmodule VeriSim.Query.VQLExecutorTest do
 
   describe "execute_mutation/2 — routing" do
     test "unknown mutation tag returns {:error, {:invalid_mutation, _}}" do
-      assert {:error, {:invalid_mutation, _}} = VQLExecutor.execute_mutation(%{TAG: "Bogus"})
+      assert {:error, {:invalid_mutation, _}} = VCLExecutor.execute_mutation(%{TAG: "Bogus"})
     end
 
     test "Insert routes to execute_insert (errors when RustClient unreachable)" do
       mutation = %{TAG: "Insert", modalities: %{graph: %{}}, proof: nil}
-      result = VQLExecutor.execute_mutation(mutation)
+      result = VCLExecutor.execute_mutation(mutation)
       # In test env RustClient.create_octad/1 returns {:error, _}; the
       # executor wraps that as {:insert_failed, _}.  Either path is
       # acceptable — what we're verifying is that the dispatch reached
@@ -132,13 +132,13 @@ defmodule VeriSim.Query.VQLExecutorTest do
 
     test "Update routes to execute_update without raising" do
       mutation = %{TAG: "Update", octadId: "abc", sets: %{graph: %{}}, proof: nil}
-      result = VQLExecutor.execute_mutation(mutation)
+      result = VCLExecutor.execute_mutation(mutation)
       assert match?({:ok, _}, result) or match?({:error, _}, result)
     end
 
     test "Delete routes to execute_delete without raising" do
       mutation = %{TAG: "Delete", octadId: "abc", proof: nil}
-      result = VQLExecutor.execute_mutation(mutation)
+      result = VCLExecutor.execute_mutation(mutation)
       assert match?({:ok, _}, result) or match?({:error, _}, result)
     end
   end
@@ -150,22 +150,22 @@ defmodule VeriSim.Query.VQLExecutorTest do
         _0: %{modalities: [:graph], source: {:octad, "x"}}
       }
 
-      assert {:ok, _plan} = VQLExecutor.execute_statement(stmt, explain: true)
+      assert {:ok, _plan} = VCLExecutor.execute_statement(stmt, explain: true)
     end
 
     test "%{TAG: \"Mutation\", _0: mutation} dispatches to execute_mutation" do
       stmt = %{TAG: "Mutation", _0: %{TAG: "Bogus"}}
-      assert {:error, {:invalid_mutation, _}} = VQLExecutor.execute_statement(stmt)
+      assert {:error, {:invalid_mutation, _}} = VCLExecutor.execute_statement(stmt)
     end
 
     test "%{type: :query, ...} dispatches to execute/2" do
       stmt = %{type: :query, modalities: [:graph], source: {:octad, "x"}}
-      assert {:ok, _plan} = VQLExecutor.execute_statement(stmt, explain: true)
+      assert {:ok, _plan} = VCLExecutor.execute_statement(stmt, explain: true)
     end
 
     test "%{type: :mutation, mutation: ...} dispatches to execute_mutation" do
       stmt = %{type: :mutation, mutation: %{TAG: "Bogus"}}
-      assert {:error, {:invalid_mutation, _}} = VQLExecutor.execute_statement(stmt)
+      assert {:error, {:invalid_mutation, _}} = VCLExecutor.execute_statement(stmt)
     end
 
     test "unrecognised statement shape falls through to execute/2" do
@@ -173,22 +173,22 @@ defmodule VeriSim.Query.VQLExecutorTest do
       # as a query AST.  With :explain we get back a plan without
       # needing the Rust core.
       stmt = %{modalities: [:graph], source: {:octad, "x"}}
-      assert {:ok, _plan} = VQLExecutor.execute_statement(stmt, explain: true)
+      assert {:ok, _plan} = VCLExecutor.execute_statement(stmt, explain: true)
     end
   end
 
   describe "execute_string/2 — parse error propagation" do
     test "garbage input returns {:error, {:parse_error, _}}" do
-      assert {:error, {:parse_error, _}} = VQLExecutor.execute_string("THIS IS NOT VALID VQL", [])
+      assert {:error, {:parse_error, _}} = VCLExecutor.execute_string("THIS IS NOT VALID VCL", [])
     end
 
     test "empty string returns {:error, {:parse_error, _}}" do
-      assert {:error, {:parse_error, _}} = VQLExecutor.execute_string("", [])
+      assert {:error, {:parse_error, _}} = VCLExecutor.execute_string("", [])
     end
 
     test "valid query string with :explain returns a plan" do
       assert {:ok, plan} =
-               VQLExecutor.execute_string(
+               VCLExecutor.execute_string(
                  "SELECT GRAPH FROM HEXAD abc-123",
                  explain: true
                )
@@ -202,20 +202,20 @@ defmodule VeriSim.Query.VQLExecutorTest do
     test ":timeout defaults to 30_000 ms" do
       # Indirectly verified: passing no opts shouldn't raise.
       ast = %{modalities: [:graph], source: {:octad, "x"}}
-      assert {:ok, _} = VQLExecutor.execute(ast, explain: true)
+      assert {:ok, _} = VCLExecutor.execute(ast, explain: true)
     end
 
     test ":explain false (default) attempts real execution" do
       ast = %{modalities: [:graph], source: {:octad, "x"}}
       # Real execution hits RustClient.  Without it available, we
       # expect an error — but the call must not raise.
-      result = VQLExecutor.execute(ast)
+      result = VCLExecutor.execute(ast)
       assert match?({:ok, _}, result) or match?({:error, _}, result)
     end
 
     test ":explain false explicitly attempts real execution" do
       ast = %{modalities: [:graph], source: {:octad, "x"}}
-      result = VQLExecutor.execute(ast, explain: false)
+      result = VCLExecutor.execute(ast, explain: false)
       assert match?({:ok, _}, result) or match?({:error, _}, result)
     end
   end
diff --git a/elixir-orchestration/test/verisim/query/vql_integration_test.exs b/elixir-orchestration/test/verisim/query/vcl_integration_test.exs
similarity index 95%
rename from elixir-orchestration/test/verisim/query/vql_integration_test.exs
rename to elixir-orchestration/test/verisim/query/vcl_integration_test.exs
index 60966e5..f2d3b33 100644
--- a/elixir-orchestration/test/verisim/query/vql_integration_test.exs
+++ b/elixir-orchestration/test/verisim/query/vcl_integration_test.exs
@@ -1,8 +1,8 @@
 # SPDX-License-Identifier: MPL-2.0
 
-defmodule VeriSim.Query.VQLIntegrationTest do
+defmodule VeriSim.Query.VCLIntegrationTest do
   @moduledoc """
-  VQL Slipstream end-to-end integration tests.
+  VCL Slipstream end-to-end integration tests.
 
   Exercises the full parse → classify → execute → aggregate pipeline for the
   Slipstream (no-proof) path across all 8 octad modalities.
@@ -25,8 +25,8 @@ defmodule VeriSim.Query.VQLIntegrationTest do
 
   use ExUnit.Case, async: false
 
-  alias VeriSim.Query.{VQLBridge, VQLExecutor}
-  alias VeriSim.Test.VQLTestHelpers, as: H
+  alias VeriSim.Query.{VCLBridge, VCLExecutor}
+  alias VeriSim.Test.VCLTestHelpers, as: H
 
   setup_all do
     pid = H.ensure_bridge_started()
@@ -209,7 +209,7 @@ defmodule VeriSim.Query.VQLIntegrationTest do
       # COUNT(*) is an aggregate function — the built-in parser may not recognize
       # it as a modality during SELECT parsing, which is acceptable. The full
       # ReScript parser handles aggregates natively.
-      result = VQLBridge.parse("SELECT COUNT(*) FROM FEDERATION /*")
+      result = VCLBridge.parse("SELECT COUNT(*) FROM FEDERATION /*")
 
       case result do
         {:ok, ast} ->
@@ -293,7 +293,7 @@ defmodule VeriSim.Query.VQLIntegrationTest do
     test "parses REFLECT query — queries the query store itself" do
       # REFLECT is a source type: SELECT ... FROM REFLECT
       # The built-in parser may not support this directly, but it should not crash.
-      result = VQLBridge.parse("SELECT * FROM REFLECT")
+      result = VCLBridge.parse("SELECT * FROM REFLECT")
 
       case result do
         {:ok, ast} ->
@@ -315,7 +315,7 @@ defmodule VeriSim.Query.VQLIntegrationTest do
       query = "SELECT GRAPH.*, DOCUMENT.* FROM HEXAD 'entity-001'"
       ast = H.parse!(query)
 
-      {:ok, plan} = VQLExecutor.execute(ast, explain: true)
+      {:ok, plan} = VCLExecutor.execute(ast, explain: true)
 
       assert is_map(plan)
       assert Map.has_key?(plan, :strategy)
@@ -329,15 +329,15 @@ defmodule VeriSim.Query.VQLIntegrationTest do
 
   describe "error handling" do
     test "empty string returns parse error" do
-      assert {:error, {:parse_error, _}} = VQLExecutor.execute_string("")
+      assert {:error, {:parse_error, _}} = VCLExecutor.execute_string("")
     end
 
     test "nonsense returns parse error" do
-      assert {:error, {:parse_error, _}} = VQLExecutor.execute_string("JABBERWOCKY SNARK")
+      assert {:error, {:parse_error, _}} = VCLExecutor.execute_string("JABBERWOCKY SNARK")
     end
 
     test "missing FROM clause returns parse error" do
-      assert {:error, {:parse_error, _}} = VQLExecutor.execute_string("SELECT GRAPH.*")
+      assert {:error, {:parse_error, _}} = VCLExecutor.execute_string("SELECT GRAPH.*")
     end
   end
 end
diff --git a/elixir-orchestration/test/verisim/query/vql_proof_certificate_test.exs b/elixir-orchestration/test/verisim/query/vcl_proof_certificate_test.exs
similarity index 79%
rename from elixir-orchestration/test/verisim/query/vql_proof_certificate_test.exs
rename to elixir-orchestration/test/verisim/query/vcl_proof_certificate_test.exs
index e691823..c545d58 100644
--- a/elixir-orchestration/test/verisim/query/vql_proof_certificate_test.exs
+++ b/elixir-orchestration/test/verisim/query/vcl_proof_certificate_test.exs
@@ -1,8 +1,8 @@
 # SPDX-License-Identifier: MPL-2.0
 
-defmodule VeriSim.Query.VQLProofCertificateTest do
+defmodule VeriSim.Query.VCLProofCertificateTest do
   @moduledoc """
-  Tests for VQL-DT proof certificate generation and verification.
+  Tests for VCL-DT proof certificate generation and verification.
 
   Verifies that:
   1. Certificates are generated with correct structure and SHA-256 hash
@@ -14,7 +14,7 @@ defmodule VeriSim.Query.VQLProofCertificateTest do
 
   use ExUnit.Case, async: true
 
-  alias VeriSim.Query.VQLProofCertificate
+  alias VeriSim.Query.VCLProofCertificate
 
   # ---------------------------------------------------------------------------
   # Fixtures
@@ -70,7 +70,7 @@ defmodule VeriSim.Query.VQLProofCertificateTest do
   describe "generate_certificate/2" do
     test "produces a certificate with all required fields" do
       {:ok, cert} =
-        VQLProofCertificate.generate_certificate(existence_obligation(), existence_witness())
+        VCLProofCertificate.generate_certificate(existence_obligation(), existence_witness())
 
       assert cert.type == :existence
       assert cert.obligation == existence_obligation()
@@ -85,15 +85,15 @@ defmodule VeriSim.Query.VQLProofCertificateTest do
       bad_obligation = %{proofType: "EXISTENCE", contract: "x"}
 
       assert {:error, {:invalid_obligation, _}} =
-               VQLProofCertificate.generate_certificate(bad_obligation, %{})
+               VCLProofCertificate.generate_certificate(bad_obligation, %{})
     end
 
     test "rejects non-map arguments" do
       assert {:error, {:invalid_arguments, _}} =
-               VQLProofCertificate.generate_certificate("not a map", %{})
+               VCLProofCertificate.generate_certificate("not a map", %{})
 
       assert {:error, {:invalid_arguments, _}} =
-               VQLProofCertificate.generate_certificate(%{type: :existence}, "not a map")
+               VCLProofCertificate.generate_certificate(%{type: :existence}, "not a map")
     end
   end
 
@@ -104,33 +104,33 @@ defmodule VeriSim.Query.VQLProofCertificateTest do
   describe "verify_certificate/1" do
     test "valid certificate passes verification" do
       {:ok, cert} =
-        VQLProofCertificate.generate_certificate(existence_obligation(), existence_witness())
+        VCLProofCertificate.generate_certificate(existence_obligation(), existence_witness())
 
-      assert :ok = VQLProofCertificate.verify_certificate(cert)
+      assert :ok = VCLProofCertificate.verify_certificate(cert)
     end
 
     test "tampered obligation causes hash mismatch" do
       {:ok, cert} =
-        VQLProofCertificate.generate_certificate(existence_obligation(), existence_witness())
+        VCLProofCertificate.generate_certificate(existence_obligation(), existence_witness())
 
       tampered = %{cert | obligation: %{cert.obligation | type: :integrity}}
-      assert {:error, :invalid_hash} = VQLProofCertificate.verify_certificate(tampered)
+      assert {:error, :invalid_hash} = VCLProofCertificate.verify_certificate(tampered)
     end
 
     test "tampered witness causes hash mismatch" do
       {:ok, cert} =
-        VQLProofCertificate.generate_certificate(existence_obligation(), existence_witness())
+        VCLProofCertificate.generate_certificate(existence_obligation(), existence_witness())
 
       tampered = %{cert | witness: %{"octad_id" => "evil-entity"}}
-      assert {:error, :invalid_hash} = VQLProofCertificate.verify_certificate(tampered)
+      assert {:error, :invalid_hash} = VCLProofCertificate.verify_certificate(tampered)
     end
 
     test "malformed certificate returns error" do
-      assert {:error, :malformed_certificate} = VQLProofCertificate.verify_certificate(%{})
-      assert {:error, :malformed_certificate} = VQLProofCertificate.verify_certificate(nil)
+      assert {:error, :malformed_certificate} = VCLProofCertificate.verify_certificate(%{})
+      assert {:error, :malformed_certificate} = VCLProofCertificate.verify_certificate(nil)
 
       assert {:error, :malformed_certificate} =
-               VQLProofCertificate.verify_certificate("not a cert")
+               VCLProofCertificate.verify_certificate("not a cert")
     end
   end
 
@@ -145,13 +145,13 @@ defmodule VeriSim.Query.VQLProofCertificateTest do
         {provenance_obligation(), provenance_witness()}
       ]
 
-      {:ok, certs} = VQLProofCertificate.generate_batch(pairs)
+      {:ok, certs} = VCLProofCertificate.generate_batch(pairs)
       assert length(certs) == 2
       assert Enum.at(certs, 0).type == :existence
       assert Enum.at(certs, 1).type == :provenance
 
       # All certificates should verify
-      assert :ok = VQLProofCertificate.verify_batch(certs)
+      assert :ok = VCLProofCertificate.verify_batch(certs)
     end
 
     test "batch verification fails with index on tampered certificate" do
@@ -160,14 +160,14 @@ defmodule VeriSim.Query.VQLProofCertificateTest do
         {provenance_obligation(), provenance_witness()}
       ]
 
-      {:ok, certs} = VQLProofCertificate.generate_batch(pairs)
+      {:ok, certs} = VCLProofCertificate.generate_batch(pairs)
 
       # Tamper with the second certificate
       tampered_second = %{Enum.at(certs, 1) | witness: %{"chain_hash" => "tampered"}}
       tampered_batch = List.replace_at(certs, 1, tampered_second)
 
       assert {:error, {:batch_failure, 1, :invalid_hash}} =
-               VQLProofCertificate.verify_batch(tampered_batch)
+               VCLProofCertificate.verify_batch(tampered_batch)
     end
   end
 end
diff --git a/elixir-orchestration/test/verisim/query/vql_property_test.exs b/elixir-orchestration/test/verisim/query/vcl_property_test.exs
similarity index 89%
rename from elixir-orchestration/test/verisim/query/vql_property_test.exs
rename to elixir-orchestration/test/verisim/query/vcl_property_test.exs
index 6312606..b37c323 100644
--- a/elixir-orchestration/test/verisim/query/vql_property_test.exs
+++ b/elixir-orchestration/test/verisim/query/vcl_property_test.exs
@@ -1,8 +1,8 @@
 # SPDX-License-Identifier: MPL-2.0
 
-defmodule VeriSim.Query.VQLPropertyTest do
+defmodule VeriSim.Query.VCLPropertyTest do
   @moduledoc """
-  Property-based tests for the VQL type checker using StreamData.
+  Property-based tests for the VCL type checker using StreamData.
 
   Generates random valid proof specifications and verifies that the type
   checker handles them correctly — no crashes, proper error messages for
@@ -12,7 +12,7 @@ defmodule VeriSim.Query.VQLPropertyTest do
   use ExUnit.Case, async: true
   use ExUnitProperties
 
-  alias VeriSim.Query.VQLTypeChecker
+  alias VeriSim.Query.VCLTypeChecker
 
   # ---------------------------------------------------------------------------
   # Generators
@@ -60,14 +60,14 @@ defmodule VeriSim.Query.VQLPropertyTest do
 
   property "type checker never crashes on valid proof specs" do
     check all(query_ast <- valid_query_ast()) do
-      result = VQLTypeChecker.typecheck(query_ast)
+      result = VCLTypeChecker.typecheck(query_ast)
       assert match?({:ok, _}, result) or match?({:error, _}, result)
     end
   end
 
   property "type checker output has required fields when successful" do
     check all(query_ast <- valid_query_ast()) do
-      case VQLTypeChecker.typecheck(query_ast) do
+      case VCLTypeChecker.typecheck(query_ast) do
         {:ok, info} ->
           assert is_list(info.proof_obligations)
           assert info.composition_strategy in [:independent, :conjunction, :sequential]
@@ -88,7 +88,7 @@ defmodule VeriSim.Query.VQLPropertyTest do
             contract <- valid_contract_name()
           ) do
       raw = "#{String.upcase(proof_type)}(#{contract})"
-      specs = VQLTypeChecker.parse_proof_specs(%{raw: raw})
+      specs = VCLTypeChecker.parse_proof_specs(%{raw: raw})
 
       assert length(specs) == 1
       [spec] = specs
@@ -105,7 +105,7 @@ defmodule VeriSim.Query.VQLPropertyTest do
       parts = Enum.zip(types, contracts) |> Enum.map(fn {t, c} -> "#{String.upcase(t)}(#{c})" end)
       raw = Enum.join(parts, " AND ")
 
-      specs = VQLTypeChecker.parse_proof_specs(%{raw: raw})
+      specs = VCLTypeChecker.parse_proof_specs(%{raw: raw})
       assert length(specs) == length(types)
     end
   end
@@ -121,7 +121,7 @@ defmodule VeriSim.Query.VQLPropertyTest do
         proof: [%{raw: "#{bad_type}(test)"}]
       }
 
-      assert {:error, {:unknown_proof_type, _}} = VQLTypeChecker.typecheck(query_ast)
+      assert {:error, {:unknown_proof_type, _}} = VCLTypeChecker.typecheck(query_ast)
     end
   end
 end
diff --git a/elixir-orchestration/test/verisim/query/vql_test.exs b/elixir-orchestration/test/verisim/query/vcl_test.exs
similarity index 69%
rename from elixir-orchestration/test/verisim/query/vql_test.exs
rename to elixir-orchestration/test/verisim/query/vcl_test.exs
index e1c2b7c..846bcfd 100644
--- a/elixir-orchestration/test/verisim/query/vql_test.exs
+++ b/elixir-orchestration/test/verisim/query/vcl_test.exs
@@ -1,20 +1,20 @@
 # SPDX-License-Identifier: MPL-2.0
 
-defmodule VeriSim.Query.VQLTest do
+defmodule VeriSim.Query.VCLTest do
   @moduledoc """
-  VQL end-to-end tests for parsing, routing, and execution.
+  VCL end-to-end tests for parsing, routing, and execution.
 
-  Tests the VQL Slipstream path (no PROOF clause) across all 8 octad modalities.
-  Uses the built-in Elixir fallback parser via VQLBridge.parse/1.
+  Tests the VCL Slipstream path (no PROOF clause) across all 8 octad modalities.
+  Uses the built-in Elixir fallback parser via VCLBridge.parse/1.
   """
 
   use ExUnit.Case, async: false
 
-  alias VeriSim.Query.{VQLBridge, VQLExecutor}
+  alias VeriSim.Query.{VCLBridge, VCLExecutor}
 
   setup_all do
-    # Start VQLBridge GenServer (will fall back to built-in parser without Deno)
-    case VQLBridge.start_link([]) do
+    # Start VCLBridge GenServer (will fall back to built-in parser without Deno)
+    case VCLBridge.start_link([]) do
       {:ok, pid} -> %{bridge_pid: pid}
       {:error, {:already_started, pid}} -> %{bridge_pid: pid}
     end
@@ -24,80 +24,80 @@ defmodule VeriSim.Query.VQLTest do
   # Parse tests — verify the bridge produces a well-formed AST
   # ===========================================================================
 
-  describe "VQLBridge.parse/1 — SELECT queries" do
+  describe "VCLBridge.parse/1 — SELECT queries" do
     test "parses single-modality GRAPH query" do
-      {:ok, ast} = VQLBridge.parse("SELECT GRAPH.* FROM HEXAD 'abc-123'")
+      {:ok, ast} = VCLBridge.parse("SELECT GRAPH.* FROM HEXAD 'abc-123'")
       assert is_map(ast)
       assert ast[:modalities] || ast["modalities"]
     end
 
     test "parses single-modality VECTOR query" do
-      {:ok, ast} = VQLBridge.parse("SELECT VECTOR.* FROM HEXAD 'abc-123'")
+      {:ok, ast} = VCLBridge.parse("SELECT VECTOR.* FROM HEXAD 'abc-123'")
       assert is_map(ast)
     end
 
     test "parses single-modality DOCUMENT query" do
-      {:ok, ast} = VQLBridge.parse("SELECT DOCUMENT.* FROM HEXAD 'abc-123'")
+      {:ok, ast} = VCLBridge.parse("SELECT DOCUMENT.* FROM HEXAD 'abc-123'")
       assert is_map(ast)
     end
 
     test "parses single-modality TEMPORAL query" do
-      {:ok, ast} = VQLBridge.parse("SELECT TEMPORAL.* FROM HEXAD 'abc-123'")
+      {:ok, ast} = VCLBridge.parse("SELECT TEMPORAL.* FROM HEXAD 'abc-123'")
       assert is_map(ast)
     end
 
     test "parses single-modality PROVENANCE query" do
-      {:ok, ast} = VQLBridge.parse("SELECT PROVENANCE.* FROM HEXAD 'abc-123'")
+      {:ok, ast} = VCLBridge.parse("SELECT PROVENANCE.* FROM HEXAD 'abc-123'")
       assert is_map(ast)
     end
 
     test "parses single-modality SPATIAL query" do
-      {:ok, ast} = VQLBridge.parse("SELECT SPATIAL.* FROM HEXAD 'abc-123'")
+      {:ok, ast} = VCLBridge.parse("SELECT SPATIAL.* FROM HEXAD 'abc-123'")
       assert is_map(ast)
     end
 
     test "parses multi-modality query" do
-      {:ok, ast} = VQLBridge.parse("SELECT GRAPH.*, VECTOR.*, DOCUMENT.* FROM HEXAD 'abc-123'")
+      {:ok, ast} = VCLBridge.parse("SELECT GRAPH.*, VECTOR.*, DOCUMENT.* FROM HEXAD 'abc-123'")
 
       assert is_map(ast)
     end
 
     test "parses ALL modality wildcard" do
-      {:ok, ast} = VQLBridge.parse("SELECT * FROM HEXAD 'abc-123'")
+      {:ok, ast} = VCLBridge.parse("SELECT * FROM HEXAD 'abc-123'")
       assert is_map(ast)
     end
 
     test "parses query with WHERE clause" do
       {:ok, ast} =
-        VQLBridge.parse("SELECT DOCUMENT.* FROM HEXAD 'abc-123' WHERE DOCUMENT.title = 'Test'")
+        VCLBridge.parse("SELECT DOCUMENT.* FROM HEXAD 'abc-123' WHERE DOCUMENT.title = 'Test'")
 
       assert is_map(ast)
     end
 
     test "parses query with LIMIT and OFFSET" do
-      {:ok, ast} = VQLBridge.parse("SELECT GRAPH.* FROM HEXAD 'abc-123' LIMIT 10 OFFSET 5")
+      {:ok, ast} = VCLBridge.parse("SELECT GRAPH.* FROM HEXAD 'abc-123' LIMIT 10 OFFSET 5")
 
       assert is_map(ast)
     end
 
     test "parses query with ORDER BY" do
       {:ok, ast} =
-        VQLBridge.parse("SELECT DOCUMENT.* FROM HEXAD 'abc-123' ORDER BY DOCUMENT.title ASC")
+        VCLBridge.parse("SELECT DOCUMENT.* FROM HEXAD 'abc-123' ORDER BY DOCUMENT.title ASC")
 
       assert is_map(ast)
     end
 
     test "parses query with aggregate in projection" do
-      {:ok, ast} = VQLBridge.parse("SELECT GRAPH.* FROM HEXAD 'abc-123' LIMIT 5")
+      {:ok, ast} = VCLBridge.parse("SELECT GRAPH.* FROM HEXAD 'abc-123' LIMIT 5")
 
       assert is_map(ast)
     end
   end
 
-  describe "VQLBridge — mutations via parse_statement/1" do
+  describe "VCLBridge — mutations via parse_statement/1" do
     test "parses INSERT with document data" do
       {:ok, ast} =
-        VQLBridge.parse_statement("INSERT HEXAD WITH DOCUMENT(title = 'Test', body = 'Content')")
+        VCLBridge.parse_statement("INSERT HEXAD WITH DOCUMENT(title = 'Test', body = 'Content')")
 
       assert is_map(ast)
       assert ast[:TAG] == "Mutation" or ast["TAG"] == "Mutation"
@@ -105,25 +105,25 @@ defmodule VeriSim.Query.VQLTest do
 
     test "parses UPDATE with set clause" do
       {:ok, ast} =
-        VQLBridge.parse_statement("UPDATE HEXAD 'abc-123' SET DOCUMENT.title = 'Updated'")
+        VCLBridge.parse_statement("UPDATE HEXAD 'abc-123' SET DOCUMENT.title = 'Updated'")
 
       assert is_map(ast)
     end
 
     test "parses DELETE" do
-      {:ok, ast} = VQLBridge.parse_statement("DELETE HEXAD 'abc-123'")
+      {:ok, ast} = VCLBridge.parse_statement("DELETE HEXAD 'abc-123'")
 
       assert is_map(ast)
     end
   end
 
-  describe "VQLBridge.parse/1 — error cases" do
+  describe "VCLBridge.parse/1 — error cases" do
     test "rejects empty string" do
-      assert {:error, _} = VQLBridge.parse("")
+      assert {:error, _} = VCLBridge.parse("")
     end
 
     test "rejects gibberish" do
-      assert {:error, _} = VQLBridge.parse("THIS IS NOT VQL AT ALL")
+      assert {:error, _} = VCLBridge.parse("THIS IS NOT VCL AT ALL")
     end
   end
 
@@ -131,14 +131,14 @@ defmodule VeriSim.Query.VQLTest do
   # Executor tests — verify routing and error handling (without Rust core)
   # ===========================================================================
 
-  describe "VQLExecutor.execute_string/2" do
+  describe "VCLExecutor.execute_string/2" do
     test "returns parse error for invalid query" do
-      assert {:error, {:parse_error, _}} = VQLExecutor.execute_string("NOT VQL")
+      assert {:error, {:parse_error, _}} = VCLExecutor.execute_string("NOT VCL")
     end
 
     test "returns explain plan when explain option set" do
       result =
-        VQLExecutor.execute_string(
+        VCLExecutor.execute_string(
           "SELECT GRAPH.* FROM HEXAD 'abc-123'",
           explain: true
         )
@@ -154,15 +154,15 @@ defmodule VeriSim.Query.VQLTest do
     end
   end
 
-  describe "VQLExecutor.execute_statement/2" do
+  describe "VCLExecutor.execute_statement/2" do
     test "routes query AST through execute without crashing" do
-      {:ok, ast} = VQLBridge.parse_statement("SELECT GRAPH.* FROM HEXAD 'abc-123'")
+      {:ok, ast} = VCLBridge.parse_statement("SELECT GRAPH.* FROM HEXAD 'abc-123'")
 
       # Without Rust core running at 8080, the executor will fail to reach it.
       # We verify it does not crash (BadMapError, etc.) — any {:ok, _} or {:error, _} is fine.
       result =
         try do
-          VQLExecutor.execute_statement(ast, timeout: 1_000)
+          VCLExecutor.execute_statement(ast, timeout: 1_000)
         rescue
           # If the response is not JSON (e.g., some other HTTP server is on 8080),
           # the executor may blow up with a BadMapError — that's a test-env issue,
@@ -175,11 +175,11 @@ defmodule VeriSim.Query.VQLTest do
     end
 
     test "routes mutation AST through execute_mutation without crashing" do
-      {:ok, ast} = VQLBridge.parse_statement("DELETE HEXAD 'abc-123'")
+      {:ok, ast} = VCLBridge.parse_statement("DELETE HEXAD 'abc-123'")
 
       result =
         try do
-          VQLExecutor.execute_statement(ast, timeout: 1_000)
+          VCLExecutor.execute_statement(ast, timeout: 1_000)
         rescue
           _ -> {:error, :rust_core_unavailable}
         end
@@ -196,7 +196,7 @@ defmodule VeriSim.Query.VQLTest do
   describe "condition classification" do
     test "simple condition is pushed down" do
       {:ok, ast} =
-        VQLBridge.parse("SELECT GRAPH.* FROM HEXAD 'abc-123' WHERE GRAPH.type = 'Person'")
+        VCLBridge.parse("SELECT GRAPH.* FROM HEXAD 'abc-123' WHERE GRAPH.type = 'Person'")
 
       # The where clause should be present and classified as pushdown
       assert is_map(ast)
@@ -209,7 +209,7 @@ defmodule VeriSim.Query.VQLTest do
 
   describe "provenance query routing" do
     test "parses provenance-only query" do
-      {:ok, ast} = VQLBridge.parse("SELECT PROVENANCE.* FROM HEXAD 'abc-123'")
+      {:ok, ast} = VCLBridge.parse("SELECT PROVENANCE.* FROM HEXAD 'abc-123'")
 
       assert is_map(ast)
     end
@@ -221,7 +221,7 @@ defmodule VeriSim.Query.VQLTest do
 
   describe "spatial query routing" do
     test "parses spatial-only query" do
-      {:ok, ast} = VQLBridge.parse("SELECT SPATIAL.* FROM HEXAD 'abc-123'")
+      {:ok, ast} = VCLBridge.parse("SELECT SPATIAL.* FROM HEXAD 'abc-123'")
 
       assert is_map(ast)
     end
diff --git a/elixir-orchestration/test/verisim/query/vql_type_checker_test.exs b/elixir-orchestration/test/verisim/query/vcl_type_checker_test.exs
similarity index 84%
rename from elixir-orchestration/test/verisim/query/vql_type_checker_test.exs
rename to elixir-orchestration/test/verisim/query/vcl_type_checker_test.exs
index 5a90568..4b0b031 100644
--- a/elixir-orchestration/test/verisim/query/vql_type_checker_test.exs
+++ b/elixir-orchestration/test/verisim/query/vcl_type_checker_test.exs
@@ -1,8 +1,8 @@
 # SPDX-License-Identifier: MPL-2.0
 
-defmodule VeriSim.Query.VQLTypeCheckerTest do
+defmodule VeriSim.Query.VCLTypeCheckerTest do
   @moduledoc """
-  Tests for the Elixir-native VQL-DT type checker.
+  Tests for the Elixir-native VCL-DT type checker.
 
   Verifies that the type checker:
   1. Validates proof types are known
@@ -15,7 +15,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
 
   use ExUnit.Case, async: true
 
-  alias VeriSim.Query.VQLTypeChecker
+  alias VeriSim.Query.VCLTypeChecker
 
   # ===========================================================================
   # parse_proof_specs/1 — multi-proof splitting
@@ -24,7 +24,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
   describe "parse_proof_specs/1" do
     test "splits AND-connected proofs" do
       specs =
-        VQLTypeChecker.parse_proof_specs(%{
+        VCLTypeChecker.parse_proof_specs(%{
           raw: "EXISTENCE(entity-001) AND PROVENANCE(entity-001)"
         })
 
@@ -36,7 +36,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
     end
 
     test "splits OR-connected proofs" do
-      specs = VQLTypeChecker.parse_proof_specs(%{raw: "EXISTENCE(a) OR INTEGRITY(b)"})
+      specs = VCLTypeChecker.parse_proof_specs(%{raw: "EXISTENCE(a) OR INTEGRITY(b)"})
 
       assert length(specs) == 2
       assert Enum.at(specs, 0).proofType == "EXISTENCE"
@@ -44,7 +44,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
     end
 
     test "handles single proof spec" do
-      specs = VQLTypeChecker.parse_proof_specs(%{raw: "INTEGRITY(my_contract)"})
+      specs = VCLTypeChecker.parse_proof_specs(%{raw: "INTEGRITY(my_contract)"})
 
       assert length(specs) == 1
       assert Enum.at(specs, 0).proofType == "INTEGRITY"
@@ -52,7 +52,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
     end
 
     test "handles proof without parentheses" do
-      specs = VQLTypeChecker.parse_proof_specs(%{raw: "EXISTENCE entity-001"})
+      specs = VCLTypeChecker.parse_proof_specs(%{raw: "EXISTENCE entity-001"})
 
       assert length(specs) == 1
       assert Enum.at(specs, 0).proofType == "EXISTENCE"
@@ -61,7 +61,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
 
     test "handles three proofs" do
       specs =
-        VQLTypeChecker.parse_proof_specs(%{raw: "EXISTENCE(a) AND PROVENANCE(b) AND INTEGRITY(c)"})
+        VCLTypeChecker.parse_proof_specs(%{raw: "EXISTENCE(a) AND PROVENANCE(b) AND INTEGRITY(c)"})
 
       assert length(specs) == 3
       assert Enum.map(specs, & &1.proofType) == ["EXISTENCE", "PROVENANCE", "INTEGRITY"]
@@ -69,14 +69,14 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
 
     test "passes through structured specs unchanged" do
       input = %{proofType: "EXISTENCE", contractName: "entity-001"}
-      specs = VQLTypeChecker.parse_proof_specs(input)
+      specs = VCLTypeChecker.parse_proof_specs(input)
 
       assert length(specs) == 1
       assert Enum.at(specs, 0) == input
     end
 
     test "handles nil" do
-      assert VQLTypeChecker.parse_proof_specs(nil) == []
+      assert VCLTypeChecker.parse_proof_specs(nil) == []
     end
 
     test "handles list of specs" do
@@ -85,14 +85,14 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         %{proofType: "INTEGRITY", contractName: "b"}
       ]
 
-      specs = VQLTypeChecker.parse_proof_specs(input)
+      specs = VCLTypeChecker.parse_proof_specs(input)
 
       assert length(specs) == 2
     end
 
     test "handles list containing raw specs" do
       input = [%{raw: "EXISTENCE(a) AND PROVENANCE(b)"}]
-      specs = VQLTypeChecker.parse_proof_specs(input)
+      specs = VCLTypeChecker.parse_proof_specs(input)
 
       assert length(specs) == 2
     end
@@ -109,7 +109,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "EXISTENCE", contractName: "entity-001"}]
       }
 
-      assert {:ok, info} = VQLTypeChecker.typecheck(ast)
+      assert {:ok, info} = VCLTypeChecker.typecheck(ast)
       assert length(info.proof_obligations) == 1
       assert Enum.at(info.proof_obligations, 0).type == :existence
       assert info.composition_strategy == :independent
@@ -124,7 +124,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         ]
       }
 
-      assert {:ok, info} = VQLTypeChecker.typecheck(ast)
+      assert {:ok, info} = VCLTypeChecker.typecheck(ast)
       assert length(info.proof_obligations) == 2
       assert info.composition_strategy == :conjunction
     end
@@ -135,7 +135,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "PROVENANCE", contractName: "entity-001"}]
       }
 
-      assert {:ok, info} = VQLTypeChecker.typecheck(ast)
+      assert {:ok, info} = VCLTypeChecker.typecheck(ast)
       assert Enum.at(info.proof_obligations, 0).type == :provenance
     end
 
@@ -145,7 +145,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "INTEGRITY", contractName: "contract-001"}]
       }
 
-      assert {:ok, info} = VQLTypeChecker.typecheck(ast)
+      assert {:ok, info} = VCLTypeChecker.typecheck(ast)
       assert Enum.at(info.proof_obligations, 0).type == :integrity
     end
 
@@ -155,7 +155,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "CONSISTENCY", contractName: "entity-001"}]
       }
 
-      assert {:ok, info} = VQLTypeChecker.typecheck(ast)
+      assert {:ok, info} = VCLTypeChecker.typecheck(ast)
       assert Enum.at(info.proof_obligations, 0).type == :consistency
     end
 
@@ -165,7 +165,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "FRESHNESS", contractName: "entity-001"}]
       }
 
-      assert {:ok, info} = VQLTypeChecker.typecheck(ast)
+      assert {:ok, info} = VCLTypeChecker.typecheck(ast)
       assert Enum.at(info.proof_obligations, 0).type == :freshness
     end
 
@@ -175,7 +175,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: %{raw: "EXISTENCE(entity-001)"}
       }
 
-      assert {:ok, info} = VQLTypeChecker.typecheck(ast)
+      assert {:ok, info} = VCLTypeChecker.typecheck(ast)
       assert length(info.proof_obligations) == 1
     end
 
@@ -185,7 +185,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: %{raw: "EXISTENCE(entity-001) AND PROVENANCE(entity-001)"}
       }
 
-      assert {:ok, info} = VQLTypeChecker.typecheck(ast)
+      assert {:ok, info} = VCLTypeChecker.typecheck(ast)
       assert length(info.proof_obligations) == 2
     end
   end
@@ -197,7 +197,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "BOGUS", contractName: "entity-001"}]
       }
 
-      assert {:error, {:unknown_proof_type, msg}} = VQLTypeChecker.typecheck(ast)
+      assert {:error, {:unknown_proof_type, msg}} = VCLTypeChecker.typecheck(ast)
       assert msg =~ "BOGUS"
     end
 
@@ -207,7 +207,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "INTEGRITY"}]
       }
 
-      assert {:error, {:missing_contract, _}} = VQLTypeChecker.typecheck(ast)
+      assert {:error, {:missing_contract, _}} = VCLTypeChecker.typecheck(ast)
     end
 
     test "rejects CITATION proof without contract" do
@@ -216,7 +216,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "CITATION"}]
       }
 
-      assert {:error, {:missing_contract, _}} = VQLTypeChecker.typecheck(ast)
+      assert {:error, {:missing_contract, _}} = VCLTypeChecker.typecheck(ast)
     end
 
     test "rejects INTEGRITY proof with wrong modality" do
@@ -225,7 +225,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "INTEGRITY", contractName: "contract-001"}]
       }
 
-      assert {:error, {:modality_mismatch, msg}} = VQLTypeChecker.typecheck(ast)
+      assert {:error, {:modality_mismatch, msg}} = VCLTypeChecker.typecheck(ast)
       assert msg =~ "semantic"
     end
 
@@ -235,7 +235,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "PROVENANCE", contractName: "entity-001"}]
       }
 
-      assert {:error, {:modality_mismatch, msg}} = VQLTypeChecker.typecheck(ast)
+      assert {:error, {:modality_mismatch, msg}} = VCLTypeChecker.typecheck(ast)
       assert msg =~ "provenance"
     end
 
@@ -245,7 +245,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "FRESHNESS", contractName: "entity-001"}]
       }
 
-      assert {:error, {:modality_mismatch, msg}} = VQLTypeChecker.typecheck(ast)
+      assert {:error, {:modality_mismatch, msg}} = VCLTypeChecker.typecheck(ast)
       assert msg =~ "temporal"
     end
 
@@ -255,7 +255,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: []
       }
 
-      assert {:error, {:missing_proof, _}} = VQLTypeChecker.typecheck(ast)
+      assert {:error, {:missing_proof, _}} = VCLTypeChecker.typecheck(ast)
     end
 
     test "rejects query with nil proof" do
@@ -264,7 +264,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: nil
       }
 
-      assert {:error, {:missing_proof, _}} = VQLTypeChecker.typecheck(ast)
+      assert {:error, {:missing_proof, _}} = VCLTypeChecker.typecheck(ast)
     end
   end
 
@@ -279,7 +279,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "EXISTENCE", contractName: "entity-001"}]
       }
 
-      {:ok, info} = VQLTypeChecker.typecheck(ast)
+      {:ok, info} = VCLTypeChecker.typecheck(ast)
       obligation = Enum.at(info.proof_obligations, 0)
 
       assert is_list(obligation.witness_fields)
@@ -293,7 +293,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "EXISTENCE", contractName: "entity-001"}]
       }
 
-      {:ok, info} = VQLTypeChecker.typecheck(ast)
+      {:ok, info} = VCLTypeChecker.typecheck(ast)
       obligation = Enum.at(info.proof_obligations, 0)
 
       assert obligation.circuit == "existence-proof-v1"
@@ -308,7 +308,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         ]
       }
 
-      {:ok, info} = VQLTypeChecker.typecheck(ast)
+      {:ok, info} = VCLTypeChecker.typecheck(ast)
 
       assert info.total_estimated_ms > 0
 
@@ -323,7 +323,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "PROVENANCE", contractName: "entity-001"}]
       }
 
-      {:ok, info} = VQLTypeChecker.typecheck(ast)
+      {:ok, info} = VCLTypeChecker.typecheck(ast)
       assert Enum.at(info.proof_obligations, 0).circuit == "provenance-proof-v1"
     end
 
@@ -333,7 +333,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "INTEGRITY", contractName: "contract-001"}]
       }
 
-      {:ok, info} = VQLTypeChecker.typecheck(ast)
+      {:ok, info} = VCLTypeChecker.typecheck(ast)
       assert Enum.at(info.proof_obligations, 0).circuit == "integrity-proof-v1"
     end
   end
@@ -349,7 +349,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         proof: [%{proofType: "EXISTENCE", contractName: "entity-001"}]
       }
 
-      {:ok, info} = VQLTypeChecker.typecheck(ast)
+      {:ok, info} = VCLTypeChecker.typecheck(ast)
       assert info.composition_strategy == :independent
       assert info.is_parallelizable == true
     end
@@ -363,7 +363,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         ]
       }
 
-      {:ok, info} = VQLTypeChecker.typecheck(ast)
+      {:ok, info} = VCLTypeChecker.typecheck(ast)
       assert info.composition_strategy == :sequential
       assert info.is_parallelizable == false
     end
@@ -377,7 +377,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
         ]
       }
 
-      {:ok, info} = VQLTypeChecker.typecheck(ast)
+      {:ok, info} = VCLTypeChecker.typecheck(ast)
       assert info.composition_strategy == :conjunction
     end
   end
@@ -412,7 +412,7 @@ defmodule VeriSim.Query.VQLTypeCheckerTest do
           proof: [%{proofType: proof_type_str, contractName: contract}]
         }
 
-        result = VQLTypeChecker.typecheck(ast)
+        result = VCLTypeChecker.typecheck(ast)
 
         assert {:ok, info} = result,
                "#{proof_type_str} should be accepted, got: #{inspect(result)}"
diff --git a/elixir-orchestration/test/verisim/telemetry_test.exs b/elixir-orchestration/test/verisim/telemetry_test.exs
index 7308ad1..d7f6e83 100644
--- a/elixir-orchestration/test/verisim/telemetry_test.exs
+++ b/elixir-orchestration/test/verisim/telemetry_test.exs
@@ -206,7 +206,7 @@ defmodule VeriSim.TelemetryTest do
       assert drift.most_drifted == :semantic
     end
 
-    test "proof_type_usage/0 tracks VQL-DT adoption" do
+    test "proof_type_usage/0 tracks VCL-DT adoption" do
       Collector.increment_map(:proof_type_usage, "EXISTENCE", 3)
       Collector.increment_map(:proof_type_usage, "INTEGRITY", 2)
 
