@gmickel/gno 0.17.0 → 0.19.0

package/README.md

@@ -32,7 +32,27 @@ GNO is a local knowledge engine that turns your documents into a searchable, con
 
 ---
 
-## What's New in v0.15
+## What's New in v0.19
+
+- **Exclusion Filters**: explicit `exclude` controls across CLI, API, Web, and MCP to hard-prune unwanted docs by title/path/body text
+- **Ask Query-Mode Parity**: Ask now supports structured `term` / `intent` / `hyde` controls in both API and Web UI
+
+### v0.18
+
+- **Intent Steering**: optional `intent` control for ambiguous queries across CLI, API, Web, and MCP query flows
+- **Rerank Controls**: `candidateLimit` lets you tune rerank cost vs. recall on slower or memory-constrained machines
+- **Stability**: query expansion now uses a bounded configurable context size (`models.expandContextSize`, default `2048`)
+- **Rerank Efficiency**: identical chunk texts are deduplicated before scoring and expanded back out deterministically
+
+### v0.17
+
+- **Structured Query Modes**: `term`, `intent`, and `hyde` controls across CLI, API, MCP, and Web
+- **Temporal Retrieval Upgrades**: `since`/`until`, date-range parsing, and recency sorting with frontmatter-date fallback
+- **Web Retrieval UX Polish**: richer advanced controls in Search and Ask (collection/date/category/author/tags + query modes)
+- **Metadata-Aware Retrieval**: ingestion now materializes document metadata/date fields for better filtering and ranking
+- **Migration Reliability**: SQLite-compatible migration path for existing indexes (including older SQLite engines)
+
+### v0.15
 
 - **HTTP Backends**: Offload embedding, reranking, and generation to remote GPU servers
 - Simple URI config: `http://host:port/path#modelname`
@@ -146,6 +166,8 @@ gno search "handleAuth"              # Find exact matches
 gno vsearch "error handling patterns" # Semantic similarity
 gno query "database optimization"    # Full pipeline
 gno query "meeting decisions" --since "last month" --category "meeting,notes" --author "gordon"
+gno query "performance" --intent "web performance and latency"
+gno query "performance" --exclude "reviews,hiring"
 gno ask "what did we decide" --answer # AI synthesis
 ```
 
@@ -161,6 +183,8 @@ gno query "auth flow" --thorough
 
 # Structured retrieval intent
 gno query "auth flow" \
+  --intent "web authentication and token lifecycle" \
+  --candidate-limit 12 \
   --query-mode term:"jwt refresh token -oauth1" \
   --query-mode intent:"how refresh token rotation works" \
   --query-mode hyde:"Refresh tokens rotate on each use and previous tokens are revoked." \

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "embeddings",

package/src/cli/commands/ask.ts

@@ -192,14 +192,17 @@ export async function ask(
       limit,
       collection: options.collection,
       lang: options.lang,
+      intent: options.intent,
       since: options.since,
       until: options.until,
       categories: options.categories,
       author: options.author,
       tagsAll: options.tagsAll,
       tagsAny: options.tagsAny,
+      exclude: options.exclude,
       noExpand: options.noExpand,
       noRerank: options.noRerank,
+      candidateLimit: options.candidateLimit,
     });
 
     if (!searchResult.ok) {
@@ -258,6 +261,10 @@ export async function ask(
         expanded: searchResult.value.meta.expanded ?? false,
         reranked: searchResult.value.meta.reranked ?? false,
         vectorsUsed: searchResult.value.meta.vectorsUsed ?? false,
+        intent: searchResult.value.meta.intent,
+        candidateLimit: searchResult.value.meta.candidateLimit,
+        exclude: searchResult.value.meta.exclude,
+        queryModes: searchResult.value.meta.queryModes,
         answerGenerated,
         totalResults: results.length,
         answerContext,

package/src/cli/commands/models/use.ts

@@ -58,6 +58,7 @@ export async function modelsUse(
       presets: config.models?.presets ?? [],
       loadTimeout: config.models?.loadTimeout ?? 60_000,
       inferenceTimeout: config.models?.inferenceTimeout ?? 30_000,
+      expandContextSize: config.models?.expandContextSize ?? 2_048,
       warmModelTtl: config.models?.warmModelTtl ?? 300_000,
     },
   };

package/src/cli/program.ts

@@ -224,6 +224,11 @@ function wireSearchCommands(program: Command): void {
     )
     .option("--category <values>", "require category match (comma-separated)")
     .option("--author <text>", "filter by author (case-insensitive contains)")
+    .option("--intent <text>", "disambiguating context for ambiguous queries")
+    .option(
+      "--exclude <values>",
+      "exclude docs containing any term (comma-separated)"
+    )
     .option("--tags-all <tags>", "require ALL tags (comma-separated)")
     .option("--tags-any <tags>", "require ANY tag (comma-separated)")
     .option("--full", "include full content")
@@ -269,6 +274,7 @@ function wireSearchCommands(program: Command): void {
         ? parsePositiveInt("limit", cmdOpts.limit)
         : getDefaultLimit(format);
       const categories = parseCsvValues(cmdOpts.category);
+      const exclude = parseCsvValues(cmdOpts.exclude);
 
       const { search, formatSearch } = await import("./commands/search");
       const result = await search(queryText, {
@@ -280,6 +286,8 @@ function wireSearchCommands(program: Command): void {
         until: cmdOpts.until as string | undefined,
         categories,
         author: cmdOpts.author as string | undefined,
+        intent: cmdOpts.intent as string | undefined,
+        exclude,
         tagsAll,
         tagsAny,
         full: Boolean(cmdOpts.full),
@@ -329,6 +337,11 @@ function wireSearchCommands(program: Command): void {
     )
     .option("--category <values>", "require category match (comma-separated)")
     .option("--author <text>", "filter by author (case-insensitive contains)")
+    .option("--intent <text>", "disambiguating context for ambiguous queries")
+    .option(
+      "--exclude <values>",
+      "exclude docs containing any term (comma-separated)"
+    )
     .option("--tags-all <tags>", "require ALL tags (comma-separated)")
     .option("--tags-any <tags>", "require ANY tag (comma-separated)")
     .option("--full", "include full content")
@@ -374,6 +387,7 @@ function wireSearchCommands(program: Command): void {
         ? parsePositiveInt("limit", cmdOpts.limit)
         : getDefaultLimit(format);
       const categories = parseCsvValues(cmdOpts.category);
+      const exclude = parseCsvValues(cmdOpts.exclude);
 
       const { vsearch, formatVsearch } = await import("./commands/vsearch");
       const result = await vsearch(queryText, {
@@ -385,6 +399,8 @@ function wireSearchCommands(program: Command): void {
         until: cmdOpts.until as string | undefined,
         categories,
         author: cmdOpts.author as string | undefined,
+        intent: cmdOpts.intent as string | undefined,
+        exclude,
         tagsAll,
         tagsAny,
         full: Boolean(cmdOpts.full),
@@ -429,6 +445,11 @@ function wireSearchCommands(program: Command): void {
     )
     .option("--category <values>", "require category match (comma-separated)")
     .option("--author <text>", "filter by author (case-insensitive contains)")
+    .option("--intent <text>", "disambiguating context for ambiguous queries")
+    .option(
+      "--exclude <values>",
+      "exclude docs containing any term (comma-separated)"
+    )
     .option("--tags-all <tags>", "require ALL tags (comma-separated)")
     .option("--tags-any <tags>", "require ANY tag (comma-separated)")
     .option("--full", "include full content")
@@ -443,6 +464,7 @@ function wireSearchCommands(program: Command): void {
       (value: string, previous: string[] = []) => [...previous, value],
       []
     )
+    .option("-C, --candidate-limit <num>", "max candidates passed to reranking")
     .option("--explain", "include scoring explanation")
     .option("--json", "JSON output")
     .option("--md", "Markdown output")
@@ -495,7 +517,11 @@ function wireSearchCommands(program: Command): void {
       const limit = cmdOpts.limit
         ? parsePositiveInt("limit", cmdOpts.limit)
         : getDefaultLimit(format);
+      const candidateLimit = cmdOpts.candidateLimit
+        ? parsePositiveInt("candidate-limit", cmdOpts.candidateLimit)
+        : undefined;
       const categories = parseCsvValues(cmdOpts.category);
+      const exclude = parseCsvValues(cmdOpts.exclude);
 
       // Determine expansion/rerank settings based on flags
       // Priority: --fast > --thorough > --no-expand/--no-rerank > default
@@ -531,12 +557,15 @@ function wireSearchCommands(program: Command): void {
         until: cmdOpts.until as string | undefined,
         categories,
         author: cmdOpts.author as string | undefined,
+        intent: cmdOpts.intent as string | undefined,
+        exclude,
         tagsAll,
         tagsAny,
         full: Boolean(cmdOpts.full),
         lineNumbers: Boolean(cmdOpts.lineNumbers),
         noExpand,
         noRerank,
+        candidateLimit,
         queryModes,
         explain: Boolean(cmdOpts.explain),
         json: format === "json",
@@ -574,8 +603,14 @@ function wireSearchCommands(program: Command): void {
     )
     .option("--category <values>", "require category match (comma-separated)")
     .option("--author <text>", "filter by author (case-insensitive contains)")
+    .option("--intent <text>", "disambiguating context for ambiguous queries")
+    .option(
+      "--exclude <values>",
+      "exclude docs containing any term (comma-separated)"
+    )
     .option("--fast", "skip expansion and reranking (fastest)")
     .option("--thorough", "enable query expansion (slower)")
+    .option("-C, --candidate-limit <num>", "max candidates passed to reranking")
     .option("--answer", "generate short grounded answer")
     .option("--no-answer", "force retrieval-only output")
     .option("--max-answer-tokens <num>", "max answer tokens")
@@ -594,12 +629,16 @@ function wireSearchCommands(program: Command): void {
       const limit = cmdOpts.limit
         ? parsePositiveInt("limit", cmdOpts.limit)
         : getDefaultLimit(format);
+      const candidateLimit = cmdOpts.candidateLimit
+        ? parsePositiveInt("candidate-limit", cmdOpts.candidateLimit)
+        : undefined;
 
       // Parse max-answer-tokens (optional, defaults to 512 in command impl)
       const maxAnswerTokens = cmdOpts.maxAnswerTokens
         ? parsePositiveInt("max-answer-tokens", cmdOpts.maxAnswerTokens)
         : undefined;
       const categories = parseCsvValues(cmdOpts.category);
+      const exclude = parseCsvValues(cmdOpts.exclude);
 
       // Determine expansion/rerank settings based on flags
       // Default: skip expansion (balanced mode)
@@ -624,8 +663,11 @@ function wireSearchCommands(program: Command): void {
         until: cmdOpts.until as string | undefined,
         categories,
         author: cmdOpts.author as string | undefined,
+        intent: cmdOpts.intent as string | undefined,
+        exclude,
         noExpand,
         noRerank,
+        candidateLimit,
         // Per spec: --answer defaults to false, --no-answer forces retrieval-only
         // Commander creates separate cmdOpts.noAnswer for --no-answer flag
         answer: Boolean(cmdOpts.answer),

package/src/config/types.ts

@@ -209,6 +209,8 @@ export const ModelConfigSchema = z.object({
   loadTimeout: z.number().default(60_000),
   /** Inference timeout in ms */
   inferenceTimeout: z.number().default(30_000),
+  /** Context size used for query expansion generation */
+  expandContextSize: z.number().int().min(256).default(2_048),
   /** Keep warm model TTL in ms (5 min) */
   warmModelTtl: z.number().default(300_000),
 });

package/src/llm/nodeLlamaCpp/generation.ts

@@ -56,7 +56,9 @@ export class NodeLlamaCppGeneration implements GenerationPort {
     }
 
     const llamaModel = model.value.model as LlamaModel;
-    const context = await llamaModel.createContext();
+    const context = await llamaModel.createContext(
+      params?.contextSize ? { contextSize: params.contextSize } : undefined
+    );
 
     try {
       // Import LlamaChatSession dynamically

package/src/llm/registry.ts

@@ -25,6 +25,7 @@ export function getModelConfig(config: Config): ModelConfig {
       : DEFAULT_MODEL_PRESETS,
     loadTimeout: config.models?.loadTimeout ?? 60_000,
     inferenceTimeout: config.models?.inferenceTimeout ?? 30_000,
+    expandContextSize: config.models?.expandContextSize ?? 2_048,
     warmModelTtl: config.models?.warmModelTtl ?? 300_000,
   };
 }

package/src/llm/types.ts

@@ -54,6 +54,8 @@ export interface GenParams {
   seed?: number;
   /** Max tokens to generate. Default: 256 */
   maxTokens?: number;
+  /** Optional context size override for the generation context */
+  contextSize?: number;
   /** Stop sequences */
   stop?: string[];
 }

package/src/mcp/tools/index.ts

@@ -56,6 +56,8 @@ const searchInputSchema = z.object({
   limit: z.number().int().min(1).max(100).default(5),
   minScore: z.number().min(0).max(1).optional(),
   lang: z.string().optional(),
+  intent: z.string().optional(),
+  exclude: z.array(z.string()).optional(),
   since: z.string().optional(),
   until: z.string().optional(),
   categories: z.array(z.string()).optional(),
@@ -105,6 +107,8 @@ const vsearchInputSchema = z.object({
   limit: z.number().int().min(1).max(100).default(5),
   minScore: z.number().min(0).max(1).optional(),
   lang: z.string().optional(),
+  intent: z.string().optional(),
+  exclude: z.array(z.string()).optional(),
   since: z.string().optional(),
   until: z.string().optional(),
   categories: z.array(z.string()).optional(),
@@ -124,6 +128,9 @@ export const queryInputSchema = z.object({
   limit: z.number().int().min(1).max(100).default(5),
   minScore: z.number().min(0).max(1).optional(),
   lang: z.string().optional(),
+  intent: z.string().optional(),
+  candidateLimit: z.number().int().min(1).max(100).optional(),
+  exclude: z.array(z.string()).optional(),
   since: z.string().optional(),
   until: z.string().optional(),
   categories: z.array(z.string()).optional(),

package/src/mcp/tools/query.ts

@@ -36,6 +36,9 @@ interface QueryInput {
   limit?: number;
   minScore?: number;
   lang?: string;
+  intent?: string;
+  candidateLimit?: number;
+  exclude?: string[];
   since?: string;
   until?: string;
   categories?: string[];
@@ -247,6 +250,9 @@ export function handleQuery(
           minScore: args.minScore,
           collection: args.collection,
           queryLanguageHint: args.lang, // Affects expansion prompt, not retrieval
+          intent: args.intent,
+          candidateLimit: args.candidateLimit,
+          exclude: args.exclude,
           since: args.since,
           until: args.until,
           categories: args.categories,

package/src/mcp/tools/search.ts

@@ -19,6 +19,8 @@ interface SearchInput {
   limit?: number;
   minScore?: number;
   lang?: string;
+  intent?: string;
+  exclude?: string[];
   since?: string;
   until?: string;
   categories?: string[];
@@ -108,6 +110,8 @@ export function handleSearch(
         minScore: args.minScore,
         collection: args.collection,
         lang: args.lang,
+        intent: args.intent,
+        exclude: args.exclude,
         since: args.since,
         until: args.until,
         categories: args.categories,

package/src/mcp/tools/vsearch.ts

@@ -28,6 +28,8 @@ interface VsearchInput {
   limit?: number;
   minScore?: number;
   lang?: string;
+  intent?: string;
+  exclude?: string[];
   since?: string;
   until?: string;
   categories?: string[];
@@ -192,6 +194,8 @@ export function handleVsearch(
             limit: args.limit ?? 5,
             minScore: args.minScore,
             collection: args.collection,
+            intent: args.intent,
+            exclude: args.exclude,
             since: args.since,
             until: args.until,
             categories: args.categories,

package/src/pipeline/exclude.ts

@@ -0,0 +1,69 @@
+/**
+ * Explicit exclusion helpers for retrieval filters.
+ *
+ * @module src/pipeline/exclude
+ */
+
+import type { ChunkRow } from "../store/types";
+
+export function normalizeExcludeTerms(values: string[]): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+
+  for (const value of values) {
+    for (const part of value.split(",")) {
+      const trimmed = part.trim();
+      if (!trimmed) {
+        continue;
+      }
+      const key = trimmed.toLowerCase();
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      out.push(trimmed);
+    }
+  }
+
+  return out;
+}
+
+function includesTerm(haystack: string, term: string): boolean {
+  return haystack.toLowerCase().includes(term.toLowerCase());
+}
+
+export function matchesExcludedText(
+  haystacks: string[],
+  excludeTerms: string[] | undefined
+): boolean {
+  if (!excludeTerms?.length) {
+    return false;
+  }
+
+  for (const haystack of haystacks) {
+    if (!haystack) {
+      continue;
+    }
+    for (const term of excludeTerms) {
+      if (includesTerm(haystack, term)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+export function matchesExcludedChunks(
+  chunks: ChunkRow[],
+  excludeTerms: string[] | undefined
+): boolean {
+  if (!excludeTerms?.length || chunks.length === 0) {
+    return false;
+  }
+
+  return matchesExcludedText(
+    chunks.map((chunk) => chunk.text),
+    excludeTerms
+  );
+}

package/src/pipeline/expansion.ts

@@ -67,9 +67,16 @@ const STOPWORDS = new Set([
 export function generateCacheKey(
   modelUri: string,
   query: string,
-  lang: string
+  lang: string,
+  intent?: string
 ): string {
-  const data = [EXPANSION_PROMPT_VERSION, modelUri, query, lang].join("\0");
+  const data = [
+    EXPANSION_PROMPT_VERSION,
+    modelUri,
+    query,
+    lang,
+    intent?.trim() ?? "",
+  ].join("\0");
   return createHash("sha256").update(data).digest("hex");
 }
 
@@ -150,6 +157,24 @@ function getPromptTemplate(lang?: string): string {
   }
 }
 
+function buildPrompt(query: string, template: string, intent?: string): string {
+  const basePrompt = template.replace("{query}", query);
+  const trimmedIntent = intent?.trim();
+  if (!trimmedIntent) {
+    return basePrompt;
+  }
+
+  return basePrompt
+    .replace(
+      `Query: "${query}"\n`,
+      `Query: "${query}"\nQuery intent: "${trimmedIntent}"\n`
+    )
+    .replace(
+      `Anfrage: "${query}"\n`,
+      `Anfrage: "${query}"\nQuery intent: "${trimmedIntent}"\n`
+    );
+}
+
 interface QuerySignals {
   quotedPhrases: string[];
   negations: string[];
@@ -405,6 +430,10 @@ export interface ExpansionOptions {
   lang?: string;
   /** Timeout in milliseconds */
   timeout?: number;
+  /** Optional context that steers expansion for ambiguous queries */
+  intent?: string;
+  /** Optional bounded context size override for expansion generation */
+  contextSize?: number;
 }
 
 /**
@@ -420,7 +449,7 @@ export async function expandQuery(
 
   // Build prompt
   const template = getPromptTemplate(options.lang);
-  const prompt = template.replace("{query}", query);
+  const prompt = buildPrompt(query, template, options.intent);
 
   // Run with timeout (clear timer to avoid resource leak)
   let timeoutId: ReturnType<typeof setTimeout> | undefined;
@@ -434,6 +463,7 @@ export async function expandQuery(
         temperature: 0,
         seed: 42,
         maxTokens: 512,
+        contextSize: options.contextSize,
       }),
       timeoutPromise,
     ]);
@@ -486,7 +516,12 @@ export async function expandQueryCached(
   options: ExpansionOptions = {}
 ): Promise<StoreResult<ExpansionResult | null>> {
   const lang = options.lang ?? "auto";
-  const cacheKey = generateCacheKey(deps.genPort.modelUri, query, lang);
+  const cacheKey = generateCacheKey(
+    deps.genPort.modelUri,
+    query,
+    lang,
+    options.intent
+  );
 
   // Check cache
   const cached = await deps.getCache(cacheKey);

package/src/pipeline/hybrid.ts

@@ -21,6 +21,7 @@ import type {
 import { err, ok } from "../store/types";
 import { createChunkLookup } from "./chunk-lookup";
 import { formatQueryForEmbedding } from "./contextual";
+import { matchesExcludedChunks, matchesExcludedText } from "./exclude";
 import { expandQuery } from "./expansion";
 import {
   buildExplainResults,
@@ -35,6 +36,7 @@ import {
   explainVector,
 } from "./explain";
 import { type RankedInput, rrfFuse, toRankedInput } from "./fusion";
+import { selectBestChunkForSteering } from "./intent";
 import { detectQueryLanguage } from "./query-language";
 import {
   buildExpansionFromQueryModes,
@@ -329,16 +331,18 @@ export async function searchHybrid(
   }
 
   if (expansionStatus !== "provided" && shouldExpand) {
-    const hasStrongSignal = await checkBm25Strength(store, query, {
-      collection: options.collection,
-      lang: options.lang,
-      tagsAll: options.tagsAll,
-      tagsAny: options.tagsAny,
-      since: temporalRange.since,
-      until: temporalRange.until,
-      categories: options.categories,
-      author: options.author,
-    });
+    const hasStrongSignal = options.intent?.trim()
+      ? false
+      : await checkBm25Strength(store, query, {
+          collection: options.collection,
+          lang: options.lang,
+          tagsAll: options.tagsAll,
+          tagsAny: options.tagsAny,
+          since: temporalRange.since,
+          until: temporalRange.until,
+          categories: options.categories,
+          author: options.author,
+        });
 
     if (hasStrongSignal) {
       expansionStatus = "skipped_strong";
@@ -349,6 +353,8 @@ export async function searchHybrid(
         // Use queryLanguage for prompt selection, NOT options.lang (retrieval filter)
         lang: queryLanguage,
         timeout: pipelineConfig.expansionTimeout,
+        intent: options.intent,
+        contextSize: deps.config.models?.expandContextSize,
       });
       if (expandResult.ok) {
         expansion = expandResult.value;
@@ -496,13 +502,16 @@ export async function searchHybrid(
   // 4. Reranking
   // ─────────────────────────────────────────────────────────────────────────
   const rerankStartedAt = performance.now();
+  const candidateLimit =
+    options.candidateLimit ?? pipelineConfig.rerankCandidates;
   const rerankResult = await rerankCandidates(
     { rerankPort: options.noRerank ? null : rerankPort, store },
     query,
     fusedCandidates,
     {
-      maxCandidates: pipelineConfig.rerankCandidates,
+      maxCandidates: candidateLimit,
       blendingSchedule: pipelineConfig.blendingSchedule,
+      intent: options.intent,
     }
   );
   if (rerankResult.fallbackReason === "disabled") {
@@ -513,10 +522,7 @@ export async function searchHybrid(
   timings.rerankMs = performance.now() - rerankStartedAt;
 
   explainLines.push(
-    explainRerank(
-      !options.noRerank && rerankPort !== null,
-      pipelineConfig.rerankCandidates
-    )
+    explainRerank(!options.noRerank && rerankPort !== null, candidateLimit)
   );
 
   // ─────────────────────────────────────────────────────────────────────────
@@ -665,6 +671,25 @@ export async function searchHybrid(
       continue;
     }
 
+    const excluded =
+      matchesExcludedText(
+        [
+          doc.title ?? "",
+          doc.relPath,
+          doc.author ?? "",
+          doc.contentType ?? "",
+          ...(doc.categories ?? []),
+        ],
+        options.exclude
+      ) ||
+      matchesExcludedChunks(
+        chunksMap.get(candidate.mirrorHash) ?? [],
+        options.exclude
+      );
+    if (excluded) {
+      continue;
+    }
+
     // For --full mode, de-dupe by docid (keep best scoring candidate per doc)
     if (options.full && seenDocids.has(doc.docid)) {
       continue;
@@ -692,10 +717,23 @@ export async function searchHybrid(
     const collectionPath = collectionPaths.get(doc.collection);
 
     // For --full mode, fetch full mirror content
-    let snippet = chunk.text;
+    const snippetChunk =
+      options.full || !options.intent?.trim()
+        ? chunk
+        : (selectBestChunkForSteering(
+            chunksMap.get(candidate.mirrorHash) ?? [],
+            query,
+            options.intent,
+            {
+              preferredSeq: chunk.seq,
+              intentWeight: 0.3,
+            }
+          ) ?? chunk);
+
+    let snippet = snippetChunk.text;
     let snippetRange: { startLine: number; endLine: number } | undefined = {
-      startLine: chunk.startLine,
-      endLine: chunk.endLine,
+      startLine: snippetChunk.startLine,
+      endLine: snippetChunk.endLine,
     };
 
     if (options.full) {
@@ -791,12 +829,15 @@ export async function searchHybrid(
       reranked: rerankResult.reranked,
       vectorsUsed: vectorAvailable,
       totalResults: finalResults.length,
+      intent: options.intent,
+      exclude: options.exclude,
       collection: options.collection,
       lang: options.lang,
       since: temporalRange.since,
       until: temporalRange.until,
       categories: options.categories,
       author: options.author,
+      candidateLimit,
       queryLanguage,
       queryModes: queryModeSummary,
       explain: explainData,