@unbrained/pm-cli 2026.6.19 → 2026.6.20

package/dist/cli-bundle/chunks/{chunk-ZZEM2PH7.js → chunk-26OQTCGH.js}

@@ -1,21 +1,21 @@
 
-!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]="0e7c6d8d-dad6-54ca-ae84-247fada10287")}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]="7919579f-9834-5809-8c55-f7618807569e")}catch(e){}}();
 import {
   verifyHistoryChain
-} from "./chunk-FP7YLQ52.js";
+} from "./chunk-WMQBNVZL.js";
 import {
   hashDocument
-} from "./chunk-GL3QKIET.js";
+} from "./chunk-XKJDCJEH.js";
 import {
   getHistoryPath,
   writeFileAtomic
-} from "./chunk-I2VJM36R.js";
+} from "./chunk-AZ75OVK4.js";
 
 // dist/core/history/drift-scan.js
 import fs from "fs/promises";
 import { createHash } from "node:crypto";
 import path from "node:path";
-var DRIFT_CACHE_VERSION = 2;
+var DRIFT_CACHE_VERSION = 3;
 var DRIFT_CACHE_FILENAME = "history-drift-cache.json";
 function getDriftCachePath(pmRoot) {
   return path.join(pmRoot, "runtime", DRIFT_CACHE_FILENAME);
@@ -71,7 +71,7 @@ async function verifyHistoryStream(historyPath) {
     contentHash
   };
 }
-async function scanHistoryDrift(pmRoot, items) {
+async function scanHistoryDrift(pmRoot, items, options = {}) {
   const missingStreams = [];
   const unreadableStreams = [];
   const hashMismatches = [];
@@ -80,6 +80,7 @@ async function scanHistoryDrift(pmRoot, items) {
   const previousEntries = cache?.entries ?? {};
   const nextEntries = {};
   let cacheDirty = false;
+  const verifyCacheHitByContent = options.cacheHitVerification !== "metadata";
   for (const item of items) {
     const historyPath = getHistoryPath(pmRoot, item.id);
     let stat;
@@ -119,13 +120,17 @@ async function scanHistoryDrift(pmRoot, items) {
     const canUseCache = metadataMatchesCache && cachedContentHash !== void 0;
     if (canUseCache && cached) {
       let currentContentHash;
-      try {
-        currentContentHash = await readHistoryContentHash(historyPath);
-      } catch {
-        unreadableStreams.push(item.id);
-        continue;
+      if (verifyCacheHitByContent) {
+        try {
+          currentContentHash = await readHistoryContentHash(historyPath);
+        } catch {
+          unreadableStreams.push(item.id);
+          continue;
+        }
+      } else {
+        currentContentHash = cachedContentHash;
       }
-      if (currentContentHash === cachedContentHash) {
+      if (!verifyCacheHitByContent || currentContentHash === cachedContentHash) {
         verification = {
           latestAfterHash: cached.latest_after_hash,
           chainOk: cached.chain_ok,
@@ -182,6 +187,6 @@ async function scanHistoryDrift(pmRoot, items) {
 export {
   scanHistoryDrift
 };
-//# sourceMappingURL=chunk-ZZEM2PH7.js.map
+//# sourceMappingURL=chunk-26OQTCGH.js.map
 
-//# debugId=0e7c6d8d-dad6-54ca-ae84-247fada10287
+//# debugId=7919579f-9834-5809-8c55-f7618807569e

package/dist/cli-bundle/chunks/chunk-26OQTCGH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../core/history/drift-scan.ts"],"sourcesContent":["/**\n * @module core/history/drift-scan\n *\n * Implements append-only history and replay behavior for Drift Scan.\n */\nimport fs from \"fs/promises\";\nimport { createHash } from \"node:crypto\";\nimport path from \"node:path\";\nimport { getHistoryPath } from \"../store/paths.js\";\nimport { writeFileAtomic } from \"../fs/fs-utils.js\";\nimport { hashDocument } from \"./history.js\";\nimport { verifyHistoryChain } from \"./replay.js\";\nimport type { HistoryEntry, ItemMetadata } from \"../../types/index.js\";\n\n/**\n * Documents the drift scan result payload exchanged by command, SDK, and package integrations.\n */\nexport interface DriftScanResult {\n  missingStreams: string[];\n  unreadableStreams: string[];\n  hashMismatches: string[];\n  chainMismatches: string[];\n  driftedItems: string[];\n}\n\nconst DRIFT_CACHE_VERSION = 3;\nconst DRIFT_CACHE_FILENAME = \"history-drift-cache.json\";\n\n/**\n * Controls how cached history stream verification is trusted when the file stat\n * tuple still matches a previous scan.\n */\nexport type DriftCacheHitVerification = \"content_hash\" | \"metadata\";\n\n/**\n * Documents the history drift scan options shared by health, validate, and\n * repair callers.\n */\nexport interface DriftScanOptions {\n  cacheHitVerification?: DriftCacheHitVerification;\n}\n\ninterface DriftCacheEntry {\n  mtime_ms: number;\n  ctime_ms: number;\n  size: number;\n  content_hash: string;\n  latest_after_hash: string;\n  chain_ok: boolean;\n}\n\ninterface DriftCacheEnvelope {\n  version: number;\n  entries: Record<string, DriftCacheEntry>;\n}\n\nfunction getDriftCachePath(pmRoot: string): string {\n  return path.join(pmRoot, \"runtime\", DRIFT_CACHE_FILENAME);\n}\n\nasync function loadDriftCache(pmRoot: string): Promise<DriftCacheEnvelope | null> {\n  try {\n    const raw = await fs.readFile(getDriftCachePath(pmRoot), \"utf8\");\n    const parsed = JSON.parse(raw) as DriftCacheEnvelope;\n    if (parsed.version !== DRIFT_CACHE_VERSION || typeof parsed.entries !== \"object\" || parsed.entries === null) {\n      return null;\n    }\n    return parsed;\n  } catch {\n    return null;\n  }\n}\n\nfunction isErrno(error: unknown, code: string): boolean {\n  return typeof error === \"object\" && error !== null && \"code\" in error && (error as { code?: string }).code === code;\n}\n\ninterface StreamVerification {\n  latestAfterHash: string;\n  chainOk: boolean;\n  contentHash: string;\n}\n\nfunction hashContent(raw: string): string {\n  return createHash(\"sha256\").update(raw).digest(\"hex\");\n}\n\nasync function readHistoryContentHash(historyPath: string): Promise<string> {\n  const raw = await fs.readFile(historyPath, \"utf8\");\n  return hashContent(raw);\n}\n\n/**\n * Read and fully verify one history stream's hash chain. Returns null for an\n * empty/missing stream (caller records it as a missing stream).\n */\nasync function verifyHistoryStream(historyPath: string): Promise<StreamVerification | null> {\n  const raw = await fs.readFile(historyPath, \"utf8\");\n  const contentHash = hashContent(raw);\n  if (raw.trim().length === 0) {\n    return null;\n  }\n  const entries: HistoryEntry[] = [];\n  let latestAfterHash: string | null = null;\n  for (const line of raw.split(/\\r?\\n/)) {\n    const trimmed = line.trim();\n    if (trimmed.length === 0) {\n      continue;\n    }\n    const parsed = JSON.parse(trimmed) as HistoryEntry;\n    if (typeof parsed.after_hash !== \"string\" || parsed.after_hash.trim().length === 0) {\n      throw new Error(\"missing after_hash\");\n    }\n    entries.push(parsed);\n    latestAfterHash = parsed.after_hash;\n  }\n  /* c8 ignore start -- defensive guard for future history schema changes. */\n  if (!latestAfterHash) {\n    return null;\n  }\n  /* c8 ignore stop */\n  return {\n    latestAfterHash,\n    chainOk: verifyHistoryChain(entries).ok,\n    contentHash,\n  };\n}\n\n/**\n * Scan every item's history stream for drift (missing/unreadable streams, broken\n * hash chains, and item/history hash mismatches).\n *\n * Full chain re-verification of a large history tree is the dominant cost of\n * `pm health`. We cache the per-stream verification keyed by the history file's\n * mtime/ctime/size plus content hash. Strict callers keep recomputing the\n * content hash on metadata hits; latency-sensitive health checks can opt into\n * trusting the stat tuple and skip rereading unchanged streams.\n */\nexport async function scanHistoryDrift(\n  pmRoot: string,\n  items: Array<ItemMetadata & { body: string }>,\n  options: DriftScanOptions = {},\n): Promise<DriftScanResult> {\n  const missingStreams: string[] = [];\n  const unreadableStreams: string[] = [];\n  const hashMismatches: string[] = [];\n  const chainMismatches: string[] = [];\n\n  const cache = await loadDriftCache(pmRoot);\n  const previousEntries: Record<string, DriftCacheEntry> = cache?.entries ?? {};\n  const nextEntries: Record<string, DriftCacheEntry> = {};\n  let cacheDirty = false;\n  // Metadata mode does not open a stat-matched stream, so unreadable-after-stat\n  // failures are intentionally deferred to strict validate/history-repair scans.\n  const verifyCacheHitByContent = options.cacheHitVerification !== \"metadata\";\n\n  for (const item of items) {\n    const historyPath = getHistoryPath(pmRoot, item.id);\n\n    let stat: Awaited<ReturnType<typeof fs.stat>>;\n    try {\n      stat = await fs.stat(historyPath);\n    } catch (error: unknown) {\n      if (isErrno(error, \"ENOENT\")) {\n        missingStreams.push(item.id);\n      } else {\n        unreadableStreams.push(item.id);\n      }\n      continue;\n    }\n\n    const loadStreamVerification = async (): Promise<StreamVerification | null | \"unreadable\"> => {\n      try {\n        return await verifyHistoryStream(historyPath);\n      } catch {\n        return \"unreadable\";\n      }\n    };\n\n    const loadFreshVerification = async (): Promise<StreamVerification | null> => {\n      const loaded = await loadStreamVerification();\n      if (loaded === \"unreadable\") {\n        unreadableStreams.push(item.id);\n        return null;\n      }\n      if (!loaded) {\n        missingStreams.push(item.id);\n        return null;\n      }\n      return loaded;\n    };\n\n    const cached = previousEntries[item.id];\n    let verification: StreamVerification;\n    const metadataMatchesCache =\n      cached !== undefined &&\n      cached.mtime_ms === stat.mtimeMs &&\n      cached.ctime_ms === stat.ctimeMs &&\n      cached.size === stat.size;\n    const cachedContentHash =\n      typeof cached?.content_hash === \"string\" && cached.content_hash.length > 0 ? cached.content_hash : undefined;\n    const canUseCache = metadataMatchesCache && cachedContentHash !== undefined;\n    if (canUseCache && cached) {\n      let currentContentHash: string;\n      if (verifyCacheHitByContent) {\n        try {\n          currentContentHash = await readHistoryContentHash(historyPath);\n        } catch {\n          unreadableStreams.push(item.id);\n          continue;\n        }\n      } else {\n        currentContentHash = cachedContentHash;\n      }\n      if (!verifyCacheHitByContent || currentContentHash === cachedContentHash) {\n        verification = {\n          latestAfterHash: cached.latest_after_hash,\n          chainOk: cached.chain_ok,\n          contentHash: currentContentHash,\n        };\n      } else {\n        cacheDirty = true;\n        const refreshed = await loadFreshVerification();\n        if (!refreshed) {\n          continue;\n        }\n        verification = refreshed;\n      }\n    } else {\n      cacheDirty = true;\n      const refreshed = await loadFreshVerification();\n      if (!refreshed) {\n        continue;\n      }\n      verification = refreshed;\n    }\n\n    if (!verification.chainOk) {\n      chainMismatches.push(item.id);\n    }\n    nextEntries[item.id] = {\n      mtime_ms: stat.mtimeMs,\n      ctime_ms: stat.ctimeMs,\n      size: stat.size,\n      content_hash: verification.contentHash,\n      latest_after_hash: verification.latestAfterHash,\n      chain_ok: verification.chainOk,\n    };\n\n    const { body, ...frontMatter } = item;\n    const currentHash = hashDocument({\n      metadata: frontMatter as ItemMetadata,\n      body,\n    });\n    if (currentHash !== verification.latestAfterHash) {\n      hashMismatches.push(item.id);\n    }\n  }\n\n  if (cacheDirty || Object.keys(previousEntries).length !== Object.keys(nextEntries).length) {\n    const cachePath = getDriftCachePath(pmRoot);\n    try {\n      await fs.mkdir(path.dirname(cachePath), { recursive: true });\n      await writeFileAtomic(cachePath, JSON.stringify({ version: DRIFT_CACHE_VERSION, entries: nextEntries }));\n    } catch {\n      // Best-effort cache write: a failed persist must never fail a health scan.\n    }\n  }\n\n  const driftedItems = [...new Set([...missingStreams, ...unreadableStreams, ...hashMismatches, ...chainMismatches])].sort((a, b) =>\n    a.localeCompare(b),\n  );\n  return { missingStreams, unreadableStreams, hashMismatches, chainMismatches, driftedItems };\n}\n"],"names":[],"mappings":"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","debugId":"7919579f-9834-5809-8c55-f7618807569e"}

package/dist/cli-bundle/chunks/{chunk-RVG3WLY3.js → chunk-2LUNPA3U.js}

@@ -3,7 +3,7 @@
 import {
   getRuntimePath,
   writeFileAtomic
-} from "./chunk-I2VJM36R.js";
+} from "./chunk-AZ75OVK4.js";
 
 // dist/core/session/session-state.js
 import { promises as fs } from "node:fs";
@@ -53,6 +53,6 @@ export {
   setFocusedItem,
   clearFocusedItem
 };
-//# sourceMappingURL=chunk-RVG3WLY3.js.map
+//# sourceMappingURL=chunk-2LUNPA3U.js.map
 
 //# debugId=c63f67f8-15be-5ba4-9853-406782c70ecb

package/dist/cli-bundle/chunks/{chunk-OURX4WVG.js → chunk-2QJLN4KM.js}

@@ -1,21 +1,21 @@
 import {
   readHistoryEntries
-} from "./chunk-QTWWHFI3.js";
+} from "./chunk-FBBPCSJM.js";
 import {
   parseLimit
-} from "./chunk-DYZKSIVX.js";
+} from "./chunk-VE3BUO3R.js";
 import {
   enforceHistoryStreamPolicyForItems,
   listAllFrontMatterLight
-} from "./chunk-X7RKOJXL.js";
+} from "./chunk-SL233DQD.js";
 import {
   resolveItemTypeRegistry
-} from "./chunk-SO2IOH37.js";
+} from "./chunk-XNQ3YH6N.js";
 import {
   compareTimestampStrings,
   nowIso,
   resolveIsoOrRelative
-} from "./chunk-MTGMNUMJ.js";
+} from "./chunk-B3LROPTV.js";
 import {
   EXIT_CODE,
   PmCliError,
@@ -25,7 +25,7 @@ import {
   readSettings,
   resolvePmRoot,
   runActiveOnReadHooks
-} from "./chunk-5QLHQK7V.js";
+} from "./chunk-QWAJPGEI.js";
 
 // dist/cli/commands/activity.js
 import fs from "node:fs/promises";
@@ -193,4 +193,4 @@ export {
   _testOnly,
   runActivity
 };
-//# sourceMappingURL=chunk-OURX4WVG.js.map
+//# sourceMappingURL=chunk-2QJLN4KM.js.map

package/dist/cli-bundle/chunks/{search-2JX776KX.js → chunk-2ZY5SLNR.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]="aefc1a6f-1597-51fe-8f41-aa81f6bc1f71")}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]="1236de77-7e22-557c-870c-b1279c7eabc9")}catch(e){}}();
 import {
   collectStaleVectorizationIds
 } from "./chunk-ROGZTCCB.js";
@@ -7,22 +7,25 @@ import {
   buildEventCorpus,
   buildPlanFlatCorpus,
   buildReminderCorpus,
+  buildSearchCorpus,
   executeEmbeddingRequest,
   executeVectorQuery,
   readVectorizationStatusLedger,
   resolveEmbeddingProviders,
+  resolveSearchCorpusFields,
   resolveSettingsWithSemanticRuntimeDefaults,
   resolveVectorStores
-} from "./chunk-QCHNPN24.js";
+} from "./chunk-4YMX7XFI.js";
 import {
   buildContentFilterEcho,
   buildGovernanceMissingFilterEcho,
   collectRuntimeFilterValues,
+  isStatusAllFilterInput,
   matchesRuntimeFilters,
   parseStatusFilterCsv,
   resolveContentFieldFilters,
   resolveMissingMetadataFilters
-} from "./chunk-5SRID7DV.js";
+} from "./chunk-X3CD2VUI.js";
 import {
   hasContentFieldFilter,
   itemMatchesContentFilters
@@ -31,31 +34,30 @@ import {
   hasMissingMetadataFilter,
   itemMatchesMissingMetadata,
   lifecycleClassifierFromStatusRegistry
-} from "./chunk-MPEWACTG.js";
+} from "./chunk-6KARQMC6.js";
 import {
   parseLimit,
   parsePriority,
   parseType
-} from "./chunk-S673PVHD.js";
+} from "./chunk-CNPWCUDR.js";
 import {
   collectRegisteredItemFieldNames,
   listAllDocumentCandidatesCached,
   listAllFrontMatter,
   toItemRecord
-} from "./chunk-GL3QKIET.js";
-import "./chunk-22YA6GCA.js";
+} from "./chunk-XKJDCJEH.js";
 import {
   isTerminalStatus,
   parseItemDocument
-} from "./chunk-EMFDZ7N3.js";
+} from "./chunk-FSOJCFDS.js";
 import {
   resolveItemTypeRegistry
-} from "./chunk-BQVESTOG.js";
+} from "./chunk-KCJZREBI.js";
 import {
   compareTimestampStrings,
   nowIso,
   resolveIsoOrRelative
-} from "./chunk-5P2LQV2F.js";
+} from "./chunk-MTQK5ZSB.js";
 import {
   EXIT_CODE,
   PmCliError,
@@ -74,7 +76,7 @@ import {
   runActiveOnReadHooks,
   toNonEmptyString,
   toNonEmptyStringOrUndefined
-} from "./chunk-I2VJM36R.js";
+} from "./chunk-AZ75OVK4.js";
 
 // dist/cli/commands/search.js
 import fs from "node:fs/promises";
@@ -318,6 +320,112 @@ async function rerankCandidatesWithEmbeddings(provider, model, query, candidates
   return scoreById;
 }
 
+// dist/core/search/bm25.js
+var DEFAULT_BM25_K1 = 1.2;
+var DEFAULT_BM25_B = 0.75;
+function tokenizeBm25(text) {
+  return tokenizeAlphaNumeric(text);
+}
+function buildTermFrequencies(tokens) {
+  const frequencies = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    frequencies.set(token, (frequencies.get(token) ?? 0) + 1);
+  }
+  return frequencies;
+}
+function buildBm25Index(documents) {
+  const stats = [];
+  const documentFrequency = /* @__PURE__ */ new Map();
+  let totalLength = 0;
+  for (const document of documents) {
+    const tokens = tokenizeBm25(document.text);
+    const termFrequencies = buildTermFrequencies(tokens);
+    totalLength += tokens.length;
+    for (const term of termFrequencies.keys()) {
+      documentFrequency.set(term, (documentFrequency.get(term) ?? 0) + 1);
+    }
+    stats.push({ id: document.id, termFrequencies, length: tokens.length });
+  }
+  const documentCount = stats.length;
+  return {
+    documents: stats,
+    documentFrequency,
+    documentCount,
+    averageDocumentLength: documentCount > 0 ? totalLength / documentCount : 0
+  };
+}
+function inverseDocumentFrequency(documentCount, termDocumentFrequency) {
+  return Math.log(1 + (documentCount - termDocumentFrequency + 0.5) / (termDocumentFrequency + 0.5));
+}
+function scoreBm25Query(index, queryTokens, params) {
+  const scores = /* @__PURE__ */ new Map();
+  if (index.documentCount === 0 || index.averageDocumentLength === 0) {
+    return scores;
+  }
+  const distinctQueryTerms = [...new Set(queryTokens.filter((token) => token.length > 0))];
+  if (distinctQueryTerms.length === 0) {
+    return scores;
+  }
+  const idfByTerm = /* @__PURE__ */ new Map();
+  for (const term of distinctQueryTerms) {
+    const termDocumentFrequency = index.documentFrequency.get(term);
+    if (termDocumentFrequency === void 0) {
+      continue;
+    }
+    idfByTerm.set(term, inverseDocumentFrequency(index.documentCount, termDocumentFrequency));
+  }
+  if (idfByTerm.size === 0) {
+    return scores;
+  }
+  for (const document of index.documents) {
+    let score = 0;
+    for (const [term, idf] of idfByTerm) {
+      const termFrequency = document.termFrequencies.get(term);
+      if (termFrequency === void 0) {
+        continue;
+      }
+      const lengthNormalization = 1 - params.b + params.b * document.length / index.averageDocumentLength;
+      const denominator = termFrequency + params.k1 * lengthNormalization;
+      score += idf * (termFrequency * (params.k1 + 1) / denominator);
+    }
+    if (score > 0) {
+      scores.set(document.id, score);
+    }
+  }
+  return scores;
+}
+function resolveClampedParam(candidate, fallback, min, max) {
+  if (typeof candidate !== "number" || !Number.isFinite(candidate)) {
+    return fallback;
+  }
+  return Math.min(max, Math.max(min, candidate));
+}
+function flattenSearchCorpusText(corpus) {
+  const collectValueText = (value) => {
+    if (typeof value === "string") {
+      return [value];
+    }
+    if (typeof value === "number") {
+      return [String(value)];
+    }
+    if (Array.isArray(value)) {
+      return value.flatMap(collectValueText);
+    }
+    if (typeof value === "object" && value !== null) {
+      return Object.values(value).flatMap(collectValueText);
+    }
+    return [];
+  };
+  return collectValueText(Object.values(corpus)).join(" ");
+}
+function resolveBm25Params(settings) {
+  const bm25 = settings?.search?.bm25;
+  return {
+    k1: resolveClampedParam(bm25?.k1, DEFAULT_BM25_K1, 0, 1e3),
+    b: resolveClampedParam(bm25?.b, DEFAULT_BM25_B, 0, 1)
+  };
+}
+
 // dist/cli/commands/search.js
 var DEFAULT_COMPACT_SEARCH_FIELDS = [
   "id",
@@ -405,7 +513,7 @@ function buildCompactSearchFilterSummary(params) {
   const { mode, matchMode, options, includeLinked, titleExact, phraseExact, scoreThreshold, hybridSemanticWeight, runtimeFieldFilters } = params;
   const filters = {};
   if (options.status !== void 0) {
-    filters.status = options.status;
+    filters.status = isStatusAllFilterInput(options.status) ? "all" : options.status;
   }
   if (options.type !== void 0) {
     filters.type = options.type;
@@ -479,7 +587,7 @@ function buildVerboseSearchFilters(params) {
   return {
     mode: effectiveMode,
     match_mode: matchMode,
-    status: options.status ?? null,
+    status: isStatusAllFilterInput(options.status) ? "all" : options.status ?? null,
     type: options.type ?? null,
     tag: options.tag ?? null,
     priority: options.priority ?? null,
@@ -682,7 +790,9 @@ var _testOnlySearchCommand = {
   collectExactPhraseFields,
   collectLinkedPaths,
   combineHybridHits,
+  computeBuiltInBm25Hits,
   computeSemanticOrHybridHits,
+  resolveBuiltInBm25Mode,
   countOccurrences,
   dependencyEntries,
   documentContainsExactPhrase,
@@ -1054,9 +1164,10 @@ function buildHitHighlights(document, matchedFields, tokens) {
 }
 function scoreDocument(document, tokens, normalizedQuery, linkedCorpus, tuning, idPrefix, applyCoverageBonus = false) {
   const item = document.metadata;
-  const normalizedId = item.id.trim().toLowerCase();
+  const normalizedId = normalizeSearchPhrase(item.id);
   const normalizedIdPrefix = typeof idPrefix === "string" ? idPrefix.trim().toLowerCase() : "";
-  const normalizedShortId = normalizedIdPrefix.length > 0 && normalizedId.startsWith(normalizedIdPrefix) ? normalizedId.slice(normalizedIdPrefix.length) : normalizedId;
+  const normalizedIdPrefixPhrase = normalizeSearchPhrase(normalizedIdPrefix);
+  const normalizedShortId = normalizedIdPrefixPhrase.length > 0 && normalizedId.startsWith(normalizedIdPrefixPhrase) ? normalizedId.slice(normalizedIdPrefixPhrase.length).trim() : normalizedId;
   if (normalizedQuery === normalizedId || normalizedQuery === normalizedShortId) {
     return {
       item,
@@ -1422,7 +1533,7 @@ function forceExactIdHitsToTop(rankedHits, keywordHits) {
   }));
   return [...promoted, ...remaining];
 }
-function combineHybridHits(filteredById, semanticScores, keywordHits, hybridSemanticWeight) {
+function combineHybridHits(filteredById, semanticScores, keywordHits, hybridSemanticWeight, semanticFieldLabel = "semantic") {
   const keywordScores = new Map(keywordHits.map((entry) => [entry.item.id, entry.score]));
   const keywordMatches = new Map(keywordHits.map((entry) => [entry.item.id, entry.matched_fields]));
   const normalizedSemantic = normalizeScoreMap(semanticScores);
@@ -1439,7 +1550,7 @@ function combineHybridHits(filteredById, semanticScores, keywordHits, hybridSema
     }
     const matchedFields = /* @__PURE__ */ new Set();
     if (semanticScores.has(id)) {
-      matchedFields.add("semantic");
+      matchedFields.add(semanticFieldLabel);
     }
     for (const field of keywordMatches.get(id) ?? []) {
       matchedFields.add(field);
@@ -1451,6 +1562,35 @@ function combineHybridHits(filteredById, semanticScores, keywordHits, hybridSema
     };
   }).filter((entry) => entry !== null);
 }
+function resolveBuiltInBm25Mode(params) {
+  const normalized = params.configuredProvider?.trim().toLowerCase();
+  if (normalized === "bm25") {
+    return "explicit";
+  }
+  if (normalized === "auto" && !params.hasEmbeddingProvider && !params.hasExtensionSearchProvider) {
+    return "auto-fallback";
+  }
+  return null;
+}
+function computeBuiltInBm25Hits(params) {
+  const bm25Documents = params.filteredDocuments.map((document) => ({
+    id: document.metadata.id,
+    text: flattenSearchCorpusText(buildSearchCorpus(document, { fields: params.corpusFields }))
+  }));
+  const index = buildBm25Index(bm25Documents);
+  const bm25Scores = scoreBm25Query(index, tokenizeBm25(params.query), params.bm25Params);
+  const filteredById = new Map(params.filteredDocuments.map((document) => [document.metadata.id, document]));
+  if (params.requestedMode === "semantic") {
+    const semanticHits = [...bm25Scores].map(([id, score]) => ({
+      item: filteredById.get(id).metadata,
+      score,
+      matched_fields: ["bm25"]
+    }));
+    return forceExactIdHitsToTop(semanticHits, params.keywordHits);
+  }
+  const hybridHits = combineHybridHits(filteredById, bm25Scores, params.keywordHits, params.hybridSemanticWeight, "bm25");
+  return forceExactIdHitsToTop(hybridHits, params.keywordHits);
+}
 function mergeVectorHitsById(vectorHitGroups) {
   const bestById = /* @__PURE__ */ new Map();
   for (const group of vectorHitGroups) {
@@ -1774,6 +1914,11 @@ async function runSearch(rawQuery, rawOptions, global) {
   const vectorResolution = resolveVectorStores(settings);
   const extensionSearchProvider = resolveExtensionSearchProvider(settings);
   const extensionVectorAdapter = resolveExtensionVectorAdapter(settings);
+  const bm25Mode = resolveBuiltInBm25Mode({
+    configuredProvider: toOptionalNonEmptyString(settings.search?.provider),
+    hasEmbeddingProvider: providerResolution.active !== null,
+    hasExtensionSearchProvider: extensionSearchProvider !== null
+  });
   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);
@@ -1829,7 +1974,22 @@ async function runSearch(rawQuery, rawOptions, global) {
     applyCoverageBonus
   )).filter((entry) => entry !== null).filter((entry) => matchMode !== "and" || entry.matched_all_terms === true);
   let hits = keywordHits;
-  if (effectiveMode !== "keyword") {
+  const useBuiltInBm25 = bm25Mode !== null && effectiveMode !== "keyword";
+  if (bm25Mode !== null && effectiveMode !== "keyword") {
+    hits = computeBuiltInBm25Hits({
+      requestedMode: effectiveMode,
+      query,
+      filteredDocuments,
+      keywordHits,
+      corpusFields: resolveSearchCorpusFields(settings),
+      bm25Params: resolveBm25Params(settings),
+      hybridSemanticWeight
+    });
+    if (bm25Mode === "auto-fallback") {
+      warnings.push(`search_${effectiveMode}_offline_bm25:no_embedding_provider:using_lexical_bm25`);
+    }
+  }
+  if (effectiveMode !== "keyword" && !useBuiltInBm25) {
     const builtInSemanticWillRun = !extensionSearchProvider && providerResolution.active !== null && (vectorResolution.active !== null || extensionVectorAdapter !== null);
     if (modeWasExplicit && builtInSemanticWillRun) {
       await maybeEmitVectorIndexStaleWarning(pmRoot, filteredDocuments, warnings);
@@ -2024,16 +2184,17 @@ async function runSearch(rawQuery, rawOptions, global) {
     ...warnings.length > 0 ? { warnings } : {}
   };
 }
+
 export {
-  _testOnlySearchCommand,
-  classifyImplicitSemanticFallbackReason,
   collectErrorCauseCodes,
-  resolveHybridSemanticWeight,
+  classifyImplicitSemanticFallbackReason,
+  _testOnlySearchCommand,
   resolveSearchMaxResults,
   resolveSearchScoreThreshold,
+  resolveHybridSemanticWeight,
   resolveSearchTuning,
   runSearch
 };
-//# sourceMappingURL=search-2JX776KX.js.map
+//# sourceMappingURL=chunk-2ZY5SLNR.js.map
 
-//# debugId=aefc1a6f-1597-51fe-8f41-aa81f6bc1f71
+//# debugId=1236de77-7e22-557c-870c-b1279c7eabc9