@unbrained/pm-cli 2026.6.6 → 2026.6.8

package/dist/cli-bundle/chunks/{search-JPUQTVCY.js → search-EQDHSE4G.js}

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b58cad50-da5e-5276-b71a-3499854f773b")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="1eb1787d-185d-5d6c-9933-0f8e2635576f")}catch(e){}}();
 import {
   collectStaleVectorizationIds
 } from "./chunk-IUV734HF.js";
@@ -13,40 +13,42 @@ import {
   resolveEmbeddingProviders,
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores
-} from "./chunk-4LL6TK5B.js";
+} from "./chunk-PQDH3S54.js";
 import {
   collectRuntimeFilterValues,
   matchesRuntimeFilters,
   parseStatusFilterCsv
-} from "./chunk-GCOQW437.js";
+} from "./chunk-SDLEYY6A.js";
 import {
   parseLimit,
   parsePriority,
   parseType
-} from "./chunk-3VAM3NNM.js";
+} from "./chunk-NDSMKB2I.js";
 import "./chunk-XSLQSXAH.js";
 import {
   collectRegisteredItemFieldNames,
   listAllDocumentCandidatesCached,
   listAllFrontMatter,
   toItemRecord
-} from "./chunk-GGYWB3Y2.js";
-import "./chunk-HZGUAH22.js";
+} from "./chunk-ODN53S6H.js";
+import "./chunk-4TI3532H.js";
 import {
   isTerminalStatus,
   parseItemDocument
-} from "./chunk-LB3RUL2N.js";
+} from "./chunk-XEKZCBCS.js";
 import {
   resolveItemTypeRegistry
-} from "./chunk-2VBQ6ZXS.js";
+} from "./chunk-Z2HXAFFH.js";
 import {
   compareTimestampStrings,
   nowIso,
   resolveIsoOrRelative
-} from "./chunk-TCD3R2PF.js";
+} from "./chunk-XZS4MV37.js";
 import {
   EXIT_CODE,
   PmCliError,
+  coerceNumberInRange,
+  coercePositiveInteger,
   getActiveExtensionRegistrations,
   getItemPath,
   getSettingsPath,
@@ -58,8 +60,9 @@ import {
   resolveRuntimeFieldRegistry,
   resolveRuntimeStatusRegistry,
   runActiveOnReadHooks,
+  toNonEmptyString,
   toNonEmptyStringOrUndefined
-} from "./chunk-5SFCOO6B.js";
+} from "./chunk-YJAKN2N2.js";
 
 // dist/cli/commands/search.js
 import fs from "node:fs/promises";
@@ -104,6 +107,205 @@ function tokenizeAlphaNumeric(value) {
   return normalizeLowercaseWhitespace(value).split(/[^a-z0-9]+/).filter((token) => token.length > 0);
 }
 
+// dist/core/search/relevance.js
+var DEFAULT_QUERY_EXPANSION_MAX_QUERIES = 4;
+var DEFAULT_RERANK_TOP_K = 20;
+var MAX_RERANK_TOP_K = 200;
+var QUERY_EXPANSION_STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "for",
+  "from",
+  "in",
+  "into",
+  "of",
+  "on",
+  "or",
+  "the",
+  "to",
+  "with"
+]);
+function dedupeQueries(values, limit) {
+  const deduped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of values) {
+    const normalized = entry.trim().replaceAll(/\s+/g, " ");
+    if (normalized.length === 0) {
+      continue;
+    }
+    const dedupeKey = normalized.toLowerCase();
+    if (seen.has(dedupeKey)) {
+      continue;
+    }
+    seen.add(dedupeKey);
+    deduped.push(normalized);
+    if (deduped.length >= limit) {
+      break;
+    }
+  }
+  return deduped;
+}
+function singularizeSimple(token) {
+  const normalizedToken = token.toLowerCase();
+  if (normalizedToken.length > 4 && normalizedToken.endsWith("ies")) {
+    return `${normalizedToken.slice(0, -3)}y`;
+  }
+  if (normalizedToken.length > 4 && (normalizedToken.endsWith("ches") || normalizedToken.endsWith("shes") || normalizedToken.endsWith("xes") || normalizedToken.endsWith("zes") || normalizedToken.endsWith("sses"))) {
+    return normalizedToken.slice(0, -2);
+  }
+  if (normalizedToken.length > 3 && normalizedToken.endsWith("s") && !normalizedToken.endsWith("ss") && !normalizedToken.endsWith("us") && !normalizedToken.endsWith("is") && !normalizedToken.endsWith("as")) {
+    return normalizedToken.slice(0, -1);
+  }
+  return normalizedToken;
+}
+function pluralizeSimple(token) {
+  const normalizedToken = token.toLowerCase();
+  if (normalizedToken.length > 2 && (!normalizedToken.endsWith("s") || normalizedToken.endsWith("ss"))) {
+    if (normalizedToken.endsWith("y") && !/[aeiou]y$/u.test(normalizedToken)) {
+      return `${normalizedToken.slice(0, -1)}ies`;
+    }
+    if (normalizedToken.endsWith("ch") || normalizedToken.endsWith("sh") || normalizedToken.endsWith("x") || normalizedToken.endsWith("z") || normalizedToken.endsWith("ss")) {
+      return `${normalizedToken}es`;
+    }
+    return `${normalizedToken}s`;
+  }
+  return normalizedToken;
+}
+function buildDeterministicQueryExpansions(query, maxQueries = DEFAULT_QUERY_EXPANSION_MAX_QUERIES) {
+  const normalizedQuery = query.trim().replaceAll(/\s+/g, " ");
+  if (normalizedQuery.length === 0) {
+    return [];
+  }
+  const tokens = tokenizeAlphaNumeric(normalizedQuery);
+  if (tokens.length === 0) {
+    return [normalizedQuery];
+  }
+  const contentTokens = tokens.filter((token) => !QUERY_EXPANSION_STOP_WORDS.has(token.toLowerCase()));
+  const singularized = tokens.map((token) => singularizeSimple(token));
+  const pluralized = contentTokens.map((token) => pluralizeSimple(token));
+  return dedupeQueries([
+    normalizedQuery,
+    tokens.join(" "),
+    contentTokens.join(" "),
+    singularized.join(" "),
+    pluralized.join(" ")
+  ], Math.max(1, maxQueries));
+}
+function normalizeQueryExpansionOutput(raw) {
+  const rawQueries = Array.isArray(raw) ? raw : raw?.queries;
+  if (!Array.isArray(rawQueries)) {
+    return [];
+  }
+  return dedupeQueries(rawQueries.filter((entry) => typeof entry === "string"), DEFAULT_QUERY_EXPANSION_MAX_QUERIES);
+}
+function mergeQueryExpansions(base, extra, maxQueries) {
+  return dedupeQueries([...base, ...extra], Math.max(1, maxQueries));
+}
+function resolveQueryExpansionConfig(settings, fallbackProviderName) {
+  const search = settings.search;
+  const queryExpansion = search?.query_expansion;
+  const configuredProvider = toNonEmptyString(queryExpansion?.provider);
+  return {
+    enabled: queryExpansion?.enabled === true,
+    provider: configuredProvider ?? fallbackProviderName,
+    max_queries: DEFAULT_QUERY_EXPANSION_MAX_QUERIES
+  };
+}
+function resolveRerankConfig(settings, fallbackModel) {
+  const search = settings.search;
+  const rerank = search?.rerank;
+  const configuredModel = toNonEmptyString(rerank?.model);
+  const configuredTopK = coercePositiveInteger(rerank?.top_k);
+  const normalizedTopK = configuredTopK ?? DEFAULT_RERANK_TOP_K;
+  return {
+    enabled: rerank?.enabled === true,
+    model: configuredModel ?? fallbackModel,
+    top_k: Math.min(MAX_RERANK_TOP_K, normalizedTopK)
+  };
+}
+function normalizeRerankOutput(raw) {
+  const rawHits = Array.isArray(raw) ? raw : raw?.hits;
+  if (!Array.isArray(rawHits)) {
+    return [];
+  }
+  const bestById = /* @__PURE__ */ new Map();
+  for (const entry of rawHits) {
+    if (typeof entry !== "object" || entry === null) {
+      continue;
+    }
+    const id = toNonEmptyString(entry.id);
+    const score = entry.score;
+    if (!id || typeof score !== "number" || !Number.isFinite(score)) {
+      continue;
+    }
+    const existing = bestById.get(id);
+    if (existing === void 0 || score > existing) {
+      bestById.set(id, score);
+    }
+  }
+  const normalized = [...bestById.entries()].map(([id, score]) => ({ id, score }));
+  normalized.sort((left, right) => {
+    if (left.score !== right.score) {
+      return right.score - left.score;
+    }
+    return left.id.localeCompare(right.id);
+  });
+  return normalized;
+}
+function dotProduct(left, right) {
+  const size = left.length;
+  let result = 0;
+  for (let index = 0; index < size; index += 1) {
+    result += left[index] * right[index];
+  }
+  return result;
+}
+function l2Norm(vector) {
+  let sumSquares = 0;
+  for (let index = 0; index < vector.length; index += 1) {
+    sumSquares += vector[index] * vector[index];
+  }
+  return Math.sqrt(sumSquares);
+}
+function cosineSimilarityWithKnownLeftNorm(left, right, leftNorm) {
+  if (!left || !right || left.length === 0 || right.length === 0 || left.length !== right.length) {
+    return 0;
+  }
+  const numerator = dotProduct(left, right);
+  const rightNorm = l2Norm(right);
+  const denominator = leftNorm * rightNorm;
+  if (!Number.isFinite(numerator) || !Number.isFinite(leftNorm) || !Number.isFinite(rightNorm) || !Number.isFinite(denominator) || denominator === 0) {
+    return 0;
+  }
+  return Math.max(-1, Math.min(1, numerator / denominator));
+}
+async function rerankCandidatesWithEmbeddings(provider, model, query, candidates, timeoutMs) {
+  if (candidates.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const effectiveModel = toNonEmptyString(model) ?? provider.model;
+  const rerankProvider = effectiveModel === provider.model ? provider : { ...provider, model: effectiveModel };
+  const payload = [query.trim(), ...candidates.map((entry) => entry.text)];
+  const vectors = await executeEmbeddingRequest(rerankProvider, payload, timeoutMs ? { timeout_ms: timeoutMs } : {});
+  const queryVector = vectors[0];
+  if (!queryVector) {
+    return /* @__PURE__ */ new Map();
+  }
+  const queryNorm = l2Norm(queryVector);
+  const scoreById = /* @__PURE__ */ new Map();
+  for (let index = 0; index < candidates.length; index += 1) {
+    const candidate = candidates[index];
+    const candidateVector = vectors[index + 1];
+    if (!candidateVector) {
+      continue;
+    }
+    const similarity = cosineSimilarityWithKnownLeftNorm(queryVector, candidateVector, queryNorm);
+    scoreById.set(candidate.id, Math.max(0, Math.min(1, (similarity + 1) / 2)));
+  }
+  return scoreById;
+}
+
 // dist/cli/commands/search.js
 var DEFAULT_COMPACT_SEARCH_FIELDS = [
   "id",
@@ -177,6 +379,53 @@ var LONG_QUERY_TITLE_EXACT_BONUS = 120;
 var LONG_QUERY_PHRASE_MULTIPLIER = 6;
 var IMPLICIT_HYBRID_EMBEDDING_TIMEOUT_MS = 8e3;
 var IMPLICIT_HYBRID_VECTOR_TIMEOUT_MS = 8e3;
+function isNonEmptyRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+function buildCompactSearchFilterSummary(params) {
+  const { mode, options, includeLinked, titleExact, phraseExact, scoreThreshold, hybridSemanticWeight, runtimeFieldFilters } = params;
+  const filters = {};
+  if (options.status !== void 0) {
+    filters.status = options.status;
+  }
+  if (options.type !== void 0) {
+    filters.type = options.type;
+  }
+  if (options.tag !== void 0) {
+    filters.tag = options.tag;
+  }
+  if (options.priority !== void 0) {
+    filters.priority = options.priority;
+  }
+  if (options.deadlineBefore !== void 0) {
+    filters.deadline_before = options.deadlineBefore;
+  }
+  if (options.deadlineAfter !== void 0) {
+    filters.deadline_after = options.deadlineAfter;
+  }
+  if (includeLinked) {
+    filters.include_linked = true;
+  }
+  if (titleExact) {
+    filters.title_exact = true;
+  }
+  if (phraseExact) {
+    filters.phrase_exact = true;
+  }
+  if (scoreThreshold > 0) {
+    filters.score_threshold = scoreThreshold;
+  }
+  if (mode === "hybrid" && options.semanticWeight !== void 0) {
+    filters.hybrid_semantic_weight = hybridSemanticWeight;
+  }
+  if (options.limit !== void 0) {
+    filters.limit = options.limit;
+  }
+  if (isNonEmptyRecord(runtimeFieldFilters)) {
+    filters.runtime_filters = runtimeFieldFilters;
+  }
+  return filters;
+}
 function collectErrorCauseCodes(error) {
   const codes = [];
   let current = error;
@@ -253,6 +502,9 @@ function parseTitleExact(raw) {
 function parsePhraseExact(raw) {
   return raw === true;
 }
+function parseSemanticWeightOverride(raw) {
+  return coerceNumberInRange(raw, 0, 1) ?? void 0;
+}
 function normalizeSearchPhrase(value) {
   return value.toLowerCase().replace(/\s+/g, " ").trim();
 }
@@ -654,7 +906,28 @@ function resolveSearchTuning(settings) {
     linked_content_weight: resolveWeight(tuning.linked_content_weight, defaults.linked_content_weight)
   };
 }
-function emptySearchResult(query, mode, options, includeLinked, scoreThreshold, hybridSemanticWeight, projection, warnings) {
+function emptySearchResult(query, mode, options, includeLinked, scoreThreshold, hybridSemanticWeight, queryExpansion, rerank, projection, warnings, runtimeFieldFilters) {
+  const compactSummaryMode = projection.mode === "compact" && options.compact === true;
+  if (compactSummaryMode) {
+    const compactFilters = buildCompactSearchFilterSummary({
+      mode,
+      options,
+      includeLinked,
+      titleExact: options.titleExact === true,
+      phraseExact: options.phraseExact === true,
+      scoreThreshold,
+      hybridSemanticWeight,
+      runtimeFieldFilters
+    });
+    return {
+      query: query.trim(),
+      mode,
+      items: [],
+      count: 0,
+      filters: compactFilters,
+      ...warnings.length > 0 ? { warnings } : {}
+    };
+  }
   const projectionFields = projection.mode === "full" ? null : [...projection.fields];
   return {
     query: query.trim(),
@@ -674,6 +947,11 @@ function emptySearchResult(query, mode, options, includeLinked, scoreThreshold,
       phrase_exact: options.phraseExact === true,
       score_threshold: scoreThreshold,
       hybrid_semantic_weight: mode === "hybrid" ? hybridSemanticWeight : null,
+      query_expansion_enabled: queryExpansion.enabled,
+      query_expansion_provider: queryExpansion.provider,
+      rerank_enabled: rerank.enabled,
+      rerank_model: rerank.model,
+      rerank_top_k: rerank.top_k,
       limit: options.limit ?? null
     },
     projection: {
@@ -697,25 +975,40 @@ function requireSemanticDependencies(requestedMode, providerResolution, vectorRe
   };
 }
 var toOptionalNonEmptyString = toNonEmptyStringOrUndefined;
-function resolveExtensionSearchProvider(settings) {
+function resolveExtensionSearchProviderByName(providerName) {
   const registrations = getActiveExtensionRegistrations();
-  const providerName = toOptionalNonEmptyString(settings.search?.provider);
   const resolved = resolveRegisteredSearchProvider(registrations, providerName);
   if (!resolved) {
     return null;
   }
   const runtimeDefinition = resolved.runtime_definition ?? resolved.definition;
   const query = runtimeDefinition.query;
-  if (typeof query !== "function") {
-    return null;
-  }
+  const queryExpansion = runtimeDefinition.queryExpansion ?? runtimeDefinition.query_expansion;
+  const rerank = runtimeDefinition.rerank;
   const registeredName = toOptionalNonEmptyString(runtimeDefinition.name) ?? toOptionalNonEmptyString(resolved.definition.name) ?? providerName;
   if (!registeredName) {
     return null;
   }
-  return {
+  const hooks = {
     providerName: registeredName,
-    query
+    ...typeof query === "function" ? { query } : {},
+    ...typeof queryExpansion === "function" ? { queryExpansion } : {},
+    ...typeof rerank === "function" ? { rerank } : {}
+  };
+  if (!hooks.query && !hooks.queryExpansion && !hooks.rerank) {
+    return null;
+  }
+  return hooks;
+}
+function resolveExtensionSearchProvider(settings) {
+  const providerName = toOptionalNonEmptyString(settings.search?.provider);
+  const resolved = resolveExtensionSearchProviderByName(providerName);
+  if (!resolved?.query) {
+    return null;
+  }
+  return {
+    providerName: resolved.providerName,
+    query: resolved.query
   };
 }
 function resolveExtensionVectorAdapter(settings) {
@@ -817,39 +1110,172 @@ function combineHybridHits(filteredById, semanticScores, keywordHits, hybridSema
     };
   }).filter((entry) => entry !== null);
 }
+function mergeVectorHitsById(vectorHitGroups) {
+  const bestById = /* @__PURE__ */ new Map();
+  for (const group of vectorHitGroups) {
+    for (const hit of group) {
+      const existing = bestById.get(hit.id);
+      if (!existing || hit.score > existing.score) {
+        bestById.set(hit.id, hit);
+      }
+    }
+  }
+  const merged = [...bestById.values()];
+  merged.sort((left, right) => {
+    if (left.score !== right.score) {
+      return right.score - left.score;
+    }
+    return left.id.localeCompare(right.id);
+  });
+  return merged;
+}
+function buildRerankCorpus(document) {
+  const metadata = document.metadata;
+  const tags = Array.isArray(metadata?.tags) ? metadata.tags.join(" ") : "";
+  return [
+    metadata?.title,
+    metadata?.description,
+    metadata?.type,
+    metadata?.status,
+    tags,
+    document.body
+  ].map((entry) => typeof entry === "string" ? entry.trim() : "").filter((entry) => entry.length > 0).join("\n");
+}
 async function computeSemanticOrHybridHits(context) {
   const semanticLimit = context.limit ?? context.maxResults;
   const embeddingOptions = context.embeddingTimeoutMs !== void 0 ? { timeout_ms: context.embeddingTimeoutMs } : {};
   const vectorQueryOptions = context.vectorQueryTimeoutMs !== void 0 ? { timeout_ms: context.vectorQueryTimeoutMs } : {};
-  const queryVectors = await executeEmbeddingRequest(context.provider, context.query.trim(), embeddingOptions);
-  const semanticVector = queryVectors[0];
-  let vectorHits;
-  if (context.extensionVectorAdapter?.query) {
-    try {
-      vectorHits = await Promise.resolve(context.extensionVectorAdapter.query({
-        vector: semanticVector,
-        limit: semanticLimit,
-        settings: context.settings
-      }));
-    } catch (error) {
-      if (!context.vectorStore) {
-        throw new PmCliError(`Extension vector adapter query failed and no built-in fallback store is configured (${error instanceof Error ? error.message : String(error)})`, EXIT_CODE.GENERIC_FAILURE);
+  const queryTrimmed = context.query.trim();
+  const baseExpandedQueries = context.queryExpansion.enabled ? buildDeterministicQueryExpansions(queryTrimmed, context.queryExpansion.max_queries) : [queryTrimmed];
+  let expandedQueries = baseExpandedQueries.length > 0 ? baseExpandedQueries : [queryTrimmed];
+  if (context.queryExpansion.enabled) {
+    if (context.queryExpansionExtension?.expand) {
+      try {
+        const rawExpansion = await Promise.resolve(context.queryExpansionExtension.expand({
+          query: queryTrimmed,
+          mode: context.requestedMode,
+          settings: context.settings
+        }));
+        const extensionExpansion = normalizeQueryExpansionOutput(rawExpansion);
+        expandedQueries = mergeQueryExpansions(expandedQueries, extensionExpansion, context.queryExpansion.max_queries);
+      } catch {
+        context.warnings.push(`search_query_expansion_provider_failed:${context.queryExpansionExtension.providerName}:using_builtin`);
       }
-      vectorHits = await executeVectorQuery(context.vectorStore, semanticVector, semanticLimit, vectorQueryOptions);
+    } else if (context.queryExpansion.provider && context.queryExpansion.provider !== "openai" && context.queryExpansion.provider !== "ollama") {
+      context.warnings.push(`search_query_expansion_provider_unavailable:${context.queryExpansion.provider}:using_builtin`);
     }
-  } else if (context.vectorStore) {
-    vectorHits = await executeVectorQuery(context.vectorStore, semanticVector, semanticLimit, vectorQueryOptions);
-  } else {
-    throw new PmCliError("Semantic search requires either a configured vector store or an extension vector adapter query handler", EXIT_CODE.USAGE);
   }
+  const queryVectors = await executeEmbeddingRequest(context.provider, expandedQueries, embeddingOptions);
+  const executeVectorQueryWithFallback = async (semanticVector) => {
+    if (context.extensionVectorAdapter?.query) {
+      try {
+        return await Promise.resolve(context.extensionVectorAdapter.query({
+          vector: semanticVector,
+          limit: semanticLimit,
+          settings: context.settings
+        }));
+      } catch (error) {
+        if (!context.vectorStore) {
+          throw new PmCliError(`Extension vector adapter query failed and no built-in fallback store is configured (${error instanceof Error ? error.message : String(error)})`, EXIT_CODE.GENERIC_FAILURE);
+        }
+        return await executeVectorQuery(context.vectorStore, semanticVector, semanticLimit, vectorQueryOptions);
+      }
+    }
+    if (context.vectorStore) {
+      return await executeVectorQuery(context.vectorStore, semanticVector, semanticLimit, vectorQueryOptions);
+    }
+    throw new PmCliError("Semantic search requires either a configured vector store or an extension vector adapter query handler", EXIT_CODE.USAGE);
+  };
+  const queryVectorGroups = await Promise.all(queryVectors.map(async (semanticVector) => await executeVectorQueryWithFallback(semanticVector)));
+  const vectorHits = mergeVectorHitsById(queryVectorGroups);
   const filteredById = new Map(context.filteredDocuments.map((document) => [document.metadata.id, document]));
   const { semanticHits, semanticScores } = buildSemanticHits(vectorHits, filteredById);
   const vectorMatchCount = semanticScores.size;
   if (context.requestedMode === "semantic") {
     return { hits: semanticHits, vectorMatchCount };
   }
+  let hybridHits = combineHybridHits(filteredById, semanticScores, context.keywordHits, context.hybridSemanticWeight);
+  if (context.rerank.enabled && hybridHits.length > 1) {
+    const sortedForCandidates = [...hybridHits].sort((left, right) => {
+      if (left.score !== right.score) {
+        return right.score - left.score;
+      }
+      return left.item.id.localeCompare(right.item.id);
+    });
+    const candidateHits = sortedForCandidates.slice(0, context.rerank.top_k);
+    const candidateContexts = candidateHits.map((hit) => {
+      const document = filteredById.get(hit.item.id);
+      if (!document) {
+        return null;
+      }
+      return { hit, text: buildRerankCorpus(document) };
+    }).filter((entry) => entry !== null);
+    const rerankCandidates = candidateContexts.map((entry) => ({
+      id: entry.hit.item.id,
+      text: entry.text
+    }));
+    let rerankScores = null;
+    if (context.rerankExtension?.rerank) {
+      try {
+        const rawRerank = await Promise.resolve(context.rerankExtension.rerank({
+          query: queryTrimmed,
+          mode: "hybrid",
+          model: context.rerank.model,
+          top_k: context.rerank.top_k,
+          settings: context.settings,
+          candidates: candidateContexts.map((entry) => ({
+            id: entry.hit.item.id,
+            text: entry.text,
+            score: entry.hit.score
+          }))
+        }));
+        const normalizedRerank = normalizeRerankOutput(rawRerank);
+        if (normalizedRerank.length > 0) {
+          rerankScores = new Map(normalizedRerank.map((entry) => [entry.id, entry.score]));
+        } else {
+          context.warnings.push(`search_rerank_provider_invalid_response:${context.rerankExtension.providerName}:using_builtin`);
+        }
+      } catch {
+        context.warnings.push(`search_rerank_provider_failed:${context.rerankExtension.providerName}:using_builtin`);
+      }
+    }
+    if (!rerankScores) {
+      try {
+        rerankScores = await rerankCandidatesWithEmbeddings(context.provider, context.rerank.model, queryTrimmed, rerankCandidates, context.embeddingTimeoutMs);
+      } catch {
+        context.warnings.push("search_rerank_failed:using_hybrid_scores");
+      }
+    }
+    if (rerankScores && rerankScores.size > 0) {
+      const rerankedIds = new Set(rerankScores.keys());
+      hybridHits = hybridHits.map((hit) => {
+        const rerankScore = rerankScores.get(hit.item.id);
+        if (rerankScore === void 0) {
+          return hit;
+        }
+        const matchedFields = new Set(hit.matched_fields);
+        matchedFields.add("rerank");
+        return {
+          ...hit,
+          score: rerankScore,
+          matched_fields: [...matchedFields].sort((left, right) => left.localeCompare(right))
+        };
+      });
+      hybridHits.sort((left, right) => {
+        const leftWasReranked = rerankedIds.has(left.item.id);
+        const rightWasReranked = rerankedIds.has(right.item.id);
+        if (leftWasReranked !== rightWasReranked) {
+          return leftWasReranked ? -1 : 1;
+        }
+        if (left.score !== right.score) {
+          return right.score - left.score;
+        }
+        return left.item.id.localeCompare(right.item.id);
+      });
+    }
+  }
   return {
-    hits: combineHybridHits(filteredById, semanticScores, context.keywordHits, context.hybridSemanticWeight),
+    hits: hybridHits,
     vectorMatchCount
   };
 }
@@ -979,18 +1405,29 @@ async function runSearch(query, options, global) {
   const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
   const maxResults = resolveSearchMaxResults(settings);
   const scoreThreshold = resolveSearchScoreThreshold(settings);
-  const hybridSemanticWeight = resolveHybridSemanticWeight(settings);
+  const semanticWeightProvided = options.semanticWeight !== void 0;
+  const semanticWeightOverride = parseSemanticWeightOverride(options.semanticWeight);
+  const hybridSemanticWeight = semanticWeightOverride ?? resolveHybridSemanticWeight(settings);
   const tuning = resolveSearchTuning(settings);
   const providerResolution = resolveEmbeddingProviders(settings);
   const vectorResolution = resolveVectorStores(settings);
   const extensionSearchProvider = resolveExtensionSearchProvider(settings);
   const extensionVectorAdapter = resolveExtensionVectorAdapter(settings);
+  const queryExpansion = resolveQueryExpansionConfig(settings, providerResolution.active?.name ?? null);
+  const rerank = resolveRerankConfig(settings, providerResolution.active?.model ?? toOptionalNonEmptyString(settings.search?.embedding_model) ?? "text-embedding-3-small");
+  const queryExpansionProvider = resolveExtensionSearchProviderByName(queryExpansion.provider ?? void 0);
+  const queryExpansionExtension = queryExpansionProvider?.queryExpansion ? { providerName: queryExpansionProvider.providerName, expand: queryExpansionProvider.queryExpansion } : null;
+  const rerankProvider = resolveExtensionSearchProviderByName(toOptionalNonEmptyString(settings.search?.provider));
+  const rerankExtension = rerankProvider?.rerank ? { providerName: rerankProvider.providerName, rerank: rerankProvider.rerank } : null;
   let effectiveMode = parseMode(options.mode, {
     hasProvider: providerResolution.active !== null || extensionSearchProvider !== null,
     hasVectorStore: vectorResolution.active !== null || extensionVectorAdapter !== null
   });
   const loadedDocuments = await loadDocuments(pmRoot, settings.item_format ?? "toon", typeRegistry.type_to_folder, settings.schema);
   const warnings = loadedDocuments.warnings;
+  if (effectiveMode === "hybrid" && semanticWeightProvided && semanticWeightOverride === void 0) {
+    warnings.push("search_hybrid_semantic_weight_override_invalid:using_settings_default");
+  }
   const allDocuments = loadedDocuments.documents;
   const metadataFilteredDocuments = applyFilters(allDocuments, options, typeRegistry, runtimeFieldFilters, statusFilter);
   const filteredDocuments = applyExactQueryFilters(metadataFilteredDocuments, normalizedQuery, {
@@ -998,7 +1435,7 @@ async function runSearch(query, options, global) {
     phraseExact
   });
   if (effectiveMode === "keyword" && (filteredDocuments.length === 0 || limit === 0)) {
-    return emptySearchResult(query, effectiveMode, options, includeLinked, scoreThreshold, hybridSemanticWeight, projection, warnings);
+    return emptySearchResult(query, effectiveMode, options, includeLinked, scoreThreshold, hybridSemanticWeight, queryExpansion, rerank, projection, warnings, runtimeFieldFilters);
   }
   const projectRoot = process.cwd();
   const globalRoot = resolveGlobalPmRoot(projectRoot);
@@ -1022,7 +1459,7 @@ async function runSearch(query, options, global) {
         requireSemanticDependencies(effectiveMode, providerResolution, vectorResolution, extensionVectorAdapter !== null);
       }
       if (filteredDocuments.length === 0 || limit === 0) {
-        return emptySearchResult(query, effectiveMode, options, includeLinked, scoreThreshold, hybridSemanticWeight, projection, warnings);
+        return emptySearchResult(query, effectiveMode, options, includeLinked, scoreThreshold, hybridSemanticWeight, queryExpansion, rerank, projection, warnings, runtimeFieldFilters);
       }
       const filteredById = new Map(filteredDocuments.map((document) => [document.metadata.id, document]));
       const canUseBuiltInSemantic = providerResolution.active !== null && (vectorResolution.active !== null || extensionVectorAdapter !== null);
@@ -1057,6 +1494,11 @@ async function runSearch(query, options, global) {
           provider,
           vectorStore,
           extensionVectorAdapter,
+          queryExpansion,
+          queryExpansionExtension,
+          rerank,
+          rerankExtension,
+          warnings,
           settings,
           ...implicitHybridMode ? {
             embeddingTimeoutMs: IMPLICIT_HYBRID_EMBEDDING_TIMEOUT_MS,
@@ -1084,6 +1526,27 @@ async function runSearch(query, options, global) {
   const limited = resolvedLimit === void 0 ? sorted : sorted.slice(0, resolvedLimit);
   const projectedItems = projectSearchHits(limited, projection);
   const projectionFields = projection.mode === "full" ? null : [...projection.fields];
+  const compactSummaryMode = projection.mode === "compact" && options.compact === true;
+  if (compactSummaryMode) {
+    const compactFilters = buildCompactSearchFilterSummary({
+      mode: effectiveMode,
+      options,
+      includeLinked,
+      titleExact,
+      phraseExact,
+      scoreThreshold,
+      hybridSemanticWeight,
+      runtimeFieldFilters
+    });
+    return {
+      query: query.trim(),
+      mode: effectiveMode,
+      items: projectedItems,
+      count: projectedItems.length,
+      filters: compactFilters,
+      ...warnings.length > 0 ? { warnings } : {}
+    };
+  }
   return {
     query: query.trim(),
     mode: effectiveMode,
@@ -1102,6 +1565,11 @@ async function runSearch(query, options, global) {
       phrase_exact: phraseExact,
       score_threshold: scoreThreshold,
       hybrid_semantic_weight: effectiveMode === "hybrid" ? hybridSemanticWeight : null,
+      query_expansion_enabled: queryExpansion.enabled,
+      query_expansion_provider: queryExpansion.provider,
+      rerank_enabled: rerank.enabled,
+      rerank_model: rerank.model,
+      rerank_top_k: rerank.top_k,
       limit: options.limit ?? null,
       runtime_filters: runtimeFieldFilters
     },
@@ -1122,6 +1590,6 @@ export {
   resolveSearchTuning,
   runSearch
 };
-//# sourceMappingURL=search-JPUQTVCY.js.map
+//# sourceMappingURL=search-EQDHSE4G.js.map
 
-//# debugId=b58cad50-da5e-5276-b71a-3499854f773b
+//# debugId=1eb1787d-185d-5d6c-9933-0f8e2635576f