@unbrained/pm-cli 2026.5.30 → 2026.5.31

package/dist/cli-bundle/chunks/search-HENBL456.js

@@ -0,0 +1,1135 @@
+import {
+  collectStaleVectorizationIds
+} from "./chunk-QAJBIGRA.js";
+import {
+  buildEventCorpus,
+  buildPlanFlatCorpus,
+  buildReminderCorpus,
+  executeEmbeddingRequest,
+  executeVectorQuery,
+  readVectorizationStatusLedger,
+  resolveEmbeddingProviders,
+  resolveSettingsWithSemanticRuntimeDefaults,
+  resolveVectorStores
+} from "./chunk-6HT2F4TK.js";
+import "./chunk-EGUGFSNX.js";
+import {
+  collectRuntimeFilterValues,
+  matchesRuntimeFilters
+} from "./chunk-FM26RGSU.js";
+import {
+  parseLimit,
+  parsePriority,
+  parseType
+} from "./chunk-SEXQN4KL.js";
+import {
+  listAllDocumentCandidatesCached,
+  listAllFrontMatter,
+  toItemRecord
+} from "./chunk-BUPWJ3IJ.js";
+import "./chunk-4AEZR5EJ.js";
+import "./chunk-CEFIVZPG.js";
+import {
+  isTerminalStatus,
+  parseItemDocument
+} from "./chunk-MD7K4JYF.js";
+import {
+  resolveItemTypeRegistry
+} from "./chunk-WDPXDQFG.js";
+import {
+  compareTimestampStrings,
+  nowIso,
+  resolveIsoOrRelative
+} from "./chunk-PVNQLCIS.js";
+import {
+  EXIT_CODE,
+  PmCliError,
+  getActiveExtensionRegistrations,
+  getItemPath,
+  getSettingsPath,
+  isPathWithinDirectory,
+  pathExists,
+  readSettings,
+  resolveGlobalPmRoot,
+  resolvePmRoot,
+  resolveRuntimeFieldRegistry,
+  resolveRuntimeStatusRegistry,
+  runActiveOnReadHooks,
+  toNonEmptyStringOrUndefined
+} from "./chunk-LSXGH6NE.js";
+
+// dist/cli/commands/search.js
+import fs from "node:fs/promises";
+import path from "node:path";
+
+// dist/core/extensions/runtime-registrations.js
+!(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] = "0eb4f7df-9f0e-5e86-9802-1490f5a73f6e");
+  } catch (e2) {
+  }
+})();
+function normalizeRegistrationName(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized.length > 0 ? normalized : null;
+}
+function resolveRegisteredSearchProvider(registrations, configuredProvider) {
+  const providerName = normalizeRegistrationName(configuredProvider);
+  if (!registrations || !providerName) {
+    return null;
+  }
+  const matched = [...registrations.search_providers].reverse().find((registration) => {
+    const definitionName = normalizeRegistrationName(registration.runtime_definition?.name) ?? normalizeRegistrationName(registration.definition?.name);
+    return definitionName === providerName;
+  });
+  return matched ?? null;
+}
+function resolveRegisteredVectorStoreAdapter(registrations, configuredAdapter) {
+  const adapterName = normalizeRegistrationName(configuredAdapter);
+  if (!registrations || !adapterName) {
+    return null;
+  }
+  const matched = [...registrations.vector_store_adapters].reverse().find((registration) => {
+    const definitionName = normalizeRegistrationName(registration.runtime_definition?.name) ?? normalizeRegistrationName(registration.definition?.name);
+    return definitionName === adapterName;
+  });
+  return matched ?? null;
+}
+
+// dist/core/shared/text-normalization.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "1109b938-c421-5517-9671-2cebd7e10309");
+  } catch (e2) {
+  }
+})();
+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);
+}
+
+// dist/cli/commands/search.js
+!(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] = "22bb189d-1bb3-5ce3-8b8a-d64dcb0b6c02");
+  } catch (e2) {
+  }
+})();
+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"]);
+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 IMPLICIT_HYBRID_EMBEDDING_TIMEOUT_MS = 8e3;
+var IMPLICIT_HYBRID_VECTOR_TIMEOUT_MS = 8e3;
+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 buildImplicitSemanticFallbackWarning(error) {
+  const reason = classifyImplicitSemanticFallbackReason(error);
+  if (reason === "timeout") {
+    return "search_implicit_semantic_fallback:timeout:using_keyword_mode";
+  }
+  if (reason === "connection") {
+    return "search_implicit_semantic_fallback:connection:using_keyword_mode";
+  }
+  return "search_implicit_semantic_fallback:error:using_keyword_mode";
+}
+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 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: []
+  };
+}
+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 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 applyFilters(items, options, typeRegistry, runtimeFieldFilters) {
+  const typeFilter = parseType(options.type, typeRegistry);
+  const tagFilter = options.tag?.trim().toLowerCase();
+  const priorityFilter = parsePriority(options.priority);
+  const deadlineBefore = parseDeadline(options.deadlineBefore, "deadline-before");
+  const deadlineAfter = parseDeadline(options.deadlineAfter, "deadline-after");
+  return items.filter((document) => {
+    const item = document.metadata;
+    if (typeFilter && item.type !== typeFilter)
+      return false;
+    if (tagFilter && !stringArray(item.tags).includes(tagFilter))
+      return false;
+    if (priorityFilter !== void 0 && item.priority !== priorityFilter)
+      return false;
+    if (deadlineBefore && (!item.deadline || compareTimestampStrings(item.deadline, deadlineBefore) > 0))
+      return false;
+    if (deadlineAfter && (!item.deadline || compareTimestampStrings(item.deadline, deadlineAfter) < 0))
+      return false;
+    if (!matchesRuntimeFilters(item, runtimeFieldFilters))
+      return false;
+    return true;
+  });
+}
+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");
+}
+function scoreDocument(document, tokens, normalizedQuery, linkedCorpus, tuning) {
+  const item = document.metadata;
+  const titleTokenCounts = /* @__PURE__ */ new Map();
+  for (const token of tokenizeForExactTokenMatch(item.title)) {
+    titleTokenCounts.set(token, (titleTokenCounts.get(token) ?? 0) + 1);
+  }
+  const searchableFields = [
+    { name: "title", value: item.title, weight: tuning.title_weight },
+    { name: "description", value: item.description, weight: tuning.description_weight },
+    { name: "tags", value: stringArray(item.tags).join(" "), weight: tuning.tags_weight },
+    { name: "status", value: typeof item.status === "string" ? item.status : "", weight: tuning.status_weight },
+    { name: "body", value: document.body, weight: tuning.body_weight },
+    { name: "comments", value: textEntries(item.comments).map((entry) => entry.text).join(" "), weight: tuning.comments_weight },
+    { name: "notes", value: textEntries(item.notes).map((entry) => entry.text).join(" "), weight: tuning.notes_weight },
+    { name: "learnings", value: textEntries(item.learnings).map((entry) => entry.text).join(" "), weight: tuning.learnings_weight },
+    { name: "reminders", value: buildReminderCorpus(item).join(" "), weight: tuning.reminders_weight },
+    { name: "events", value: buildEventCorpus(item).join(" "), weight: tuning.events_weight },
+    {
+      name: "dependencies",
+      value: dependencyEntries(item.dependencies).map((entry) => `${entry.id} ${entry.kind}`).join(" "),
+      weight: tuning.dependencies_weight
+    },
+    { name: "plan", value: buildPlanFlatCorpus(item), weight: tuning.body_weight },
+    { name: "linked_content", value: linkedCorpus, weight: tuning.linked_content_weight }
+  ];
+  let score = 0;
+  const matched = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    const exactTitleMatches = titleTokenCounts.get(token) ?? 0;
+    if (exactTitleMatches > 0) {
+      score += exactTitleMatches * tuning.title_exact_bonus;
+      matched.add("title");
+    }
+    for (const field of searchableFields) {
+      const fieldValue = field.value.toLowerCase();
+      const occurrences = countOccurrences(fieldValue, token);
+      if (occurrences > 0) {
+        score += occurrences * field.weight;
+        matched.add(field.name);
+      }
+    }
+  }
+  const isLongPhraseQuery = tokens.length >= LONG_QUERY_TOKEN_THRESHOLD && normalizedQuery.includes(" ");
+  if (isLongPhraseQuery) {
+    const normalizedTitle = normalizeSearchPhrase(item.title);
+    if (normalizedTitle === normalizedQuery) {
+      score += LONG_QUERY_TITLE_EXACT_BONUS;
+      matched.add("title");
+    }
+    for (const field of searchableFields) {
+      const normalizedField = normalizeSearchPhrase(field.value);
+      const phraseOccurrences = countOccurrences(normalizedField, normalizedQuery);
+      if (phraseOccurrences > 0) {
+        score += phraseOccurrences * field.weight * LONG_QUERY_PHRASE_MULTIPLIER;
+        matched.add(field.name);
+      }
+    }
+  }
+  if (score <= 0) {
+    return null;
+  }
+  return {
+    item,
+    score,
+    matched_fields: [...matched].sort((a, b) => a.localeCompare(b))
+  };
+}
+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) {
+  return scoreDocument(document, tokens, normalizedQuery, includeLinked ? linkedCorpusById.get(document.metadata.id) ?? "" : "", tuning);
+}
+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, options, includeLinked, scoreThreshold, hybridSemanticWeight, projection, warnings) {
+  const projectionFields = projection.mode === "full" ? null : [...projection.fields];
+  return {
+    query: query.trim(),
+    mode,
+    items: [],
+    count: 0,
+    filters: {
+      mode,
+      type: options.type ?? null,
+      tag: options.tag ?? null,
+      priority: options.priority ?? null,
+      deadline_before: options.deadlineBefore ?? null,
+      deadline_after: options.deadlineAfter ?? null,
+      include_linked: includeLinked,
+      title_exact: options.titleExact === true,
+      phrase_exact: options.phraseExact === true,
+      score_threshold: scoreThreshold,
+      hybrid_semantic_weight: mode === "hybrid" ? hybridSemanticWeight : null,
+      limit: options.limit ?? null
+    },
+    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 resolveExtensionSearchProvider(settings) {
+  const registrations = getActiveExtensionRegistrations();
+  const providerName = toOptionalNonEmptyString(settings.search?.provider);
+  const resolved = resolveRegisteredSearchProvider(registrations, providerName);
+  if (!resolved) {
+    return null;
+  }
+  const runtimeDefinition = resolved.runtime_definition ?? resolved.definition;
+  const query = runtimeDefinition.query;
+  if (typeof query !== "function") {
+    return null;
+  }
+  const registeredName = toOptionalNonEmptyString(runtimeDefinition.name) ?? toOptionalNonEmptyString(resolved.definition.name) ?? providerName;
+  if (!registeredName) {
+    return null;
+  }
+  return {
+    providerName: registeredName,
+    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;
+  }
+  return {
+    query
+  };
+}
+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 combineHybridHits(filteredById, semanticScores, keywordHits, hybridSemanticWeight) {
+  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("semantic");
+    }
+    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);
+}
+async function computeSemanticOrHybridHits(context) {
+  const semanticLimit = context.limit ?? context.maxResults;
+  const embeddingOptions = context.embeddingTimeoutMs !== void 0 ? { timeout_ms: context.embeddingTimeoutMs } : {};
+  const vectorQueryOptions = context.vectorQueryTimeoutMs !== void 0 ? { timeout_ms: context.vectorQueryTimeoutMs } : {};
+  const queryVectors = await executeEmbeddingRequest(context.provider, context.query.trim(), embeddingOptions);
+  const semanticVector = queryVectors[0];
+  let vectorHits;
+  if (context.extensionVectorAdapter?.query) {
+    try {
+      vectorHits = await Promise.resolve(context.extensionVectorAdapter.query({
+        vector: semanticVector,
+        limit: semanticLimit,
+        settings: context.settings
+      }));
+    } catch (error) {
+      if (!context.vectorStore) {
+        throw new PmCliError(`Extension vector adapter query failed and no built-in fallback store is configured (${error instanceof Error ? error.message : String(error)})`, EXIT_CODE.GENERIC_FAILURE);
+      }
+      vectorHits = await executeVectorQuery(context.vectorStore, semanticVector, semanticLimit, vectorQueryOptions);
+    }
+  } else if (context.vectorStore) {
+    vectorHits = await executeVectorQuery(context.vectorStore, semanticVector, semanticLimit, vectorQueryOptions);
+  } else {
+    throw new PmCliError("Semantic search requires either a configured vector store or an extension vector adapter query handler", EXIT_CODE.USAGE);
+  }
+  const filteredById = new Map(context.filteredDocuments.map((document) => [document.metadata.id, document]));
+  const { semanticHits, semanticScores } = buildSemanticHits(vectorHits, filteredById);
+  const vectorMatchCount = semanticScores.size;
+  if (context.requestedMode === "semantic") {
+    return { hits: semanticHits, vectorMatchCount };
+  }
+  return {
+    hits: combineHybridHits(filteredById, semanticScores, context.keywordHits, context.hybridSemanticWeight),
+    vectorMatchCount
+  };
+}
+async function loadDocuments(pmRoot, itemFormat, typeToFolder, schema) {
+  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,
+        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;
+  }
+  return hits.map((hit) => {
+    const projected = {};
+    for (const field of projection.fields) {
+      projected[field] = readSearchFieldValue(hit, field);
+    }
+    return projected;
+  });
+}
+async function runSearch(query, options, global2) {
+  const includeLinked = parseIncludeLinked(options.includeLinked);
+  const titleExact = parseTitleExact(options.titleExact);
+  const phraseExact = parsePhraseExact(options.phraseExact);
+  const tokens = parseTokens(query);
+  const normalizedQuery = normalizeSearchPhrase(query);
+  const limit = parseLimit(options.limit);
+  const projection = parseProjectionConfig(options);
+  const modeWasExplicit = typeof options.mode === "string" && options.mode.trim().length > 0;
+  const pmRoot = resolvePmRoot(process.cwd(), global2.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 runtimeDefaultsResolution = resolveSettingsWithSemanticRuntimeDefaults(storedSettings);
+  const settings = runtimeDefaultsResolution.settings;
+  const statusRegistry = resolveRuntimeStatusRegistry(settings.schema);
+  const runtimeFieldRegistry = resolveRuntimeFieldRegistry(settings.schema);
+  validateSearchProjectionFields(projection, runtimeFieldRegistry);
+  const runtimeFieldFilters = collectRuntimeFilterValues(options, runtimeFieldRegistry, "search");
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const maxResults = resolveSearchMaxResults(settings);
+  const scoreThreshold = resolveSearchScoreThreshold(settings);
+  const hybridSemanticWeight = resolveHybridSemanticWeight(settings);
+  const tuning = resolveSearchTuning(settings);
+  const providerResolution = resolveEmbeddingProviders(settings);
+  const vectorResolution = resolveVectorStores(settings);
+  const extensionSearchProvider = resolveExtensionSearchProvider(settings);
+  const extensionVectorAdapter = resolveExtensionVectorAdapter(settings);
+  let effectiveMode = parseMode(options.mode, {
+    hasProvider: providerResolution.active !== null || extensionSearchProvider !== null,
+    hasVectorStore: vectorResolution.active !== null || extensionVectorAdapter !== null
+  });
+  const loadedDocuments = await loadDocuments(pmRoot, settings.item_format ?? "toon", typeRegistry.type_to_folder, settings.schema);
+  const warnings = loadedDocuments.warnings;
+  const allDocuments = loadedDocuments.documents;
+  const metadataFilteredDocuments = applyFilters(allDocuments, options, typeRegistry, runtimeFieldFilters);
+  const filteredDocuments = applyExactQueryFilters(metadataFilteredDocuments, normalizedQuery, {
+    titleExact,
+    phraseExact
+  });
+  if (effectiveMode === "keyword" && (filteredDocuments.length === 0 || limit === 0)) {
+    return emptySearchResult(query, effectiveMode, options, includeLinked, scoreThreshold, hybridSemanticWeight, projection, warnings);
+  }
+  const projectRoot = process.cwd();
+  const globalRoot = resolveGlobalPmRoot(projectRoot);
+  const linkedCorpusById = /* @__PURE__ */ new Map();
+  if (includeLinked && (effectiveMode === "keyword" || effectiveMode === "hybrid")) {
+    const linkedCorpusRoots = await resolveLinkedCorpusRoots(projectRoot, globalRoot);
+    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);
+    }
+  }
+  const keywordHits = filteredDocuments.map((document) => buildHybridLexicalScore(document, tokens, normalizedQuery, effectiveMode !== "semantic", linkedCorpusById, tuning)).filter((entry) => entry !== null);
+  let hits = keywordHits;
+  if (effectiveMode !== "keyword") {
+    const builtInSemanticWillRun = !extensionSearchProvider && providerResolution.active !== null && (vectorResolution.active !== null || extensionVectorAdapter !== null);
+    if (modeWasExplicit && builtInSemanticWillRun) {
+      await maybeEmitVectorIndexStaleWarning(pmRoot, filteredDocuments, warnings);
+    }
+    try {
+      if (!extensionSearchProvider) {
+        requireSemanticDependencies(effectiveMode, providerResolution, vectorResolution, extensionVectorAdapter !== null);
+      }
+      if (filteredDocuments.length === 0 || limit === 0) {
+        return emptySearchResult(query, effectiveMode, options, includeLinked, scoreThreshold, hybridSemanticWeight, projection, warnings);
+      }
+      const filteredById = new Map(filteredDocuments.map((document) => [document.metadata.id, document]));
+      const canUseBuiltInSemantic = providerResolution.active !== null && (vectorResolution.active !== null || extensionVectorAdapter !== null);
+      if (extensionSearchProvider) {
+        try {
+          const providerResponse = await Promise.resolve(extensionSearchProvider.query({
+            query,
+            mode: effectiveMode,
+            tokens,
+            options,
+            settings,
+            documents: filteredDocuments
+          }));
+          hits = normalizeExtensionProviderHits(extensionSearchProvider.providerName, providerResponse, filteredById);
+        } catch (error) {
+          if (!canUseBuiltInSemantic) {
+            throw new PmCliError(`Extension search provider "${extensionSearchProvider.providerName}" failed: ${error instanceof Error ? error.message : String(error)}`, EXIT_CODE.GENERIC_FAILURE);
+          }
+        }
+      }
+      if (hits === keywordHits) {
+        const implicitHybridMode = !modeWasExplicit && effectiveMode === "hybrid";
+        const { provider, vectorStore } = requireSemanticDependencies(effectiveMode, providerResolution, vectorResolution, extensionVectorAdapter !== null);
+        const semanticResult = await computeSemanticOrHybridHits({
+          requestedMode: effectiveMode,
+          query,
+          filteredDocuments,
+          keywordHits,
+          hybridSemanticWeight,
+          limit,
+          maxResults,
+          provider,
+          vectorStore,
+          extensionVectorAdapter,
+          settings,
+          ...implicitHybridMode ? {
+            embeddingTimeoutMs: IMPLICIT_HYBRID_EMBEDDING_TIMEOUT_MS,
+            vectorQueryTimeoutMs: IMPLICIT_HYBRID_VECTOR_TIMEOUT_MS
+          } : {}
+        });
+        hits = semanticResult.hits;
+        if (semanticResult.vectorMatchCount === 0) {
+          if (effectiveMode === "semantic") {
+            hits = keywordHits;
+          }
+          warnings.push(`search_${effectiveMode}_degraded:no_vector_matches:results_are_lexical`);
+        }
+      }
+    } catch (error) {
+      const fallbackWarning = modeWasExplicit ? buildExplicitSemanticFallbackWarning(effectiveMode, error) : buildImplicitSemanticFallbackWarning(error);
+      effectiveMode = "keyword";
+      hits = keywordHits;
+      warnings.push(fallbackWarning);
+    }
+  }
+  const thresholded = hits.filter((entry) => entry.score >= scoreThreshold);
+  const sorted = sortHits(thresholded, statusRegistry);
+  const resolvedLimit = effectiveMode === "keyword" ? limit : limit ?? maxResults;
+  const limited = resolvedLimit === void 0 ? sorted : sorted.slice(0, resolvedLimit);
+  const projectedItems = projectSearchHits(limited, projection);
+  const projectionFields = projection.mode === "full" ? null : [...projection.fields];
+  return {
+    query: query.trim(),
+    mode: effectiveMode,
+    items: projectedItems,
+    count: projectedItems.length,
+    filters: {
+      mode: effectiveMode,
+      type: options.type ?? null,
+      tag: options.tag ?? null,
+      priority: options.priority ?? null,
+      deadline_before: options.deadlineBefore ?? null,
+      deadline_after: options.deadlineAfter ?? null,
+      include_linked: includeLinked,
+      title_exact: titleExact,
+      phrase_exact: phraseExact,
+      score_threshold: scoreThreshold,
+      hybrid_semantic_weight: effectiveMode === "hybrid" ? hybridSemanticWeight : null,
+      limit: options.limit ?? null,
+      runtime_filters: runtimeFieldFilters
+    },
+    projection: {
+      mode: projection.mode,
+      fields: projectionFields
+    },
+    now: nowIso(),
+    ...warnings.length > 0 ? { warnings } : {}
+  };
+}
+export {
+  classifyImplicitSemanticFallbackReason,
+  collectErrorCauseCodes,
+  resolveHybridSemanticWeight,
+  resolveSearchMaxResults,
+  resolveSearchScoreThreshold,
+  resolveSearchTuning,
+  runSearch
+};
+//# sourceMappingURL=search-HENBL456.js.map