@unbrained/pm-cli 2026.7.6 → 2026.7.8

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

@@ -1,2306 +0,0 @@
-
-!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