@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-TZXRBVAM.js

@@ -0,0 +1,2306 @@
+
+!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]="106509f0-71e6-5a15-915f-acf57240a3e4")}catch(e){}}();
+import {
+  collectStaleVectorizationIds
+} from "./chunk-ROGZTCCB.js";
+import {
+  applyFilterValueEcho,
+  buildContentFilterEcho,
+  buildGovernanceMissingFilterEcho,
+  collectRuntimeFilterValues,
+  isStatusAllFilterInput,
+  matchesRuntimeFilters,
+  parseStatusFilterCsv,
+  resolveContentFieldFilters,
+  resolveMissingMetadataFilters
+} from "./chunk-3VHSI5FL.js";
+import {
+  hasContentFieldFilter,
+  itemMatchesContentFilters
+} from "./chunk-QB7XMHJW.js";
+import {
+  hasMissingMetadataFilter,
+  itemMatchesMissingMetadata,
+  lifecycleClassifierFromStatusRegistry
+} from "./chunk-MVYWGY2A.js";
+import {
+  parseLimit,
+  parsePriority,
+  parseType
+} from "./chunk-22KBU3MW.js";
+import {
+  buildEventCorpus,
+  buildPlanFlatCorpus,
+  buildReminderCorpus,
+  buildSearchCorpus,
+  executeEmbeddingRequest,
+  executeVectorQuery,
+  readVectorizationStatusLedger,
+  resolveEmbeddingProviders,
+  resolveSearchCorpusFields,
+  resolveSettingsWithSemanticRuntimeDefaults,
+  resolveVectorStores
+} from "./chunk-EOKXK3R3.js";
+import {
+  resolveRegisteredSearchProvider,
+  resolveRegisteredVectorStoreAdapter
+} from "./chunk-KGHH652T.js";
+import {
+  collectRegisteredItemFieldNames,
+  listAllDocumentCandidatesCached,
+  listAllFrontMatter,
+  toItemRecord
+} from "./chunk-ENGQOEUY.js";
+import {
+  isTerminalStatus,
+  parseItemDocument
+} from "./chunk-G24G7ZAV.js";
+import {
+  compareTimestampStrings,
+  nowIso,
+  resolveIsoOrRelative
+} from "./chunk-3GCS5SKL.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettings,
+  runActiveOnReadHooks
+} from "./chunk-E3SZTQ4K.js";
+import {
+  EXIT_CODE,
+  coerceNumberInRange,
+  coercePositiveInteger,
+  getItemPath,
+  getSettingsPath,
+  isPathWithinDirectory,
+  pathExists,
+  resolveGlobalPmRoot,
+  resolveItemTypeRegistry,
+  resolvePmRoot,
+  resolveRuntimeFieldRegistry,
+  resolveRuntimeStatusRegistry,
+  toNonEmptyString,
+  toNonEmptyStringOrUndefined
+} from "./chunk-57NWPFF2.js";
+
+// dist/cli/commands/search.js
+import fs from "node:fs/promises";
+import path from "node:path";
+
+// dist/core/shared/text-normalization.js
+function normalizeLowercaseWhitespace(value) {
+  return value.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function tokenizeAlphaNumeric(value) {
+  return normalizeLowercaseWhitespace(value).split(/[^a-z0-9]+/).filter((token) => token.length > 0);
+}
+function jaccardSimilarity(leftTokens, rightTokens) {
+  if (leftTokens.length === 0 && rightTokens.length === 0) {
+    return 1;
+  }
+  if (leftTokens.length === 0 || rightTokens.length === 0) {
+    return 0;
+  }
+  const leftSet = new Set(leftTokens);
+  const rightSet = new Set(rightTokens);
+  let intersection = 0;
+  for (const token of leftSet) {
+    if (rightSet.has(token)) {
+      intersection += 1;
+    }
+  }
+  const union = (/* @__PURE__ */ new Set([...leftSet, ...rightSet])).size;
+  return intersection / union;
+}
+
+// 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/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",
+  "title",
+  "status",
+  "type",
+  "priority",
+  "updated_at",
+  "score",
+  "matched_fields"
+];
+var SEARCH_HIT_FIELD_KEYS = /* @__PURE__ */ new Set(["score", "matched_fields", "highlights"]);
+var SEARCH_ITEM_FIELD_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "title",
+  "description",
+  "type",
+  "status",
+  "priority",
+  "tags",
+  "created_at",
+  "updated_at",
+  "deadline",
+  "assignee",
+  "author",
+  "estimated_minutes",
+  "acceptance_criteria",
+  "dependencies",
+  "comments",
+  "notes",
+  "learnings",
+  "reminders",
+  "events",
+  "files",
+  "tests",
+  "docs",
+  "close_reason",
+  "parent",
+  "reviewer",
+  "risk",
+  "confidence",
+  "sprint",
+  "release",
+  "blocked_by",
+  "blocked_reason",
+  "reporter",
+  "severity",
+  "environment",
+  "repro_steps",
+  "resolution",
+  "expected_result",
+  "actual_result",
+  "affected_version",
+  "fixed_version",
+  "component",
+  "regression",
+  "customer_impact",
+  "definition_of_ready",
+  "order",
+  "rank",
+  "goal",
+  "objective",
+  "value",
+  "impact",
+  "outcome",
+  "why_now",
+  "plan"
+]);
+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 EXACT_ID_MATCH_SCORE = 1e3;
+var SHORT_ID_MATCH_SCORE = 900;
+var HIGHLIGHT_OPEN = "\xAB";
+var HIGHLIGHT_CLOSE = "\xBB";
+var HIGHLIGHT_SNIPPET_RADIUS = 60;
+var INLINE_QUERY_FILTER_FIELDS = ["tag", "status", "type", "priority"];
+var COMPACT_SEARCH_VALUE_FILTER_ECHO_ENTRIES = [
+  {
+    optionKey: "status",
+    summaryKey: "status",
+    normalize: (value) => isStatusAllFilterInput(value) ? "all" : value
+  },
+  { optionKey: "type", summaryKey: "type" },
+  { optionKey: "tag", summaryKey: "tag" },
+  { optionKey: "priority", summaryKey: "priority" },
+  { optionKey: "deadlineBefore", summaryKey: "deadline_before" },
+  { optionKey: "deadlineAfter", summaryKey: "deadline_after" },
+  { optionKey: "updatedAfter", summaryKey: "updated_after" },
+  { optionKey: "updatedBefore", summaryKey: "updated_before" },
+  { optionKey: "createdAfter", summaryKey: "created_after" },
+  { optionKey: "createdBefore", summaryKey: "created_before" },
+  { optionKey: "assignee", summaryKey: "assignee" },
+  { optionKey: "sprint", summaryKey: "sprint" },
+  { optionKey: "release", summaryKey: "release" },
+  { optionKey: "parent", summaryKey: "parent" }
+];
+function isNonEmptyRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+function buildCompactSearchFilterSummary(params) {
+  const { mode, matchMode, options, includeLinked, titleExact, phraseExact, scoreThreshold, hybridSemanticWeight, runtimeFieldFilters } = params;
+  const filters = {};
+  applyFilterValueEcho(filters, options, COMPACT_SEARCH_VALUE_FILTER_ECHO_ENTRIES);
+  Object.assign(filters, buildGovernanceMissingFilterEcho(options));
+  Object.assign(filters, buildContentFilterEcho(options));
+  if (matchMode !== "or") {
+    filters.match_mode = matchMode;
+  }
+  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 buildVerboseSearchFilters(params) {
+  const { effectiveMode, matchMode, options, includeLinked, titleExact, phraseExact, scoreThreshold, hybridSemanticWeight, queryExpansion, rerank, runtimeFieldFilters } = params;
+  return {
+    mode: effectiveMode,
+    match_mode: matchMode,
+    status: isStatusAllFilterInput(options.status) ? "all" : valueOrNull(options.status),
+    type: valueOrNull(options.type),
+    tag: valueOrNull(options.tag),
+    priority: valueOrNull(options.priority),
+    deadline_before: valueOrNull(options.deadlineBefore),
+    deadline_after: valueOrNull(options.deadlineAfter),
+    updated_after: valueOrNull(options.updatedAfter),
+    updated_before: valueOrNull(options.updatedBefore),
+    created_after: valueOrNull(options.createdAfter),
+    created_before: valueOrNull(options.createdBefore),
+    assignee: valueOrNull(options.assignee),
+    sprint: valueOrNull(options.sprint),
+    release: valueOrNull(options.release),
+    parent: valueOrNull(options.parent),
+    ...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: valueOrNull(options.limit),
+    runtime_filters: runtimeFieldFilters
+  };
+}
+function valueOrNull(value) {
+  return value ?? null;
+}
+function collectErrorCauseCodes(error) {
+  const codes = [];
+  let current = error;
+  for (let depth = 0; depth < 5 && current && typeof current === "object"; depth += 1) {
+    const code = current.code;
+    if (typeof code === "string") {
+      codes.push(code.toLowerCase());
+    }
+    current = current.cause;
+  }
+  return codes.join(" ");
+}
+function classifyImplicitSemanticFallbackReason(error) {
+  const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
+  const causeCodes = collectErrorCauseCodes(error);
+  const haystack = `${message} ${causeCodes}`;
+  if (haystack.includes("timed out") || haystack.includes("timeout") || haystack.includes("etimedout")) {
+    return "timeout";
+  }
+  if (haystack.includes("econnrefused") || haystack.includes("connection refused") || haystack.includes("connect ") || haystack.includes("enotfound") || haystack.includes("eai_again") || haystack.includes("econnreset") || haystack.includes("fetch failed")) {
+    return "connection";
+  }
+  return "error";
+}
+function buildExplicitSemanticFallbackWarning(requestedMode, error) {
+  const reason = classifyImplicitSemanticFallbackReason(error);
+  return `search_${requestedMode}_fallback:${reason}:using_keyword_mode`;
+}
+async function maybeEmitVectorIndexStaleWarning(pmRoot, filteredDocuments, warnings) {
+  try {
+    const ledger = await readVectorizationStatusLedger(pmRoot);
+    if (ledger.warnings.length > 0) {
+      warnings.push(...ledger.warnings);
+    }
+    const staleIds = collectStaleVectorizationIds(filteredDocuments.map((document) => ({
+      id: document.metadata.id,
+      updated_at: document.metadata.updated_at
+    })), ledger.entries);
+    if (staleIds.length === 0) {
+      return;
+    }
+    warnings.push(`vector_index_stale:${staleIds.length}`);
+    process.stderr.write(`[pm] warning: ${staleIds.length} item${staleIds.length === 1 ? " is" : "s are"} new or modified since the last reindex and ${staleIds.length === 1 ? "is" : "are"} NOT in the semantic index yet \u2014 they will be missing from semantic/hybrid results until you run 'pm reindex --mode hybrid'. (Write-time embedding is governed by search.mutation_refresh_policy; staleness means the embed was skipped, failed, or the backend was unreachable.)
+`);
+  } catch {
+  }
+}
+function parseMode(raw, _context) {
+  if (raw === void 0) {
+    return "keyword";
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (normalized !== "keyword" && normalized !== "semantic" && normalized !== "hybrid") {
+    throw new PmCliError("Search mode must be one of keyword|semantic|hybrid", EXIT_CODE.USAGE);
+  }
+  return normalized;
+}
+function parseIncludeLinked(raw) {
+  return raw === true;
+}
+function parseTitleExact(raw) {
+  return raw === true;
+}
+function parsePhraseExact(raw) {
+  return raw === true;
+}
+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();
+}
+function parseDeadline(raw, fieldLabel) {
+  if (raw === void 0)
+    return void 0;
+  return resolveIsoOrRelative(raw, /* @__PURE__ */ new Date(), fieldLabel);
+}
+function parseFieldSelectors(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const selectors = raw.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  if (selectors.length === 0) {
+    throw new PmCliError("Search --fields requires a comma-separated list of field names", EXIT_CODE.USAGE);
+  }
+  return [...new Set(selectors)];
+}
+function parseProjectionConfig(options) {
+  const compactRequested = options.compact === true;
+  const fullRequested = options.full === true;
+  const fieldSelectors = parseFieldSelectors(options.fields);
+  const enabledModes = Number(compactRequested) + Number(fullRequested) + Number(fieldSelectors !== void 0);
+  if (enabledModes > 1) {
+    throw new PmCliError("Search projection options are mutually exclusive. Use one of --compact, --full, or --fields.", EXIT_CODE.USAGE);
+  }
+  if (compactRequested) {
+    return {
+      mode: "compact",
+      fields: [...DEFAULT_COMPACT_SEARCH_FIELDS]
+    };
+  }
+  if (fullRequested) {
+    return {
+      mode: "full",
+      fields: []
+    };
+  }
+  if (fieldSelectors) {
+    return {
+      mode: "fields",
+      fields: fieldSelectors
+    };
+  }
+  return {
+    mode: "full",
+    fields: []
+  };
+}
+var _testOnlySearchCommand = {
+  applyFilters,
+  applyExactQueryFilters,
+  applyInlineQueryFilters,
+  buildHitHighlights,
+  buildVerboseSearchFilters,
+  buildExplicitSemanticFallbackWarning,
+  buildCompactSearchFilterSummary,
+  buildHybridLexicalScore,
+  buildRerankCorpus,
+  buildSemanticHits,
+  classifyImplicitSemanticFallbackReason,
+  collectErrorCauseCodes,
+  collectExactPhraseFields,
+  collectLinkedPaths,
+  combineHybridHits,
+  computeBuiltInBm25Hits,
+  computeSemanticOrHybridHits,
+  resolveBuiltInBm25Mode,
+  countOccurrences,
+  dependencyEntries,
+  documentContainsExactPhrase,
+  emptySearchResult,
+  highlightFieldSnippet,
+  loadDocuments,
+  markTokenRuns,
+  parseInlineQueryFilters,
+  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;
+  }
+  const runtimeKeys = new Set(runtimeFieldRegistry.definitions.flatMap((field) => [field.key, field.metadata_key]));
+  const unknown = projection.fields.filter((field) => {
+    const normalized = field.trim();
+    const itemKey = normalized.startsWith("item.") ? normalized.slice("item.".length) : normalized;
+    return !SEARCH_HIT_FIELD_KEYS.has(normalized) && !SEARCH_ITEM_FIELD_KEYS.has(itemKey) && !runtimeKeys.has(itemKey);
+  });
+  if (unknown.length > 0) {
+    throw new PmCliError(`Unknown search --fields value(s): ${unknown.join(", ")}`, EXIT_CODE.USAGE, {
+      examples: [
+        "pm search <query> --fields id,title,status,score",
+        "pm search <query> --fields id,title,item.description,matched_fields"
+      ],
+      nextSteps: ["Use item.<field> for explicit item metadata fields, or run pm search --help for projection examples."]
+    });
+  }
+}
+function parseTokens(query) {
+  const normalized = normalizeSearchPhrase(query);
+  if (!normalized) {
+    throw new PmCliError("Search query must not be empty", EXIT_CODE.USAGE);
+  }
+  return normalized.split(/\s+/).filter(Boolean);
+}
+function parseInlineQueryFilters(query) {
+  const inlineFilters = {};
+  const residualTokens = [];
+  for (const token of query.split(/\s+/).filter((entry) => entry.length > 0)) {
+    const separatorIndex = token.indexOf(":");
+    const field = separatorIndex > 0 ? token.slice(0, separatorIndex).toLowerCase() : "";
+    const value = separatorIndex > 0 ? token.slice(separatorIndex + 1) : "";
+    const matchedField = INLINE_QUERY_FILTER_FIELDS.includes(field) ? field : void 0;
+    if (matchedField && value.length > 0 && inlineFilters[matchedField] === void 0) {
+      inlineFilters[matchedField] = value;
+      continue;
+    }
+    residualTokens.push(token);
+  }
+  return {
+    residualQuery: residualTokens.join(" "),
+    inlineFilters
+  };
+}
+function applyInlineQueryFilters(options, inlineFilters, warnings) {
+  const merged = { ...options };
+  for (const field of INLINE_QUERY_FILTER_FIELDS) {
+    const inlineValue = inlineFilters[field];
+    if (inlineValue === void 0) {
+      continue;
+    }
+    if (toNonEmptyStringOrUndefined(merged[field]) !== void 0) {
+      warnings.push(`search_inline_filter_ignored:${field}:flag_takes_precedence`);
+      continue;
+    }
+    merged[field] = inlineValue;
+  }
+  return merged;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function textEntries(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "object" && entry !== null && typeof entry.text === "string") : [];
+}
+function dependencyEntries(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "object" && entry !== null && typeof entry.id === "string" && typeof entry.kind === "string") : [];
+}
+function collectExactPhraseFields(document) {
+  const item = document.metadata;
+  return [
+    item.title,
+    item.description,
+    item.status,
+    stringArray(item.tags).join(" "),
+    document.body,
+    textEntries(item.comments).map((entry) => entry.text).join(" "),
+    textEntries(item.notes).map((entry) => entry.text).join(" "),
+    textEntries(item.learnings).map((entry) => entry.text).join(" "),
+    buildReminderCorpus(item).join(" "),
+    buildEventCorpus(item).join(" "),
+    dependencyEntries(item.dependencies).map((entry) => `${entry.id} ${entry.kind}`).join(" "),
+    buildPlanFlatCorpus(item)
+  ];
+}
+function documentContainsExactPhrase(document, normalizedQuery) {
+  return collectExactPhraseFields(document).some((fieldValue) => normalizeSearchPhrase(fieldValue).includes(normalizedQuery));
+}
+function applyExactQueryFilters(items, normalizedQuery, options) {
+  if (!options.titleExact && !options.phraseExact) {
+    return items;
+  }
+  return items.filter((document) => {
+    if (options.titleExact && normalizeSearchPhrase(document.metadata.title) !== normalizedQuery) {
+      return false;
+    }
+    if (options.phraseExact && !documentContainsExactPhrase(document, normalizedQuery)) {
+      return false;
+    }
+    return true;
+  });
+}
+function assertSearchAssigneeFilter(assigneeFilter) {
+  if (assigneeFilter && (assigneeFilter.toLowerCase() === "none" || assigneeFilter.toLowerCase() === "null")) {
+    throw new PmCliError('--assignee no longer accepts "none" or "null".', EXIT_CODE.USAGE);
+  }
+}
+function resolveSearchMetadataFilterSet(options, typeRegistry, statusFilter) {
+  const assigneeFilter = options.assignee?.trim();
+  assertSearchAssigneeFilter(assigneeFilter);
+  const missingMetadataFilters = resolveMissingMetadataFilters(options);
+  const contentFieldFilters = resolveContentFieldFilters(options);
+  return {
+    typeFilter: parseType(options.type, typeRegistry),
+    tagFilter: options.tag?.trim().toLowerCase(),
+    priorityFilter: parsePriority(options.priority),
+    deadlineBefore: parseDeadline(options.deadlineBefore, "deadline-before"),
+    deadlineAfter: parseDeadline(options.deadlineAfter, "deadline-after"),
+    updatedAfter: parseTimestampWindow(options.updatedAfter, "updated-after"),
+    updatedBefore: parseTimestampWindow(options.updatedBefore, "updated-before"),
+    createdAfter: parseTimestampWindow(options.createdAfter, "created-after"),
+    createdBefore: parseTimestampWindow(options.createdBefore, "created-before"),
+    assigneeFilter,
+    sprintFilter: options.sprint?.trim(),
+    releaseFilter: options.release?.trim(),
+    parentFilter: options.parent?.trim(),
+    statusSet: statusFilter && statusFilter.length > 0 ? new Set(statusFilter) : void 0,
+    missingMetadataFilters,
+    missingMetadataActive: hasMissingMetadataFilter(missingMetadataFilters),
+    contentFieldFilters,
+    contentFiltersActive: hasContentFieldFilter(contentFieldFilters)
+  };
+}
+function matchesScalarSearchFilters(item, filters) {
+  return matchesIdentitySearchFilters(item, filters) && matchesTimestampSearchFilters(item, filters) && matchesOwnerSearchFilters(item, filters);
+}
+function matchesIdentitySearchFilters(item, filters) {
+  if (filters.statusSet && !filters.statusSet.has(item.status))
+    return false;
+  if (filters.typeFilter && item.type !== filters.typeFilter)
+    return false;
+  if (filters.tagFilter && !stringArray(item.tags).includes(filters.tagFilter))
+    return false;
+  if (filters.priorityFilter !== void 0 && item.priority !== filters.priorityFilter)
+    return false;
+  return true;
+}
+function matchesTimestampSearchFilters(item, filters) {
+  if (filters.deadlineBefore && (!item.deadline || compareTimestampStrings(item.deadline, filters.deadlineBefore) > 0))
+    return false;
+  if (filters.deadlineAfter && (!item.deadline || compareTimestampStrings(item.deadline, filters.deadlineAfter) < 0))
+    return false;
+  if (filters.updatedAfter && compareTimestampStrings(item.updated_at, filters.updatedAfter) < 0)
+    return false;
+  if (filters.updatedBefore && compareTimestampStrings(item.updated_at, filters.updatedBefore) > 0)
+    return false;
+  if (filters.createdAfter && compareTimestampStrings(item.created_at, filters.createdAfter) < 0)
+    return false;
+  if (filters.createdBefore && compareTimestampStrings(item.created_at, filters.createdBefore) > 0)
+    return false;
+  return true;
+}
+function matchesOwnerSearchFilters(item, filters) {
+  if (filters.assigneeFilter !== void 0 && item.assignee !== filters.assigneeFilter)
+    return false;
+  if (filters.sprintFilter !== void 0 && item.sprint !== filters.sprintFilter)
+    return false;
+  if (filters.releaseFilter !== void 0 && item.release !== filters.releaseFilter)
+    return false;
+  if (filters.parentFilter !== void 0 && item.parent !== filters.parentFilter)
+    return false;
+  return true;
+}
+function matchesSearchMetadataFilters(document, filters, runtimeFieldFilters, lifecycleClassifier) {
+  const item = document.metadata;
+  if (!matchesScalarSearchFilters(item, filters)) {
+    return false;
+  }
+  if (!matchesRuntimeFilters(item, runtimeFieldFilters)) {
+    return false;
+  }
+  if (filters.missingMetadataActive && !itemMatchesMissingMetadata(item, filters.missingMetadataFilters, lifecycleClassifier)) {
+    return false;
+  }
+  if (filters.contentFiltersActive && !itemMatchesContentFilters(item, filters.contentFieldFilters)) {
+    return false;
+  }
+  return true;
+}
+function applyFilters(items, options, typeRegistry, runtimeFieldFilters, statusFilter, lifecycleClassifier) {
+  const filters = resolveSearchMetadataFilterSet(options, typeRegistry, statusFilter);
+  return items.filter((document) => matchesSearchMetadataFilters(document, filters, runtimeFieldFilters, lifecycleClassifier));
+}
+function countOccurrences(haystack, needle) {
+  let count = 0;
+  let index = 0;
+  while (true) {
+    const foundAt = haystack.indexOf(needle, index);
+    if (foundAt < 0) {
+      return count;
+    }
+    count += 1;
+    index = foundAt + needle.length;
+  }
+}
+function tokenizeForExactTokenMatch(value) {
+  return tokenizeAlphaNumeric(value);
+}
+function collectLinkedPaths(item) {
+  const fromFiles = (item.files ?? []).map((entry) => ({
+    scope: entry.scope,
+    path: entry.path.trim()
+  }));
+  const fromDocs = (item.docs ?? []).map((entry) => ({
+    scope: entry.scope,
+    path: entry.path.trim()
+  }));
+  const fromTests = (item.tests ?? []).filter((entry) => typeof entry.path === "string" && entry.path.trim().length > 0).map((entry) => ({
+    scope: entry.scope,
+    path: entry.path.trim()
+  }));
+  const sorted = [...fromFiles, ...fromDocs, ...fromTests].filter((entry) => entry.path.length > 0).sort((a, b) => a.scope.localeCompare(b.scope) || a.path.localeCompare(b.path));
+  const deduped = /* @__PURE__ */ new Map();
+  for (const entry of sorted) {
+    deduped.set(`${entry.scope}:${entry.path}`, entry);
+  }
+  return [...deduped.values()];
+}
+async function resolveContainmentRoot(root) {
+  const resolved = path.resolve(root);
+  try {
+    const realpathRoot = await fs.realpath(resolved);
+    return {
+      resolved,
+      realpath: realpathRoot
+    };
+  } catch {
+    return null;
+  }
+}
+async function resolveLinkedCorpusRoots(projectRoot, globalRoot) {
+  const [projectContainmentRoot, globalContainmentRoot] = await Promise.all([
+    resolveContainmentRoot(projectRoot),
+    resolveContainmentRoot(globalRoot)
+  ]);
+  return {
+    projectContainmentRoot,
+    globalContainmentRoot
+  };
+}
+async function loadLinkedCorpus(document, roots) {
+  const linkedPaths = collectLinkedPaths(document.metadata);
+  const chunks = [];
+  for (const linkedPath of linkedPaths) {
+    const containmentRoot = linkedPath.scope === "global" ? roots.globalContainmentRoot : roots.projectContainmentRoot;
+    if (!containmentRoot) {
+      continue;
+    }
+    const resolved = path.resolve(containmentRoot.resolved, linkedPath.path);
+    if (!isPathWithinDirectory(containmentRoot.resolved, resolved)) {
+      continue;
+    }
+    let linkedRealpath;
+    try {
+      linkedRealpath = await fs.realpath(resolved);
+    } catch {
+      continue;
+    }
+    if (!isPathWithinDirectory(containmentRoot.realpath, linkedRealpath)) {
+      continue;
+    }
+    try {
+      await runActiveOnReadHooks({
+        path: resolved,
+        scope: linkedPath.scope
+      });
+      chunks.push(await fs.readFile(resolved, "utf8"));
+    } catch {
+    }
+  }
+  return chunks.join("\n");
+}
+var SEARCHABLE_FIELD_BUILDERS = [
+  { name: "title", weightKey: "title_weight", value: (document) => document.metadata.title },
+  { name: "description", weightKey: "description_weight", value: (document) => document.metadata.description },
+  { name: "tags", weightKey: "tags_weight", value: (document) => stringArray(document.metadata.tags).join(" ") },
+  {
+    name: "status",
+    weightKey: "status_weight",
+    value: (document) => typeof document.metadata.status === "string" ? document.metadata.status : ""
+  },
+  { name: "body", weightKey: "body_weight", value: (document) => document.body },
+  {
+    name: "comments",
+    weightKey: "comments_weight",
+    value: (document) => textEntries(document.metadata.comments).map((entry) => entry.text).join(" ")
+  },
+  {
+    name: "notes",
+    weightKey: "notes_weight",
+    value: (document) => textEntries(document.metadata.notes).map((entry) => entry.text).join(" ")
+  },
+  {
+    name: "learnings",
+    weightKey: "learnings_weight",
+    value: (document) => textEntries(document.metadata.learnings).map((entry) => entry.text).join(" ")
+  },
+  { name: "reminders", weightKey: "reminders_weight", value: (document) => buildReminderCorpus(document.metadata).join(" ") },
+  { name: "events", weightKey: "events_weight", value: (document) => buildEventCorpus(document.metadata).join(" ") },
+  {
+    name: "dependencies",
+    weightKey: "dependencies_weight",
+    value: (document) => dependencyEntries(document.metadata.dependencies).map((entry) => `${entry.id} ${entry.kind}`).join(" ")
+  },
+  { name: "plan", weightKey: "body_weight", value: (document) => buildPlanFlatCorpus(document.metadata) }
+];
+var SEARCHABLE_FIELD_BUILDER_BY_NAME = new Map(SEARCHABLE_FIELD_BUILDERS.map((builder) => [builder.name, builder]));
+function escapeRegExpLiteral(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function markTokenRuns(text, tokens) {
+  const escaped = tokens.filter((token) => token.length > 0).sort((left, right) => right.length - left.length).map(escapeRegExpLiteral);
+  if (escaped.length === 0) {
+    return text;
+  }
+  const pattern = new RegExp(escaped.join("|"), "gi");
+  return text.replace(pattern, (match) => `${HIGHLIGHT_OPEN}${match}${HIGHLIGHT_CLOSE}`);
+}
+function highlightFieldSnippet(text, tokens) {
+  if (text.length === 0) {
+    return null;
+  }
+  const lowerText = text.toLowerCase();
+  let firstMatchIndex = -1;
+  for (const token of tokens) {
+    if (token.length === 0) {
+      continue;
+    }
+    const index = lowerText.indexOf(token);
+    if (index >= 0 && (firstMatchIndex < 0 || index < firstMatchIndex)) {
+      firstMatchIndex = index;
+    }
+  }
+  if (firstMatchIndex < 0) {
+    return null;
+  }
+  const windowStart = Math.max(0, firstMatchIndex - HIGHLIGHT_SNIPPET_RADIUS);
+  const windowEnd = Math.min(text.length, firstMatchIndex + HIGHLIGHT_SNIPPET_RADIUS);
+  const marked = markTokenRuns(text.slice(windowStart, windowEnd), tokens);
+  const prefix = windowStart > 0 ? "\u2026" : "";
+  const suffix = windowEnd < text.length ? "\u2026" : "";
+  return `${prefix}${marked}${suffix}`;
+}
+function buildHitHighlights(document, matchedFields, tokens) {
+  const highlights = [];
+  for (const field of matchedFields) {
+    const builder = SEARCHABLE_FIELD_BUILDER_BY_NAME.get(field);
+    if (builder === void 0) {
+      continue;
+    }
+    const snippet = highlightFieldSnippet(builder.value(document), tokens);
+    if (snippet !== null) {
+      highlights.push({ field, snippet });
+    }
+  }
+  return highlights;
+}
+function buildSearchableScoringFields(document, linkedCorpus, tuning) {
+  return [
+    ...SEARCHABLE_FIELD_BUILDERS.map((builder) => ({
+      name: builder.name,
+      value: builder.value(document),
+      weight: tuning[builder.weightKey]
+    })),
+    { name: "linked_content", value: linkedCorpus, weight: tuning.linked_content_weight }
+  ];
+}
+function buildExactIdSearchHit(item, normalizedQuery, idPrefix) {
+  const normalizedId = normalizeSearchPhrase(item.id);
+  const normalizedIdPrefix = typeof idPrefix === "string" ? idPrefix.trim().toLowerCase() : "";
+  const normalizedIdPrefixPhrase = normalizeSearchPhrase(normalizedIdPrefix);
+  const normalizedShortId = normalizedIdPrefixPhrase.length > 0 && normalizedId.startsWith(normalizedIdPrefixPhrase) ? normalizedId.slice(normalizedIdPrefixPhrase.length).trim() : normalizedId;
+  if (normalizedQuery !== normalizedId && normalizedQuery !== normalizedShortId) {
+    return null;
+  }
+  return {
+    item,
+    score: normalizedQuery === normalizedId ? EXACT_ID_MATCH_SCORE : SHORT_ID_MATCH_SCORE,
+    matched_fields: ["id"],
+    matched_all_terms: true,
+    exact_id_match: true
+  };
+}
+function scoreTokenMatches(tokens, titleTokenCounts, searchableFields, tuning, state) {
+  for (const token of tokens) {
+    const exactTitleMatches = titleTokenCounts.get(token) ?? 0;
+    if (exactTitleMatches > 0) {
+      state.score += exactTitleMatches * tuning.title_exact_bonus;
+      state.matched.add("title");
+      state.matchedTokens.add(token);
+    }
+    for (const field of searchableFields) {
+      const occurrences = countOccurrences(field.value.toLowerCase(), token);
+      if (occurrences > 0) {
+        state.score += occurrences * field.weight;
+        state.matched.add(field.name);
+        state.matchedTokens.add(token);
+      }
+    }
+  }
+}
+function scorePhraseMatches(item, normalizedQuery, searchableFields, state) {
+  const normalizedTitle = normalizeSearchPhrase(item.title);
+  if (normalizedTitle === normalizedQuery) {
+    state.score += LONG_QUERY_TITLE_EXACT_BONUS;
+    state.matched.add("title");
+  }
+  for (const field of searchableFields) {
+    const phraseOccurrences = countOccurrences(normalizeSearchPhrase(field.value), normalizedQuery);
+    if (phraseOccurrences > 0) {
+      state.score += phraseOccurrences * field.weight * LONG_QUERY_PHRASE_MULTIPLIER;
+      state.matched.add(field.name);
+    }
+  }
+}
+function scoreDocument(document, tokens, normalizedQuery, linkedCorpus, tuning, idPrefix, applyCoverageBonus = false) {
+  const item = document.metadata;
+  const exactIdHit = buildExactIdSearchHit(item, normalizedQuery, idPrefix);
+  if (exactIdHit) {
+    return exactIdHit;
+  }
+  const titleTokenCounts = /* @__PURE__ */ new Map();
+  for (const token of tokenizeForExactTokenMatch(item.title)) {
+    titleTokenCounts.set(token, (titleTokenCounts.get(token) ?? 0) + 1);
+  }
+  const searchableFields = buildSearchableScoringFields(document, linkedCorpus, tuning);
+  const state = { score: 0, matched: /* @__PURE__ */ new Set(), matchedTokens: /* @__PURE__ */ new Set() };
+  scoreTokenMatches(tokens, titleTokenCounts, searchableFields, tuning, state);
+  const distinctTokens = new Set(tokens);
+  const matchedAllTerms = distinctTokens.size > 0 && state.matchedTokens.size === distinctTokens.size;
+  if (applyCoverageBonus && distinctTokens.size > 1 && matchedAllTerms) {
+    state.score += ALL_TERMS_COVERAGE_BONUS;
+  }
+  const isLongPhraseQuery = tokens.length >= LONG_QUERY_TOKEN_THRESHOLD && normalizedQuery.includes(" ");
+  if (isLongPhraseQuery) {
+    scorePhraseMatches(item, normalizedQuery, searchableFields, state);
+  }
+  if (state.score <= 0) {
+    return null;
+  }
+  return {
+    item,
+    score: state.score,
+    matched_fields: [...state.matched].sort((a, b) => a.localeCompare(b)),
+    matched_all_terms: matchedAllTerms
+  };
+}
+function sortHits(items, statusRegistry) {
+  return [...items].sort((a, b) => {
+    const byScore = b.score - a.score;
+    if (byScore !== 0)
+      return byScore;
+    const aTerminal = isTerminalStatus(a.item.status, statusRegistry);
+    const bTerminal = isTerminalStatus(b.item.status, statusRegistry);
+    if (aTerminal !== bTerminal) {
+      return aTerminal ? 1 : -1;
+    }
+    const byPriority = a.item.priority - b.item.priority;
+    if (byPriority !== 0)
+      return byPriority;
+    const byUpdated = compareTimestampStrings(b.item.updated_at, a.item.updated_at);
+    if (byUpdated !== 0)
+      return byUpdated;
+    return a.item.id.localeCompare(b.item.id);
+  });
+}
+function buildHybridLexicalScore(document, tokens, normalizedQuery, includeLinked, linkedCorpusById, tuning, idPrefix, applyCoverageBonus = false) {
+  return scoreDocument(document, tokens, normalizedQuery, includeLinked ? linkedCorpusById.get(document.metadata.id) ?? "" : "", tuning, idPrefix, applyCoverageBonus);
+}
+function normalizeScoreMap(scoreById) {
+  if (scoreById.size === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  const values = [...scoreById.values()];
+  const minScore = Math.min(...values);
+  const maxScore = Math.max(...values);
+  if (maxScore === minScore) {
+    return new Map([...scoreById.keys()].map((id) => [id, 1]));
+  }
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [id, score] of scoreById) {
+    normalized.set(id, (score - minScore) / (maxScore - minScore));
+  }
+  return normalized;
+}
+function resolveSearchMaxResults(settings) {
+  const candidate = settings.search?.max_results;
+  if (typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0) {
+    return Math.floor(candidate);
+  }
+  return 50;
+}
+function resolveSearchScoreThreshold(settings) {
+  const candidate = settings.search?.score_threshold;
+  if (typeof candidate === "number" && Number.isFinite(candidate)) {
+    return candidate;
+  }
+  return 0;
+}
+function resolveHybridSemanticWeight(settings) {
+  const candidate = settings.search?.hybrid_semantic_weight;
+  if (typeof candidate === "number" && Number.isFinite(candidate) && candidate >= 0 && candidate <= 1) {
+    return candidate;
+  }
+  return 0.7;
+}
+function resolveSearchTuning(settings) {
+  const defaults = {
+    title_exact_bonus: 10,
+    title_weight: 8,
+    description_weight: 5,
+    tags_weight: 6,
+    status_weight: 2,
+    body_weight: 1,
+    comments_weight: 1,
+    notes_weight: 1,
+    learnings_weight: 1,
+    reminders_weight: 2,
+    events_weight: 2,
+    dependencies_weight: 3,
+    linked_content_weight: 1
+  };
+  const tuning = settings.search?.tuning;
+  if (!tuning)
+    return defaults;
+  const resolveWeight = (candidate, fallback) => {
+    if (typeof candidate === "number" && Number.isFinite(candidate) && candidate >= 0) {
+      return candidate;
+    }
+    return fallback;
+  };
+  return {
+    title_exact_bonus: resolveWeight(tuning.title_exact_bonus, defaults.title_exact_bonus),
+    title_weight: resolveWeight(tuning.title_weight, defaults.title_weight),
+    description_weight: resolveWeight(tuning.description_weight, defaults.description_weight),
+    tags_weight: resolveWeight(tuning.tags_weight, defaults.tags_weight),
+    status_weight: resolveWeight(tuning.status_weight, defaults.status_weight),
+    body_weight: resolveWeight(tuning.body_weight, defaults.body_weight),
+    comments_weight: resolveWeight(tuning.comments_weight, defaults.comments_weight),
+    notes_weight: resolveWeight(tuning.notes_weight, defaults.notes_weight),
+    learnings_weight: resolveWeight(tuning.learnings_weight, defaults.learnings_weight),
+    reminders_weight: resolveWeight(tuning.reminders_weight, defaults.reminders_weight),
+    events_weight: resolveWeight(tuning.events_weight, defaults.events_weight),
+    dependencies_weight: resolveWeight(tuning.dependencies_weight, defaults.dependencies_weight),
+    linked_content_weight: resolveWeight(tuning.linked_content_weight, defaults.linked_content_weight)
+  };
+}
+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,
+      phraseExact: options.phraseExact === true,
+      scoreThreshold,
+      hybridSemanticWeight,
+      runtimeFieldFilters
+    });
+    return {
+      query: query.trim(),
+      mode,
+      items: [],
+      count: 0,
+      ...countExtras,
+      filters: compactFilters,
+      ...warnings.length > 0 ? { warnings } : {}
+    };
+  }
+  const projectionFields = projection.mode === "full" ? null : [...projection.fields];
+  return {
+    query: query.trim(),
+    mode,
+    items: [],
+    count: 0,
+    ...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
+    },
+    now: nowIso(),
+    ...warnings.length > 0 ? { warnings } : {}
+  };
+}
+function requireSemanticDependencies(requestedMode, providerResolution, vectorResolution, hasExtensionVectorQuery) {
+  if (!providerResolution.active) {
+    throw new PmCliError(`Search mode '${requestedMode}' requires a configured embedding provider in settings.providers.openai or settings.providers.ollama`, EXIT_CODE.USAGE);
+  }
+  if (!vectorResolution.active && !hasExtensionVectorQuery) {
+    throw new PmCliError(`Search mode '${requestedMode}' requires a configured vector store in settings.vector_store.qdrant/settings.vector_store.lancedb or an extension adapter selected by settings.vector_store.adapter`, EXIT_CODE.USAGE);
+  }
+  return {
+    provider: providerResolution.active,
+    vectorStore: vectorResolution.active ?? null
+  };
+}
+var toOptionalNonEmptyString = toNonEmptyStringOrUndefined;
+function resolveExtensionSearchProviderByName(providerName) {
+  const registrations = getActiveExtensionRegistrations();
+  const resolved = resolveRegisteredSearchProvider(registrations, providerName);
+  if (!resolved) {
+    return null;
+  }
+  const runtimeDefinition = resolved.runtime_definition ?? resolved.definition;
+  const query = runtimeDefinition.query;
+  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;
+  }
+  const hooks = {
+    providerName: registeredName,
+    ...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) {
+  const registrations = getActiveExtensionRegistrations();
+  const adapterName = toOptionalNonEmptyString(settings.vector_store?.adapter);
+  const resolved = resolveRegisteredVectorStoreAdapter(registrations, adapterName);
+  if (!resolved) {
+    return null;
+  }
+  const runtimeDefinition = resolved.runtime_definition ?? resolved.definition;
+  const query = runtimeDefinition.query;
+  if (typeof query !== "function") {
+    return null;
+  }
+  const upsert = runtimeDefinition.upsert;
+  const runtimeAdapterName = toOptionalNonEmptyString(runtimeDefinition.name) ?? toOptionalNonEmptyString(resolved.definition.name) ?? adapterName ?? "extension";
+  return {
+    adapterName: runtimeAdapterName,
+    query,
+    ...typeof upsert === "function" ? { upsert } : {}
+  };
+}
+function normalizeExtensionProviderHits(providerName, raw, filteredById) {
+  const rawHits = Array.isArray(raw) ? raw : raw?.hits;
+  if (!Array.isArray(rawHits)) {
+    throw new PmCliError(`Extension search provider "${providerName}" must return an array of hits or { hits: [...] }`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const hits = [];
+  for (const rawHit of rawHits) {
+    if (typeof rawHit !== "object" || rawHit === null) {
+      continue;
+    }
+    const id = toOptionalNonEmptyString(rawHit.id);
+    const score = rawHit.score;
+    if (!id || typeof score !== "number" || !Number.isFinite(score) || seen.has(id)) {
+      continue;
+    }
+    const document = filteredById.get(id);
+    if (!document) {
+      continue;
+    }
+    const matchedFieldsRaw = rawHit.matched_fields;
+    const matchedFields = Array.isArray(matchedFieldsRaw) && matchedFieldsRaw.every((entry) => typeof entry === "string") ? [...new Set(matchedFieldsRaw.map((entry) => entry.trim()).filter((entry) => entry.length > 0))].sort((a, b) => a.localeCompare(b)) : [`provider:${providerName}`];
+    seen.add(id);
+    hits.push({
+      item: document.metadata,
+      score,
+      matched_fields: matchedFields
+    });
+  }
+  return hits;
+}
+function buildSemanticHits(vectorHits, filteredById) {
+  const semanticHits = [];
+  const semanticScores = /* @__PURE__ */ new Map();
+  for (const vectorHit of vectorHits) {
+    if (semanticScores.has(vectorHit.id)) {
+      continue;
+    }
+    const document = filteredById.get(vectorHit.id);
+    if (!document) {
+      continue;
+    }
+    semanticScores.set(vectorHit.id, vectorHit.score);
+    semanticHits.push({
+      item: document.metadata,
+      score: vectorHit.score,
+      matched_fields: ["semantic"]
+    });
+  }
+  return {
+    semanticHits,
+    semanticScores
+  };
+}
+function forceExactIdHitsToTop(rankedHits, keywordHits) {
+  const exactIdHits = keywordHits.filter((hit) => hit.exact_id_match === true);
+  if (exactIdHits.length === 0) {
+    return rankedHits;
+  }
+  const exactIdIds = new Set(exactIdHits.map((hit) => hit.item.id));
+  const remaining = rankedHits.filter((hit) => !exactIdIds.has(hit.item.id));
+  const maxRemainingScore = remaining.reduce((max, hit) => Math.max(max, hit.score), 0);
+  const orderedExactHits = exactIdHits.sort((left, right) => right.score - left.score);
+  const bandBase = maxRemainingScore + orderedExactHits.length + 1;
+  const promoted = orderedExactHits.map((hit, index) => ({
+    // Spread the original keyword hit so flags like matched_all_terms /
+    // exact_id_match are preserved; only the band-slot score and the id-only
+    // matched_fields are overridden.
+    ...hit,
+    // Higher band slot for earlier (higher original keyword score) hits.
+    score: bandBase - index,
+    matched_fields: ["id"]
+  }));
+  return [...promoted, ...remaining];
+}
+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);
+  const normalizedKeyword = normalizeScoreMap(keywordScores);
+  const candidateIds = /* @__PURE__ */ new Set([...semanticScores.keys(), ...keywordScores.keys()]);
+  const keywordWeight = 1 - hybridSemanticWeight;
+  return [...candidateIds].map((id) => {
+    const document = filteredById.get(id);
+    const semanticScore = normalizedSemantic.get(id) ?? 0;
+    const keywordScore = normalizedKeyword.get(id) ?? 0;
+    const combinedScore = semanticScore * hybridSemanticWeight + keywordScore * keywordWeight;
+    if (combinedScore <= 0) {
+      return null;
+    }
+    const matchedFields = /* @__PURE__ */ new Set();
+    if (semanticScores.has(id)) {
+      matchedFields.add(semanticFieldLabel);
+    }
+    for (const field of keywordMatches.get(id) ?? []) {
+      matchedFields.add(field);
+    }
+    return {
+      item: document.metadata,
+      score: combinedScore,
+      matched_fields: [...matchedFields].sort((a, b) => a.localeCompare(b))
+    };
+  }).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) {
+    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 resolveExpandedSemanticQueries(context, queryTrimmed) {
+  const baseExpandedQueries = context.queryExpansion.enabled ? buildDeterministicQueryExpansions(queryTrimmed, context.queryExpansion.max_queries) : [queryTrimmed];
+  const expandedQueries = baseExpandedQueries.length > 0 ? baseExpandedQueries : [queryTrimmed];
+  if (!context.queryExpansion.enabled) {
+    return expandedQueries;
+  }
+  if (context.queryExpansionExtension?.expand) {
+    try {
+      const rawExpansion = await Promise.resolve(context.queryExpansionExtension.expand({
+        query: queryTrimmed,
+        mode: context.requestedMode,
+        settings: context.settings
+      }));
+      return mergeQueryExpansions(expandedQueries, normalizeQueryExpansionOutput(rawExpansion), context.queryExpansion.max_queries);
+    } catch {
+      context.warnings.push(`search_query_expansion_provider_failed:${context.queryExpansionExtension.providerName}:using_builtin`);
+      return expandedQueries;
+    }
+  }
+  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`);
+  }
+  return expandedQueries;
+}
+async function executeSemanticVectorQuery(context, semanticVector, semanticLimit, vectorQueryOptions) {
+  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);
+      }
+      context.warnings.push(`search_vector_adapter_failed:${context.extensionVectorAdapter.adapterName}:using_builtin`);
+      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);
+}
+function buildRerankCandidateContexts(hybridHits, filteredById, topK) {
+  const sortedForCandidates = [...hybridHits].sort((left, right) => {
+    if (left.score !== right.score) {
+      return right.score - left.score;
+    }
+    return left.item.id.localeCompare(right.item.id);
+  });
+  return sortedForCandidates.slice(0, topK).map((hit) => {
+    const document = filteredById.get(hit.item.id);
+    return document ? { hit, text: buildRerankCorpus(document) } : null;
+  }).filter((entry) => entry !== null);
+}
+async function resolveExtensionRerankScores(context, queryTrimmed, candidateContexts) {
+  if (!context.rerankExtension?.rerank) {
+    return null;
+  }
+  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) {
+      return new Map(normalizedRerank.map((entry) => [entry.id, entry.score]));
+    }
+    context.warnings.push(`search_rerank_provider_invalid_response:${context.rerankExtension.providerName}:using_builtin`);
+    return null;
+  } catch {
+    context.warnings.push(`search_rerank_provider_failed:${context.rerankExtension.providerName}:using_builtin`);
+    return null;
+  }
+}
+async function resolveRerankScores(context, queryTrimmed, candidateContexts) {
+  const extensionScores = await resolveExtensionRerankScores(context, queryTrimmed, candidateContexts);
+  if (extensionScores) {
+    return extensionScores;
+  }
+  const rerankCandidates = candidateContexts.map((entry) => ({
+    id: entry.hit.item.id,
+    text: entry.text
+  }));
+  try {
+    return await rerankCandidatesWithEmbeddings(context.provider, context.rerank.model, queryTrimmed, rerankCandidates, context.embeddingTimeoutMs);
+  } catch {
+    context.warnings.push("search_rerank_failed:using_hybrid_scores");
+    return null;
+  }
+}
+function applyRerankScores(hybridHits, rerankScores) {
+  const rerankedIds = new Set(rerankScores.keys());
+  const rerankedHits = 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))
+    };
+  });
+  rerankedHits.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 rerankedHits;
+}
+async function applyHybridRerank(context, queryTrimmed, hybridHits, filteredById) {
+  if (!context.rerank.enabled || hybridHits.length <= 1) {
+    return hybridHits;
+  }
+  const candidateContexts = buildRerankCandidateContexts(hybridHits, filteredById, context.rerank.top_k);
+  const rerankScores = await resolveRerankScores(context, queryTrimmed, candidateContexts);
+  return rerankScores && rerankScores.size > 0 ? applyRerankScores(hybridHits, rerankScores) : hybridHits;
+}
+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 queryTrimmed = context.query.trim();
+  const expandedQueries = await resolveExpandedSemanticQueries(context, queryTrimmed);
+  const queryVectors = await executeEmbeddingRequest(context.provider, expandedQueries, embeddingOptions);
+  const queryVectorGroups = await Promise.all(queryVectors.map(async (semanticVector) => await executeSemanticVectorQuery(context, semanticVector, semanticLimit, vectorQueryOptions)));
+  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: forceExactIdHitsToTop(semanticHits, context.keywordHits), vectorMatchCount };
+  }
+  const hybridHits = await applyHybridRerank(context, queryTrimmed, combineHybridHits(filteredById, semanticScores, context.keywordHits, context.hybridSemanticWeight), filteredById);
+  return {
+    // GH-281: applied LAST (after any rerank reordering) so an exact full-ID /
+    // short-ID keyword match always ranks #1 in hybrid mode regardless of the
+    // semantic blend weight or rerank scores.
+    hits: forceExactIdHitsToTop(hybridHits, context.keywordHits),
+    vectorMatchCount
+  };
+}
+async function loadDocuments(pmRoot, itemFormat, typeToFolder, schema) {
+  const extensionFieldNames = collectRegisteredItemFieldNames(getActiveExtensionRegistrations());
+  const readDocumentBody = async (metadata, preferredPath, preferredFormat) => {
+    const tryRead = async (targetPath, format) => {
+      await runActiveOnReadHooks({ path: targetPath, scope: "project" });
+      const raw = await fs.readFile(targetPath, "utf8");
+      const parsed = parseItemDocument(raw, {
+        format,
+        schema,
+        extensionFieldNames,
+        onWarning: (warning) => listWarnings.push(warning)
+      });
+      return parsed.body;
+    };
+    try {
+      return await tryRead(preferredPath, preferredFormat);
+    } catch {
+      const alternateFormat = preferredFormat === "toon" ? "json_markdown" : "toon";
+      const alternatePath = getItemPath(pmRoot, metadata.type, metadata.id, alternateFormat, typeToFolder);
+      try {
+        return await tryRead(alternatePath, alternateFormat);
+      } catch {
+        listWarnings.push(`item_list_item_read_failed:${path.relative(pmRoot, alternatePath)}`);
+        return "";
+      }
+    }
+  };
+  const listWarnings = [];
+  const cachedDocuments = await listAllDocumentCandidatesCached(pmRoot, itemFormat, typeToFolder, listWarnings, schema);
+  const documents = [];
+  if (cachedDocuments.length === 0) {
+    const frontMatterDocuments = await listAllFrontMatter(pmRoot, itemFormat, typeToFolder, listWarnings, schema);
+    for (const metadata of frontMatterDocuments) {
+      const preferredPath = getItemPath(pmRoot, metadata.type, metadata.id, itemFormat, typeToFolder);
+      const body = await readDocumentBody(metadata, preferredPath, itemFormat);
+      documents.push({ metadata, body });
+    }
+    return {
+      documents,
+      warnings: [...new Set(listWarnings)].sort((left, right) => left.localeCompare(right))
+    };
+  }
+  for (const cachedDocument of cachedDocuments) {
+    if (typeof cachedDocument.body === "string") {
+      documents.push({
+        metadata: cachedDocument.metadata,
+        body: cachedDocument.body
+      });
+      continue;
+    }
+    const body = await readDocumentBody(cachedDocument.metadata, cachedDocument.item_path, cachedDocument.item_format);
+    documents.push({
+      metadata: cachedDocument.metadata,
+      body
+    });
+  }
+  return {
+    documents,
+    warnings: [...new Set(listWarnings)].sort((left, right) => left.localeCompare(right))
+  };
+}
+function readSearchFieldValue(hit, field) {
+  const normalized = field.trim();
+  if (normalized.length === 0) {
+    return null;
+  }
+  if (normalized === "score") {
+    return hit.score;
+  }
+  if (normalized === "matched_fields") {
+    return hit.matched_fields;
+  }
+  if (normalized.startsWith("item.")) {
+    const itemKey = normalized.slice("item.".length);
+    if (itemKey.length === 0) {
+      return null;
+    }
+    const itemRecord2 = toItemRecord(hit.item);
+    return itemRecord2[itemKey] ?? null;
+  }
+  const hitRecord = hit;
+  const itemRecord = toItemRecord(hit.item);
+  if (Object.prototype.hasOwnProperty.call(itemRecord, normalized)) {
+    return itemRecord[normalized] ?? null;
+  }
+  if (Object.prototype.hasOwnProperty.call(hitRecord, normalized)) {
+    return hitRecord[normalized] ?? null;
+  }
+  return null;
+}
+function projectSearchHits(hits, projection) {
+  if (projection.mode === "full") {
+    return hits.map(({ matched_all_terms: _matchedAllTerms, ...hit }) => hit);
+  }
+  return hits.map((hit) => {
+    const projected = {};
+    for (const field of projection.fields) {
+      projected[field] = readSearchFieldValue(hit, field);
+    }
+    return projected;
+  });
+}
+function resolveQueryExpansionExtension(queryExpansion) {
+  const provider = resolveExtensionSearchProviderByName(queryExpansion.provider ?? void 0);
+  return provider?.queryExpansion ? { providerName: provider.providerName, expand: provider.queryExpansion } : null;
+}
+function resolveRerankExtension(settings) {
+  const provider = resolveExtensionSearchProviderByName(toOptionalNonEmptyString(settings.search?.provider));
+  return provider?.rerank ? { providerName: provider.providerName, rerank: provider.rerank } : null;
+}
+function prepareSearchInput(rawQuery, rawOptions) {
+  const inlineWarnings = [];
+  const inlineParse = parseInlineQueryFilters(rawQuery);
+  const hasInlineFilters = Object.keys(inlineParse.inlineFilters).length > 0;
+  if (hasInlineFilters && inlineParse.residualQuery.trim().length === 0) {
+    throw new PmCliError("Inline field:value tokens consumed the entire query, leaving no search terms.", EXIT_CODE.USAGE, {
+      examples: ["pm search auth tag:area:search", "pm list --tag area:search --status open"],
+      nextSteps: [
+        "Add keyword terms alongside the inline filters, or use pm list for pure tag/status/type/priority filtering."
+      ]
+    });
+  }
+  const query = hasInlineFilters ? inlineParse.residualQuery : rawQuery;
+  const options = applyInlineQueryFilters(rawOptions, inlineParse.inlineFilters, inlineWarnings);
+  return {
+    query,
+    options,
+    inlineWarnings,
+    highlight: options.highlight === true,
+    includeLinked: parseIncludeLinked(options.includeLinked),
+    titleExact: parseTitleExact(options.titleExact),
+    phraseExact: parsePhraseExact(options.phraseExact),
+    matchMode: parseMatchMode(typeof options.matchMode === "string" ? options.matchMode : void 0),
+    minScoreOverride: parseMinScoreOverride(options.minScore),
+    countOnly: options.count === true,
+    tokens: parseTokens(query),
+    normalizedQuery: normalizeSearchPhrase(query),
+    limit: parseLimit(options.limit),
+    projection: parseProjectionConfig(options),
+    modeWasExplicit: typeof options.mode === "string" && options.mode.trim().length > 0
+  };
+}
+async function resolveSearchRuntimeContext(prepared, global) {
+  const pmRoot = resolvePmRoot(process.cwd(), global.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+  const storedSettings = await readSettings(pmRoot);
+  const settings = resolveSettingsWithSemanticRuntimeDefaults(storedSettings).settings;
+  const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
+  const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
+  validateSearchProjectionFields(prepared.projection, runtimeFieldRegistry);
+  const runtimeFieldFilters = collectRuntimeFilterValues(prepared.options, runtimeFieldRegistry, "search");
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const providerResolution = resolveEmbeddingProviders(settings);
+  const vectorResolution = resolveVectorStores(settings);
+  const extensionSearchProvider = resolveExtensionSearchProvider(settings);
+  const extensionVectorAdapter = resolveExtensionVectorAdapter(settings);
+  const semanticWeightOverride = parseSemanticWeightOverride(prepared.options.semanticWeight);
+  const queryExpansion = resolveQueryExpansionConfig(settings, providerResolution.active?.name ?? null);
+  const rerank = resolveRerankConfig(settings, providerResolution.active?.model ?? toOptionalNonEmptyString(settings.search?.embedding_model) ?? "text-embedding-3-small");
+  return {
+    pmRoot,
+    settings,
+    statusRegistry,
+    runtimeFieldRegistry,
+    runtimeFieldFilters,
+    typeRegistry,
+    maxResults: resolveSearchMaxResults(settings),
+    scoreThreshold: prepared.minScoreOverride ?? resolveSearchScoreThreshold(settings),
+    semanticWeightProvided: prepared.options.semanticWeight !== void 0,
+    semanticWeightOverride,
+    hybridSemanticWeight: semanticWeightOverride ?? resolveHybridSemanticWeight(settings),
+    tuning: resolveSearchTuning(settings),
+    providerResolution,
+    vectorResolution,
+    extensionSearchProvider,
+    extensionVectorAdapter,
+    bm25Mode: resolveBuiltInBm25Mode({
+      configuredProvider: toOptionalNonEmptyString(settings.search?.provider),
+      hasEmbeddingProvider: providerResolution.active !== null,
+      hasExtensionSearchProvider: extensionSearchProvider !== null
+    }),
+    queryExpansion,
+    queryExpansionExtension: resolveQueryExpansionExtension(queryExpansion),
+    rerank,
+    rerankExtension: resolveRerankExtension(settings),
+    effectiveMode: parseMode(prepared.options.mode, {
+      hasProvider: providerResolution.active !== null || extensionSearchProvider !== null,
+      hasVectorStore: vectorResolution.active !== null || extensionVectorAdapter !== null
+    })
+  };
+}
+async function loadFilteredSearchCorpus(prepared, runtime) {
+  const loadedDocuments = await loadDocuments(runtime.pmRoot, runtime.settings.item_format ?? "toon", runtime.typeRegistry.type_to_folder, runtime.settings.schema);
+  const statusFilter = parseStatusFilterCsv(typeof prepared.options.status === "string" ? prepared.options.status : void 0, runtime.statusRegistry, { strict: true });
+  const lifecycleClassifier = lifecycleClassifierFromStatusRegistry(runtime.statusRegistry);
+  const metadataFilteredDocuments = applyFilters(loadedDocuments.documents, prepared.options, runtime.typeRegistry, runtime.runtimeFieldFilters, statusFilter, lifecycleClassifier);
+  return {
+    warnings: loadedDocuments.warnings,
+    allDocuments: loadedDocuments.documents,
+    filteredDocuments: applyExactQueryFilters(metadataFilteredDocuments, prepared.normalizedQuery, {
+      titleExact: prepared.titleExact,
+      phraseExact: prepared.phraseExact || prepared.matchMode === "exact"
+    })
+  };
+}
+async function collectLinkedCorpusById(includeLinked, effectiveMode, filteredDocuments) {
+  const linkedCorpusById = /* @__PURE__ */ new Map();
+  if (!includeLinked || effectiveMode !== "keyword" && effectiveMode !== "hybrid") {
+    return linkedCorpusById;
+  }
+  const projectRoot = process.cwd();
+  const linkedCorpusRoots = await resolveLinkedCorpusRoots(projectRoot, resolveGlobalPmRoot(projectRoot));
+  const linkedCorpusEntries = await Promise.all(filteredDocuments.map(async (document) => [document.metadata.id, await loadLinkedCorpus(document, linkedCorpusRoots)]));
+  for (const [id, corpus] of linkedCorpusEntries) {
+    linkedCorpusById.set(id, corpus);
+  }
+  return linkedCorpusById;
+}
+async function computeKeywordSearchHits(prepared, runtime, filteredDocuments) {
+  const linkedCorpusById = await collectLinkedCorpusById(prepared.includeLinked, runtime.effectiveMode, filteredDocuments);
+  const applyCoverageBonus = prepared.matchMode === "or";
+  return filteredDocuments.map((document) => buildHybridLexicalScore(document, prepared.tokens, prepared.normalizedQuery, prepared.includeLinked, linkedCorpusById, runtime.tuning, runtime.settings.id_prefix, applyCoverageBonus)).filter((entry) => entry !== null).filter((entry) => prepared.matchMode !== "and" || entry.matched_all_terms === true);
+}
+function buildEmptySearchResultFromContext(response, countOnly) {
+  return emptySearchResult(response.query, response.effectiveMode, response.matchMode, response.options, response.includeLinked, response.scoreThreshold, response.hybridSemanticWeight, response.queryExpansion, response.rerank, response.projection, response.warnings, response.runtimeFieldFilters, countOnly);
+}
+async function executeBuiltInBm25Search(prepared, runtime, filteredDocuments, keywordHits, warnings) {
+  if (runtime.bm25Mode === null || runtime.effectiveMode === "keyword") {
+    return null;
+  }
+  const hits = computeBuiltInBm25Hits({
+    requestedMode: runtime.effectiveMode,
+    query: prepared.query,
+    filteredDocuments,
+    keywordHits,
+    corpusFields: resolveSearchCorpusFields(runtime.settings),
+    bm25Params: resolveBm25Params(runtime.settings),
+    hybridSemanticWeight: runtime.hybridSemanticWeight
+  });
+  if (runtime.bm25Mode === "auto-fallback") {
+    warnings.push(`search_${runtime.effectiveMode}_offline_bm25:no_embedding_provider:using_lexical_bm25`);
+  }
+  return hits;
+}
+async function executeExtensionSearchProvider(prepared, runtime, filteredDocuments, filteredById) {
+  if (!runtime.extensionSearchProvider) {
+    return null;
+  }
+  const canUseBuiltInSemantic = runtime.providerResolution.active !== null && (runtime.vectorResolution.active !== null || runtime.extensionVectorAdapter !== null);
+  try {
+    const providerResponse = await Promise.resolve(runtime.extensionSearchProvider.query({
+      query: prepared.query,
+      mode: runtime.effectiveMode,
+      tokens: prepared.tokens,
+      options: prepared.options,
+      settings: runtime.settings,
+      documents: filteredDocuments
+    }));
+    return normalizeExtensionProviderHits(runtime.extensionSearchProvider.providerName, providerResponse, filteredById);
+  } catch (error) {
+    if (!canUseBuiltInSemantic) {
+      throw new PmCliError(`Extension search provider "${runtime.extensionSearchProvider.providerName}" failed: ${error instanceof Error ? error.message : String(error)}`, EXIT_CODE.GENERIC_FAILURE);
+    }
+    return null;
+  }
+}
+function maybeApplyNoVectorFallback(effectiveMode, semanticResult, keywordHits, warnings) {
+  if (semanticResult.vectorMatchCount > 0) {
+    return semanticResult.hits;
+  }
+  warnings.push(`search_${effectiveMode}_degraded:no_vector_matches:results_are_lexical`);
+  return effectiveMode === "semantic" ? keywordHits : semanticResult.hits;
+}
+async function prepareBuiltInSemanticSearch(runtime, effectiveMode, filteredDocuments, warnings, modeWasExplicit) {
+  const builtInSemanticWillRun = !runtime.extensionSearchProvider && runtime.providerResolution.active !== null && (runtime.vectorResolution.active !== null || runtime.extensionVectorAdapter !== null);
+  if (modeWasExplicit && builtInSemanticWillRun) {
+    await maybeEmitVectorIndexStaleWarning(runtime.pmRoot, filteredDocuments, warnings);
+  }
+  if (!runtime.extensionSearchProvider) {
+    requireSemanticDependencies(effectiveMode, runtime.providerResolution, runtime.vectorResolution, runtime.extensionVectorAdapter !== null);
+  }
+}
+async function executeSemanticSearch(input) {
+  const { prepared, runtime, filteredDocuments, keywordHits, warnings, modeWasExplicit } = input;
+  let hits = keywordHits;
+  const bm25Hits = await executeBuiltInBm25Search(prepared, runtime, filteredDocuments, keywordHits, warnings);
+  const semanticMode = runtime.effectiveMode;
+  if (bm25Hits !== null || semanticMode === "keyword") {
+    return { effectiveMode: runtime.effectiveMode, hits: bm25Hits ?? hits };
+  }
+  try {
+    await prepareBuiltInSemanticSearch(runtime, semanticMode, filteredDocuments, warnings, modeWasExplicit);
+    if (filteredDocuments.length === 0 || prepared.limit === 0) {
+      return { effectiveMode: runtime.effectiveMode, hits: [] };
+    }
+    const filteredById = new Map(filteredDocuments.map((document) => [document.metadata.id, document]));
+    hits = await executeExtensionSearchProvider(prepared, runtime, filteredDocuments, filteredById) ?? hits;
+    if (hits === keywordHits) {
+      const { provider, vectorStore } = requireSemanticDependencies(semanticMode, runtime.providerResolution, runtime.vectorResolution, runtime.extensionVectorAdapter !== null);
+      const semanticResult = await computeSemanticOrHybridHits({
+        requestedMode: semanticMode,
+        query: prepared.query,
+        filteredDocuments,
+        keywordHits,
+        hybridSemanticWeight: runtime.hybridSemanticWeight,
+        limit: prepared.limit,
+        maxResults: runtime.maxResults,
+        provider,
+        vectorStore,
+        extensionVectorAdapter: runtime.extensionVectorAdapter,
+        queryExpansion: runtime.queryExpansion,
+        queryExpansionExtension: runtime.queryExpansionExtension,
+        rerank: runtime.rerank,
+        rerankExtension: runtime.rerankExtension,
+        warnings,
+        settings: runtime.settings
+      });
+      hits = maybeApplyNoVectorFallback(semanticMode, semanticResult, keywordHits, warnings);
+    }
+    return { effectiveMode: runtime.effectiveMode, hits };
+  } catch (error) {
+    warnings.push(buildExplicitSemanticFallbackWarning(runtime.effectiveMode, error));
+    return { effectiveMode: "keyword", hits: keywordHits };
+  }
+}
+function buildCountOnlySearchResult(response, total) {
+  if (response.projection.mode === "compact" && response.options.compact === true) {
+    return withSearchWarnings({
+      query: response.query.trim(),
+      mode: response.effectiveMode,
+      items: [],
+      count: total,
+      total,
+      count_only: true,
+      filters: buildCompactSearchFilterSummary({
+        mode: response.effectiveMode,
+        matchMode: response.matchMode,
+        options: response.options,
+        includeLinked: response.includeLinked,
+        titleExact: response.titleExact,
+        phraseExact: response.phraseExact,
+        scoreThreshold: response.scoreThreshold,
+        hybridSemanticWeight: response.hybridSemanticWeight,
+        runtimeFieldFilters: response.runtimeFieldFilters
+      })
+    }, response.warnings);
+  }
+  const projectionFields = response.projection.mode === "full" ? null : [...response.projection.fields];
+  return withSearchWarnings({
+    query: response.query.trim(),
+    mode: response.effectiveMode,
+    items: [],
+    count: total,
+    total,
+    count_only: true,
+    filters: buildVerboseSearchFilters({
+      effectiveMode: response.effectiveMode,
+      matchMode: response.matchMode,
+      options: response.options,
+      includeLinked: response.includeLinked,
+      titleExact: response.titleExact,
+      phraseExact: response.phraseExact,
+      scoreThreshold: response.scoreThreshold,
+      hybridSemanticWeight: response.hybridSemanticWeight,
+      queryExpansion: response.queryExpansion,
+      rerank: response.rerank,
+      runtimeFieldFilters: response.runtimeFieldFilters
+    }),
+    projection: {
+      mode: response.projection.mode,
+      fields: projectionFields
+    },
+    now: nowIso()
+  }, response.warnings);
+}
+function withSearchWarnings(result, warnings) {
+  if (warnings.length === 0) {
+    return result;
+  }
+  return { ...result, warnings };
+}
+function attachSearchHighlights(prepared, filteredDocuments, limited) {
+  if (!prepared.highlight) {
+    return { hits: limited, projection: prepared.projection };
+  }
+  const documentById = new Map(filteredDocuments.map((document) => [document.metadata.id, document]));
+  const hits = limited.map((hit) => ({
+    ...hit,
+    highlights: buildHitHighlights(documentById.get(hit.item.id), hit.matched_fields, prepared.tokens)
+  }));
+  if (prepared.projection.mode === "full" || prepared.projection.fields.includes("highlights")) {
+    return { hits, projection: prepared.projection };
+  }
+  return { hits, projection: { mode: prepared.projection.mode, fields: [...prepared.projection.fields, "highlights"] } };
+}
+function buildSearchResultForHits(response, projectedItems, total, limitedCount, effectiveProjection) {
+  const truncationExtras = limitedCount < total ? { total } : {};
+  if (response.projection.mode === "compact" && response.options.compact === true) {
+    return withSearchWarnings({
+      query: response.query.trim(),
+      mode: response.effectiveMode,
+      items: projectedItems,
+      count: projectedItems.length,
+      ...truncationExtras,
+      filters: buildCompactSearchFilterSummary({
+        mode: response.effectiveMode,
+        matchMode: response.matchMode,
+        options: response.options,
+        includeLinked: response.includeLinked,
+        titleExact: response.titleExact,
+        phraseExact: response.phraseExact,
+        scoreThreshold: response.scoreThreshold,
+        hybridSemanticWeight: response.hybridSemanticWeight,
+        runtimeFieldFilters: response.runtimeFieldFilters
+      })
+    }, response.warnings);
+  }
+  const finalProjectionFields = effectiveProjection.mode === "full" ? null : [...effectiveProjection.fields];
+  return {
+    query: response.query.trim(),
+    mode: response.effectiveMode,
+    items: projectedItems,
+    count: projectedItems.length,
+    ...truncationExtras,
+    filters: buildVerboseSearchFilters({
+      effectiveMode: response.effectiveMode,
+      matchMode: response.matchMode,
+      options: response.options,
+      includeLinked: response.includeLinked,
+      titleExact: response.titleExact,
+      phraseExact: response.phraseExact,
+      scoreThreshold: response.scoreThreshold,
+      hybridSemanticWeight: response.hybridSemanticWeight,
+      queryExpansion: response.queryExpansion,
+      rerank: response.rerank,
+      runtimeFieldFilters: response.runtimeFieldFilters
+    }),
+    projection: {
+      mode: effectiveProjection.mode,
+      fields: finalProjectionFields
+    },
+    now: nowIso(),
+    ...response.warnings.length > 0 ? { warnings: response.warnings } : {}
+  };
+}
+async function runSearch(rawQuery, rawOptions, global) {
+  const prepared = prepareSearchInput(rawQuery, rawOptions);
+  const runtime = await resolveSearchRuntimeContext(prepared, global);
+  const corpus = await loadFilteredSearchCorpus(prepared, runtime);
+  const warnings = corpus.warnings;
+  warnings.push(...prepared.inlineWarnings);
+  if (runtime.effectiveMode === "hybrid" && runtime.semanticWeightProvided && runtime.semanticWeightOverride === void 0) {
+    warnings.push("search_hybrid_semantic_weight_override_invalid:using_settings_default");
+  }
+  const responseBase = {
+    query: prepared.query,
+    matchMode: prepared.matchMode,
+    options: prepared.options,
+    includeLinked: prepared.includeLinked,
+    titleExact: prepared.titleExact,
+    phraseExact: prepared.phraseExact,
+    scoreThreshold: runtime.scoreThreshold,
+    hybridSemanticWeight: runtime.hybridSemanticWeight,
+    queryExpansion: runtime.queryExpansion,
+    rerank: runtime.rerank,
+    projection: prepared.projection,
+    warnings,
+    runtimeFieldFilters: runtime.runtimeFieldFilters
+  };
+  if (runtime.effectiveMode === "keyword" && (corpus.filteredDocuments.length === 0 || prepared.limit === 0)) {
+    return buildEmptySearchResultFromContext({ ...responseBase, effectiveMode: runtime.effectiveMode }, prepared.countOnly);
+  }
+  const keywordHits = await computeKeywordSearchHits(prepared, runtime, corpus.filteredDocuments);
+  const modeResult = await executeSemanticSearch({
+    prepared,
+    runtime,
+    filteredDocuments: corpus.filteredDocuments,
+    keywordHits,
+    warnings,
+    modeWasExplicit: prepared.modeWasExplicit
+  });
+  if (modeResult.effectiveMode !== "keyword" && modeResult.hits.length === 0 && (corpus.filteredDocuments.length === 0 || prepared.limit === 0)) {
+    return buildEmptySearchResultFromContext({ ...responseBase, effectiveMode: modeResult.effectiveMode }, prepared.countOnly);
+  }
+  const thresholded = modeResult.hits.filter((entry) => entry.exact_id_match === true || entry.score >= runtime.scoreThreshold);
+  const sorted = sortHits(thresholded, runtime.statusRegistry);
+  const total = sorted.length;
+  const resolvedLimit = prepared.limit ?? runtime.maxResults;
+  const limited = sorted.slice(0, resolvedLimit);
+  const response = { ...responseBase, effectiveMode: modeResult.effectiveMode };
+  if (prepared.countOnly) {
+    return buildCountOnlySearchResult(response, total);
+  }
+  const { hits: projectedHits, projection: effectiveProjection } = attachSearchHighlights(prepared, corpus.filteredDocuments, limited);
+  const projectedItems = projectSearchHits(projectedHits, effectiveProjection);
+  return buildSearchResultForHits(response, projectedItems, total, limited.length, effectiveProjection);
+}
+
+export {
+  normalizeLowercaseWhitespace,
+  tokenizeAlphaNumeric,
+  jaccardSimilarity,
+  collectErrorCauseCodes,
+  classifyImplicitSemanticFallbackReason,
+  _testOnlySearchCommand,
+  resolveSearchMaxResults,
+  resolveSearchScoreThreshold,
+  resolveHybridSemanticWeight,
+  resolveSearchTuning,
+  runSearch
+};
+//# sourceMappingURL=chunk-TZXRBVAM.js.map
+
+//# debugId=106509f0-71e6-5a15-915f-acf57240a3e4