test(ingest): prove minimal mode does zero LLM work and stays queryable

- pkg/ingest/minimal_mode_test.go: a minimal-mode pipeline run with an
  LLM client that fails the test on any call reaches StatusReady with
  sections persisted and a call counter of 0 — proving minimal ingest is
  pure-Go. A second test reconstructs the persisted tree and confirms the
  synthesised-TOC fallback is title-bearing and section bodies load back
  from storage.
- pkg/retrieval: TestPageIndexMinimalIngestedDoc drives the page-based
  strategy end-to-end against a minimal-ingested doc shape (page ranges +
  content refs, NO summaries, nil TOC) and asserts it produces a cited
  answer from the synthesised TOC + raw page reads.
- pkg/config: default mode is "full"; VLE_INGEST_MODE=minimal override
  and Validate accept/reject coverage.
- Document ingest.mode in both example configs.

Author: hallelx2

config.example.yaml

@@ -294,10 +294,37 @@ retrieval:
     model: ""
 
 ingest:
+  # Ingest mode — how much work the pipeline does before a document is
+  # marked `ready` (queryable).
+  #
+  #   full     (default) parse -> build tree -> persist -> summarize ->
+  #            HyDE -> multi-axis summaries -> TOC build. Maximises
+  #            retrieval quality but costs ~1,000-3,000 LLM calls plus a
+  #            pdftable table-finding pass on a large filing — minutes of
+  #            wall time for a 90-page 10-K.
+  #
+  #   minimal  parse -> build tree -> persist -> ready. Skips ALL
+  #            per-section LLM enrichment (summarize, HyDE, multi-axis,
+  #            TOC build) AND the pdftable table-extraction pass, so a
+  #            document becomes queryable in ~parse-speed (seconds).
+  #            The page-based strategy (/v1/answer/pageindex) needs none
+  #            of the skipped work: it navigates a TOC synthesised from
+  #            the section tree (documents.toc_tree is left NULL) and
+  #            reads raw section/page text at query time — and that raw
+  #            page text still contains the tables' text, so dropping
+  #            table *sections* loses nothing for it. The
+  #            summary-dependent strategies (chunked-tree, agentic)
+  #            degrade to titles + raw content with no summaries.
+  #
+  # Override per-process with VLE_INGEST_MODE; on the deployed
+  # vectorless-server use VLS_INGEST_MODE=minimal (no secret edit needed).
+  mode: "full"
+
   # The summarize and HyDE stages run concurrently. This caps the total
   # number of LLM calls in flight across both stages combined, so the
   # provider's per-tenant concurrency limit isn't exceeded. 0 disables
   # the global cap; default applied by the engine is 12.
+  # (Ignored when mode: minimal — no LLM stages run.)
   global_llm_concurrency: 12
 
   # HyDE candidate-question stage. For each leaf section the pipeline asks

config.server.example.yaml

@@ -99,9 +99,21 @@ engine:
       include_sibling_breadcrumbs: true
 
   ingest:
+    # Ingest mode: full (default) | minimal.
+    #   full     parse -> persist -> summarize -> HyDE -> multi-axis ->
+    #            TOC build. Maximum retrieval quality; minutes on a large
+    #            filing.
+    #   minimal  parse -> persist -> ready. Skips every LLM enrichment
+    #            stage AND table extraction — queryable in seconds. The
+    #            page-based strategy (/v1/answer/pageindex) works on it
+    #            unchanged (synthesised TOC + raw page reads).
+    # Flip the live service without a secret edit: VLS_INGEST_MODE=minimal.
+    mode: "full"
+
     # The summarize and HyDE stages run concurrently. This caps the total
     # number of LLM calls in flight across both stages combined.
     # 0 disables the global cap; default is 12.
+    # (Ignored when mode: minimal — no LLM stages run.)
     global_llm_concurrency: 12
 
     # HyDE candidate-question generation per leaf section. Folded into

pkg/config/config_test.go

@@ -84,6 +84,52 @@ func TestDefaultValues(t *testing.T) {
 	}
 }
 
+// TestIngestModeDefault locks the default ingest mode to "full" so the
+// current full-enrichment behaviour is preserved unless explicitly
+// switched.
+func TestIngestModeDefault(t *testing.T) {
+	t.Parallel()
+	cfg := Default()
+	if cfg.Ingest.Mode != "full" {
+		t.Errorf("ingest.mode = %q, want full (default)", cfg.Ingest.Mode)
+	}
+}
+
+// TestIngestModeEnvOverride covers the VLE_INGEST_MODE override — the
+// single env var that flips the engine into fast/minimal ingest.
+func TestIngestModeEnvOverride(t *testing.T) {
+	prev := os.Getenv("VLE_INGEST_MODE")
+	defer os.Setenv("VLE_INGEST_MODE", prev)
+
+	os.Setenv("VLE_INGEST_MODE", "minimal")
+	cfg := Default()
+	applyEnvOverrides(&cfg)
+	if cfg.Ingest.Mode != "minimal" {
+		t.Errorf("VLE_INGEST_MODE=minimal not applied, got %q", cfg.Ingest.Mode)
+	}
+}
+
+// TestIngestModeValidate asserts Validate accepts the documented values
+// (and empty, which Default normalises to full) and rejects garbage.
+func TestIngestModeValidate(t *testing.T) {
+	t.Parallel()
+	for _, m := range []string{"", "full", "minimal"} {
+		cfg := Default()
+		cfg.Database.URL = "postgres://localhost/test"
+		cfg.Ingest.Mode = m
+		if err := cfg.Validate(); err != nil {
+			t.Errorf("ingest.mode=%q should pass validation, got %v", m, err)
+		}
+	}
+
+	cfg := Default()
+	cfg.Database.URL = "postgres://localhost/test"
+	cfg.Ingest.Mode = "turbo"
+	if err := cfg.Validate(); err == nil {
+		t.Error("ingest.mode=turbo should fail validation")
+	}
+}
+
 func TestTOCEnvOverride(t *testing.T) {
 	// Mutates env — restore on exit. Not parallel.
 	keys := []string{