@unbrained/pm-cli 2026.6.13 → 2026.6.17

package/dist/cli-bundle/chunks/{search-BJ457C2A.js → search-OXLSQKHP.js}

@@ -11,36 +11,47 @@ import {
   resolveEmbeddingProviders,
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores
-} from "./chunk-PEH7SZD2.js";
+} from "./chunk-YLAW3FZN.js";
 import {
+  buildContentFilterEcho,
+  buildGovernanceMissingFilterEcho,
   collectRuntimeFilterValues,
   matchesRuntimeFilters,
-  parseStatusFilterCsv
-} from "./chunk-C24PWDFG.js";
+  parseStatusFilterCsv,
+  resolveContentFieldFilters,
+  resolveMissingMetadataFilters
+} from "./chunk-6PBPD4MN.js";
+import {
+  hasContentFieldFilter,
+  hasMissingMetadataFilter,
+  itemMatchesContentFilters,
+  itemMatchesMissingMetadata,
+  lifecycleClassifierFromStatusRegistry
+} from "./chunk-3GR2HTYY.js";
 import {
   parseLimit,
   parsePriority,
   parseType
-} from "./chunk-VYZNX4C5.js";
+} from "./chunk-COVLE33A.js";
 import {
   collectRegisteredItemFieldNames,
   listAllDocumentCandidatesCached,
   listAllFrontMatter,
   toItemRecord
-} from "./chunk-XXLMJDUB.js";
-import "./chunk-LGOXXQUW.js";
+} from "./chunk-KA22USXD.js";
+import "./chunk-5XGWFUW2.js";
 import {
   isTerminalStatus,
   parseItemDocument
-} from "./chunk-MACCNKSZ.js";
+} from "./chunk-TBV33CB4.js";
 import {
   resolveItemTypeRegistry
-} from "./chunk-W6KNFAMZ.js";
+} from "./chunk-QXMXRPX5.js";
 import {
   compareTimestampStrings,
   nowIso,
   resolveIsoOrRelative
-} from "./chunk-IXVSSHGV.js";
+} from "./chunk-LNH5Q32E.js";
 import {
   EXIT_CODE,
   PmCliError,
@@ -59,7 +70,7 @@ import {
   runActiveOnReadHooks,
   toNonEmptyString,
   toNonEmptyStringOrUndefined
-} from "./chunk-LFW5NQUP.js";
+} from "./chunk-CHM2VFVL.js";
 
 // dist/cli/commands/search.js
 import fs from "node:fs/promises";
@@ -107,7 +118,7 @@ function resolveRegisteredVectorStoreAdapter(registrations, configuredAdapter) {
 !(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] = "1109b938-c421-5517-9671-2cebd7e10309");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "f232eaee-3735-55a2-a605-5ea434b4092b");
   } catch (e2) {
   }
 })();
@@ -328,7 +339,7 @@ async function rerankCandidatesWithEmbeddings(provider, model, query, candidates
 !(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] = "11e9f6b5-58d0-5f17-a9c5-6d34b5ce4379");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "159f3fa3-02f9-5744-91bd-7d6b0f550537");
   } catch (e2) {
   }
 })();
@@ -402,13 +413,14 @@ var SEARCH_ITEM_FIELD_KEYS = /* @__PURE__ */ new Set([
 var LONG_QUERY_TOKEN_THRESHOLD = 2;
 var LONG_QUERY_TITLE_EXACT_BONUS = 120;
 var LONG_QUERY_PHRASE_MULTIPLIER = 6;
+var ALL_TERMS_COVERAGE_BONUS = 40;
 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 { mode, matchMode, options, includeLinked, titleExact, phraseExact, scoreThreshold, hybridSemanticWeight, runtimeFieldFilters } = params;
   const filters = {};
   if (options.status !== void 0) {
     filters.status = options.status;
@@ -428,6 +440,35 @@ function buildCompactSearchFilterSummary(params) {
   if (options.deadlineAfter !== void 0) {
     filters.deadline_after = options.deadlineAfter;
   }
+  if (options.updatedAfter !== void 0) {
+    filters.updated_after = options.updatedAfter;
+  }
+  if (options.updatedBefore !== void 0) {
+    filters.updated_before = options.updatedBefore;
+  }
+  if (options.createdAfter !== void 0) {
+    filters.created_after = options.createdAfter;
+  }
+  if (options.createdBefore !== void 0) {
+    filters.created_before = options.createdBefore;
+  }
+  if (options.assignee !== void 0) {
+    filters.assignee = options.assignee;
+  }
+  if (options.sprint !== void 0) {
+    filters.sprint = options.sprint;
+  }
+  if (options.release !== void 0) {
+    filters.release = options.release;
+  }
+  if (options.parent !== void 0) {
+    filters.parent = options.parent;
+  }
+  Object.assign(filters, buildGovernanceMissingFilterEcho(options));
+  Object.assign(filters, buildContentFilterEcho(options));
+  if (matchMode !== "or") {
+    filters.match_mode = matchMode;
+  }
   if (includeLinked) {
     filters.include_linked = true;
   }
@@ -451,6 +492,41 @@ function buildCompactSearchFilterSummary(params) {
   }
   return filters;
 }
+function buildVerboseSearchFilters(params) {
+  const { effectiveMode, matchMode, options, includeLinked, titleExact, phraseExact, scoreThreshold, hybridSemanticWeight, queryExpansion, rerank, runtimeFieldFilters } = params;
+  return {
+    mode: effectiveMode,
+    match_mode: matchMode,
+    status: options.status ?? null,
+    type: options.type ?? null,
+    tag: options.tag ?? null,
+    priority: options.priority ?? null,
+    deadline_before: options.deadlineBefore ?? null,
+    deadline_after: options.deadlineAfter ?? null,
+    updated_after: options.updatedAfter ?? null,
+    updated_before: options.updatedBefore ?? null,
+    created_after: options.createdAfter ?? null,
+    created_before: options.createdBefore ?? null,
+    assignee: options.assignee ?? null,
+    sprint: options.sprint ?? null,
+    release: options.release ?? null,
+    parent: options.parent ?? null,
+    ...buildGovernanceMissingFilterEcho(options),
+    ...buildContentFilterEcho(options),
+    include_linked: includeLinked,
+    title_exact: titleExact,
+    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
+  };
+}
 function collectErrorCauseCodes(error) {
   const codes = [];
   let current = error;
@@ -530,6 +606,34 @@ function parsePhraseExact(raw) {
 function parseSemanticWeightOverride(raw) {
   return coerceNumberInRange(raw, 0, 1) ?? void 0;
 }
+function parseMatchMode(raw) {
+  if (raw === void 0) {
+    return "or";
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (normalized !== "and" && normalized !== "or" && normalized !== "exact") {
+    throw new PmCliError("Search --match-mode must be one of and|or|exact", EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function parseMinScoreOverride(raw) {
+  if (raw === void 0 || raw === null || raw === "") {
+    return void 0;
+  }
+  const parsed = typeof raw === "number" ? raw : Number(String(raw).trim());
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new PmCliError("Search --min-score must be a finite number >= 0", EXIT_CODE.USAGE);
+  }
+  return parsed;
+}
+function parseTimestampWindow(raw, fieldLabel) {
+  if (raw == null)
+    return void 0;
+  const value = String(raw).trim();
+  if (value.length === 0)
+    return void 0;
+  return resolveIsoOrRelative(value, /* @__PURE__ */ new Date(), fieldLabel);
+}
 function normalizeSearchPhrase(value) {
   return value.toLowerCase().replace(/\s+/g, " ").trim();
 }
@@ -579,6 +683,47 @@ function parseProjectionConfig(options) {
     fields: []
   };
 }
+var _testOnlySearchCommand = {
+  applyFilters,
+  applyExactQueryFilters,
+  buildVerboseSearchFilters,
+  buildExplicitSemanticFallbackWarning,
+  buildCompactSearchFilterSummary,
+  buildHybridLexicalScore,
+  buildImplicitSemanticFallbackWarning,
+  buildRerankCorpus,
+  buildSemanticHits,
+  classifyImplicitSemanticFallbackReason,
+  collectErrorCauseCodes,
+  collectExactPhraseFields,
+  collectLinkedPaths,
+  combineHybridHits,
+  computeSemanticOrHybridHits,
+  countOccurrences,
+  dependencyEntries,
+  documentContainsExactPhrase,
+  emptySearchResult,
+  loadDocuments,
+  maybeEmitVectorIndexStaleWarning,
+  loadLinkedCorpus,
+  mergeVectorHitsById,
+  normalizeExtensionProviderHits,
+  normalizeScoreMap,
+  parseProjectionConfig,
+  parseTimestampWindow,
+  parseTokens,
+  readSearchFieldValue,
+  requireSemanticDependencies,
+  resolveExtensionSearchProvider,
+  resolveExtensionSearchProviderByName,
+  resolveExtensionVectorAdapter,
+  resolveLinkedCorpusRoots,
+  scoreDocument,
+  sortHits,
+  stringArray,
+  textEntries,
+  validateSearchProjectionFields
+};
 function validateSearchProjectionFields(projection, runtimeFieldRegistry) {
   if (projection.mode !== "fields") {
     return;
@@ -649,13 +794,28 @@ function applyExactQueryFilters(items, normalizedQuery, options) {
     return true;
   });
 }
-function applyFilters(items, options, typeRegistry, runtimeFieldFilters, statusFilter) {
+function applyFilters(items, options, typeRegistry, runtimeFieldFilters, statusFilter, lifecycleClassifier) {
   const typeFilter = parseType(options.type, typeRegistry);
   const tagFilter = options.tag?.trim().toLowerCase();
   const priorityFilter = parsePriority(options.priority);
   const deadlineBefore = parseDeadline(options.deadlineBefore, "deadline-before");
   const deadlineAfter = parseDeadline(options.deadlineAfter, "deadline-after");
+  const updatedAfter = parseTimestampWindow(options.updatedAfter, "updated-after");
+  const updatedBefore = parseTimestampWindow(options.updatedBefore, "updated-before");
+  const createdAfter = parseTimestampWindow(options.createdAfter, "created-after");
+  const createdBefore = parseTimestampWindow(options.createdBefore, "created-before");
+  const assigneeFilter = options.assignee?.trim();
+  const sprintFilter = options.sprint?.trim();
+  const releaseFilter = options.release?.trim();
+  const parentFilter = options.parent?.trim();
   const statusSet = statusFilter && statusFilter.length > 0 ? new Set(statusFilter) : void 0;
+  const missingMetadataFilters = resolveMissingMetadataFilters(options);
+  const missingMetadataActive = hasMissingMetadataFilter(missingMetadataFilters);
+  const contentFieldFilters = resolveContentFieldFilters(options);
+  const contentFiltersActive = hasContentFieldFilter(contentFieldFilters);
+  if (assigneeFilter && (assigneeFilter.toLowerCase() === "none" || assigneeFilter.toLowerCase() === "null")) {
+    throw new PmCliError('--assignee no longer accepts "none" or "null".', EXIT_CODE.USAGE);
+  }
   return items.filter((document) => {
     const item = document.metadata;
     if (statusSet && !statusSet.has(item.status))
@@ -670,8 +830,30 @@ function applyFilters(items, options, typeRegistry, runtimeFieldFilters, statusF
       return false;
     if (deadlineAfter && (!item.deadline || compareTimestampStrings(item.deadline, deadlineAfter) < 0))
       return false;
+    if (updatedAfter && compareTimestampStrings(item.updated_at, updatedAfter) < 0)
+      return false;
+    if (updatedBefore && compareTimestampStrings(item.updated_at, updatedBefore) > 0)
+      return false;
+    if (createdAfter && compareTimestampStrings(item.created_at, createdAfter) < 0)
+      return false;
+    if (createdBefore && compareTimestampStrings(item.created_at, createdBefore) > 0)
+      return false;
+    if (assigneeFilter !== void 0 && item.assignee !== assigneeFilter)
+      return false;
+    if (sprintFilter !== void 0 && item.sprint !== sprintFilter)
+      return false;
+    if (releaseFilter !== void 0 && item.release !== releaseFilter)
+      return false;
+    if (parentFilter !== void 0 && item.parent !== parentFilter)
+      return false;
     if (!matchesRuntimeFilters(item, runtimeFieldFilters))
       return false;
+    if (missingMetadataActive && !itemMatchesMissingMetadata(item, missingMetadataFilters, lifecycleClassifier)) {
+      return false;
+    }
+    if (contentFiltersActive && !itemMatchesContentFilters(item, contentFieldFilters)) {
+      return false;
+    }
     return true;
   });
 }
@@ -764,7 +946,7 @@ async function loadLinkedCorpus(document, roots) {
   }
   return chunks.join("\n");
 }
-function scoreDocument(document, tokens, normalizedQuery, linkedCorpus, tuning) {
+function scoreDocument(document, tokens, normalizedQuery, linkedCorpus, tuning, applyCoverageBonus = false) {
   const item = document.metadata;
   const titleTokenCounts = /* @__PURE__ */ new Map();
   for (const token of tokenizeForExactTokenMatch(item.title)) {
@@ -791,11 +973,13 @@ function scoreDocument(document, tokens, normalizedQuery, linkedCorpus, tuning)
   ];
   let score = 0;
   const matched = /* @__PURE__ */ new Set();
+  const matchedTokens = /* @__PURE__ */ new Set();
   for (const token of tokens) {
     const exactTitleMatches = titleTokenCounts.get(token) ?? 0;
     if (exactTitleMatches > 0) {
       score += exactTitleMatches * tuning.title_exact_bonus;
       matched.add("title");
+      matchedTokens.add(token);
     }
     for (const field of searchableFields) {
       const fieldValue = field.value.toLowerCase();
@@ -803,9 +987,15 @@ function scoreDocument(document, tokens, normalizedQuery, linkedCorpus, tuning)
       if (occurrences > 0) {
         score += occurrences * field.weight;
         matched.add(field.name);
+        matchedTokens.add(token);
       }
     }
   }
+  const distinctTokens = new Set(tokens);
+  const matchedAllTerms = distinctTokens.size > 0 && matchedTokens.size === distinctTokens.size;
+  if (applyCoverageBonus && distinctTokens.size > 1 && matchedAllTerms) {
+    score += ALL_TERMS_COVERAGE_BONUS;
+  }
   const isLongPhraseQuery = tokens.length >= LONG_QUERY_TOKEN_THRESHOLD && normalizedQuery.includes(" ");
   if (isLongPhraseQuery) {
     const normalizedTitle = normalizeSearchPhrase(item.title);
@@ -828,7 +1018,8 @@ function scoreDocument(document, tokens, normalizedQuery, linkedCorpus, tuning)
   return {
     item,
     score,
-    matched_fields: [...matched].sort((a, b) => a.localeCompare(b))
+    matched_fields: [...matched].sort((a, b) => a.localeCompare(b)),
+    matched_all_terms: matchedAllTerms
   };
 }
 function sortHits(items, statusRegistry) {
@@ -850,8 +1041,8 @@ function sortHits(items, statusRegistry) {
     return a.item.id.localeCompare(b.item.id);
   });
 }
-function buildHybridLexicalScore(document, tokens, normalizedQuery, includeLinked, linkedCorpusById, tuning) {
-  return scoreDocument(document, tokens, normalizedQuery, includeLinked ? linkedCorpusById.get(document.metadata.id) ?? "" : "", tuning);
+function buildHybridLexicalScore(document, tokens, normalizedQuery, includeLinked, linkedCorpusById, tuning, applyCoverageBonus = false) {
+  return scoreDocument(document, tokens, normalizedQuery, includeLinked ? linkedCorpusById.get(document.metadata.id) ?? "" : "", tuning, applyCoverageBonus);
 }
 function normalizeScoreMap(scoreById) {
   if (scoreById.size === 0) {
@@ -931,11 +1122,13 @@ function resolveSearchTuning(settings) {
     linked_content_weight: resolveWeight(tuning.linked_content_weight, defaults.linked_content_weight)
   };
 }
-function emptySearchResult(query, mode, options, includeLinked, scoreThreshold, hybridSemanticWeight, queryExpansion, rerank, projection, warnings, runtimeFieldFilters) {
+function emptySearchResult(query, mode, matchMode, options, includeLinked, scoreThreshold, hybridSemanticWeight, queryExpansion, rerank, projection, warnings, runtimeFieldFilters, countOnly = false) {
+  const countExtras = countOnly ? { total: 0, count_only: true } : {};
   const compactSummaryMode = projection.mode === "compact" && options.compact === true;
   if (compactSummaryMode) {
     const compactFilters = buildCompactSearchFilterSummary({
       mode,
+      matchMode,
       options,
       includeLinked,
       titleExact: options.titleExact === true,
@@ -949,6 +1142,7 @@ function emptySearchResult(query, mode, options, includeLinked, scoreThreshold,
       mode,
       items: [],
       count: 0,
+      ...countExtras,
       filters: compactFilters,
       ...warnings.length > 0 ? { warnings } : {}
     };
@@ -959,26 +1153,20 @@ function emptySearchResult(query, mode, options, includeLinked, scoreThreshold,
     mode,
     items: [],
     count: 0,
-    filters: {
-      mode,
-      status: options.status ?? null,
-      type: options.type ?? null,
-      tag: options.tag ?? null,
-      priority: options.priority ?? null,
-      deadline_before: options.deadlineBefore ?? null,
-      deadline_after: options.deadlineAfter ?? null,
-      include_linked: includeLinked,
-      title_exact: options.titleExact === true,
-      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
-    },
+    ...countExtras,
+    filters: buildVerboseSearchFilters({
+      effectiveMode: mode,
+      matchMode,
+      options,
+      includeLinked,
+      titleExact: options.titleExact === true,
+      phraseExact: options.phraseExact === true,
+      scoreThreshold,
+      hybridSemanticWeight,
+      queryExpansion,
+      rerank,
+      runtimeFieldFilters: runtimeFieldFilters ?? {}
+    }),
     projection: {
       mode: projection.mode,
       fields: projectionFields
@@ -1396,7 +1584,7 @@ function readSearchFieldValue(hit, field) {
 }
 function projectSearchHits(hits, projection) {
   if (projection.mode === "full") {
-    return hits;
+    return hits.map(({ matched_all_terms: _matchedAllTerms, ...hit }) => hit);
   }
   return hits.map((hit) => {
     const projected = {};
@@ -1410,6 +1598,9 @@ async function runSearch(query, options, global2) {
   const includeLinked = parseIncludeLinked(options.includeLinked);
   const titleExact = parseTitleExact(options.titleExact);
   const phraseExact = parsePhraseExact(options.phraseExact);
+  const matchMode = parseMatchMode(typeof options.matchMode === "string" ? options.matchMode : void 0);
+  const minScoreOverride = parseMinScoreOverride(options.minScore);
+  const countOnly = options.count === true;
   const tokens = parseTokens(query);
   const normalizedQuery = normalizeSearchPhrase(query);
   const limit = parseLimit(options.limit);
@@ -1429,7 +1620,7 @@ async function runSearch(query, options, global2) {
   const statusFilter = parseStatusFilterCsv(typeof options.status === "string" ? options.status : void 0, statusRegistry, { strict: true });
   const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
   const maxResults = resolveSearchMaxResults(settings);
-  const scoreThreshold = resolveSearchScoreThreshold(settings);
+  const scoreThreshold = minScoreOverride ?? resolveSearchScoreThreshold(settings);
   const semanticWeightProvided = options.semanticWeight !== void 0;
   const semanticWeightOverride = parseSemanticWeightOverride(options.semanticWeight);
   const hybridSemanticWeight = semanticWeightOverride ?? resolveHybridSemanticWeight(settings);
@@ -1454,13 +1645,16 @@ async function runSearch(query, options, global2) {
     warnings.push("search_hybrid_semantic_weight_override_invalid:using_settings_default");
   }
   const allDocuments = loadedDocuments.documents;
-  const metadataFilteredDocuments = applyFilters(allDocuments, options, typeRegistry, runtimeFieldFilters, statusFilter);
+  const lifecycleClassifier = lifecycleClassifierFromStatusRegistry(statusRegistry);
+  const metadataFilteredDocuments = applyFilters(allDocuments, options, typeRegistry, runtimeFieldFilters, statusFilter, lifecycleClassifier);
   const filteredDocuments = applyExactQueryFilters(metadataFilteredDocuments, normalizedQuery, {
     titleExact,
-    phraseExact
+    // --match-mode exact reuses the exact-phrase containment logic so the whole
+    // normalized query must appear as a contiguous phrase in some searchable field.
+    phraseExact: phraseExact || matchMode === "exact"
   });
   if (effectiveMode === "keyword" && (filteredDocuments.length === 0 || limit === 0)) {
-    return emptySearchResult(query, effectiveMode, options, includeLinked, scoreThreshold, hybridSemanticWeight, queryExpansion, rerank, projection, warnings, runtimeFieldFilters);
+    return emptySearchResult(query, effectiveMode, matchMode, options, includeLinked, scoreThreshold, hybridSemanticWeight, queryExpansion, rerank, projection, warnings, runtimeFieldFilters, countOnly);
   }
   const projectRoot = process.cwd();
   const globalRoot = resolveGlobalPmRoot(projectRoot);
@@ -1472,7 +1666,19 @@ async function runSearch(query, options, global2) {
       linkedCorpusById.set(id, corpus);
     }
   }
-  const keywordHits = filteredDocuments.map((document) => buildHybridLexicalScore(document, tokens, normalizedQuery, effectiveMode !== "semantic", linkedCorpusById, tuning)).filter((entry) => entry !== null);
+  const applyCoverageBonus = matchMode === "or";
+  const keywordHits = filteredDocuments.map((document) => buildHybridLexicalScore(
+    document,
+    tokens,
+    normalizedQuery,
+    // Linked corpus is only collected into linkedCorpusById when the user
+    // passed --include-linked (and mode is keyword/hybrid), so pass the
+    // parsed flag directly rather than re-deriving it from the mode.
+    includeLinked,
+    linkedCorpusById,
+    tuning,
+    applyCoverageBonus
+  )).filter((entry) => entry !== null).filter((entry) => matchMode !== "and" || entry.matched_all_terms === true);
   let hits = keywordHits;
   if (effectiveMode !== "keyword") {
     const builtInSemanticWillRun = !extensionSearchProvider && providerResolution.active !== null && (vectorResolution.active !== null || extensionVectorAdapter !== null);
@@ -1484,7 +1690,7 @@ async function runSearch(query, options, global2) {
         requireSemanticDependencies(effectiveMode, providerResolution, vectorResolution, extensionVectorAdapter !== null);
       }
       if (filteredDocuments.length === 0 || limit === 0) {
-        return emptySearchResult(query, effectiveMode, options, includeLinked, scoreThreshold, hybridSemanticWeight, queryExpansion, rerank, projection, warnings, runtimeFieldFilters);
+        return emptySearchResult(query, effectiveMode, matchMode, options, includeLinked, scoreThreshold, hybridSemanticWeight, queryExpansion, rerank, projection, warnings, runtimeFieldFilters, countOnly);
       }
       const filteredById = new Map(filteredDocuments.map((document) => [document.metadata.id, document]));
       const canUseBuiltInSemantic = providerResolution.active !== null && (vectorResolution.active !== null || extensionVectorAdapter !== null);
@@ -1525,6 +1731,7 @@ async function runSearch(query, options, global2) {
           rerankExtension,
           warnings,
           settings,
+          /* c8 ignore next 5 -- reserved for future implicit-hybrid auto-mode; current parseMode defaults keyword when mode is omitted */
           ...implicitHybridMode ? {
             embeddingTimeoutMs: IMPLICIT_HYBRID_EMBEDDING_TIMEOUT_MS,
             vectorQueryTimeoutMs: IMPLICIT_HYBRID_VECTOR_TIMEOUT_MS
@@ -1547,14 +1754,69 @@ async function runSearch(query, options, global2) {
   }
   const thresholded = hits.filter((entry) => entry.score >= scoreThreshold);
   const sorted = sortHits(thresholded, statusRegistry);
-  const resolvedLimit = effectiveMode === "keyword" ? limit : limit ?? maxResults;
-  const limited = resolvedLimit === void 0 ? sorted : sorted.slice(0, resolvedLimit);
-  const projectedItems = projectSearchHits(limited, projection);
+  const total = sorted.length;
+  const resolvedLimit = limit ?? maxResults;
+  const limited = sorted.slice(0, resolvedLimit);
   const projectionFields = projection.mode === "full" ? null : [...projection.fields];
   const compactSummaryMode = projection.mode === "compact" && options.compact === true;
+  if (countOnly) {
+    if (compactSummaryMode) {
+      const compactFilters = buildCompactSearchFilterSummary({
+        mode: effectiveMode,
+        matchMode,
+        options,
+        includeLinked,
+        titleExact,
+        phraseExact,
+        scoreThreshold,
+        hybridSemanticWeight,
+        runtimeFieldFilters
+      });
+      return {
+        query: query.trim(),
+        mode: effectiveMode,
+        items: [],
+        count: total,
+        total,
+        count_only: true,
+        filters: compactFilters,
+        ...warnings.length > 0 ? { warnings } : {}
+      };
+    }
+    return {
+      query: query.trim(),
+      mode: effectiveMode,
+      items: [],
+      count: total,
+      total,
+      count_only: true,
+      filters: buildVerboseSearchFilters({
+        effectiveMode,
+        matchMode,
+        options,
+        includeLinked,
+        titleExact,
+        phraseExact,
+        scoreThreshold,
+        hybridSemanticWeight,
+        queryExpansion,
+        rerank,
+        runtimeFieldFilters
+      }),
+      projection: {
+        mode: projection.mode,
+        fields: projectionFields
+      },
+      now: nowIso(),
+      ...warnings.length > 0 ? { warnings } : {}
+    };
+  }
+  const projectedItems = projectSearchHits(limited, projection);
+  const truncationExtras = limited.length < total ? { total } : {};
   if (compactSummaryMode) {
     const compactFilters = buildCompactSearchFilterSummary({
       mode: effectiveMode,
+      matchMode,
       options,
       includeLinked,
       titleExact,
@@ -1568,6 +1830,7 @@ async function runSearch(query, options, global2) {
       mode: effectiveMode,
       items: projectedItems,
       count: projectedItems.length,
+      ...truncationExtras,
       filters: compactFilters,
       ...warnings.length > 0 ? { warnings } : {}
     };
@@ -1577,27 +1840,20 @@ async function runSearch(query, options, global2) {
     mode: effectiveMode,
     items: projectedItems,
     count: projectedItems.length,
-    filters: {
-      mode: effectiveMode,
-      status: options.status ?? null,
-      type: options.type ?? null,
-      tag: options.tag ?? null,
-      priority: options.priority ?? null,
-      deadline_before: options.deadlineBefore ?? null,
-      deadline_after: options.deadlineAfter ?? null,
-      include_linked: includeLinked,
-      title_exact: titleExact,
-      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
-    },
+    ...truncationExtras,
+    filters: buildVerboseSearchFilters({
+      effectiveMode,
+      matchMode,
+      options,
+      includeLinked,
+      titleExact,
+      phraseExact,
+      scoreThreshold,
+      hybridSemanticWeight,
+      queryExpansion,
+      rerank,
+      runtimeFieldFilters
+    }),
     projection: {
       mode: projection.mode,
       fields: projectionFields
@@ -1607,6 +1863,7 @@ async function runSearch(query, options, global2) {
   };
 }
 export {
+  _testOnlySearchCommand,
   classifyImplicitSemanticFallbackReason,
   collectErrorCauseCodes,
   resolveHybridSemanticWeight,
@@ -1615,4 +1872,4 @@ export {
   resolveSearchTuning,
   runSearch
 };
-//# sourceMappingURL=search-BJ457C2A.js.map
+//# sourceMappingURL=search-OXLSQKHP.js.map