@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-7QH7DHUB.js

@@ -1,2046 +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]="c63a3843-4fe5-59f1-a28c-51139dae3ccd")}catch(e){}}();
-import {
-  locateItem,
-  readLocatedItem
-} from "./chunk-57C2RLW5.js";
-import {
-  nowIso
-} from "./chunk-FJRKQREY.js";
-import {
-  getActiveExtensionRegistrations,
-  readSettings
-} from "./chunk-US3T3W5J.js";
-import {
-  coercePositiveInteger,
-  getSettingsPath,
-  isFiniteNumberArray,
-  pathExists,
-  readFileIfExists,
-  removeFileIfExists,
-  resolveItemTypeRegistry,
-  resolvePmPackageRootFromModule,
-  toErrorMessage,
-  toNonEmptyString,
-  trimTrailingSlashes,
-  writeFileAtomic
-} from "./chunk-YD5FML7K.js";
-
-// dist/core/search/http-client.js
-var DEFAULT_SEARCH_HTTP_TIMEOUT_MS = 3e4;
-function normalizeSearchHttpTimeoutMs(timeoutMs, requestLabel, defaultTimeoutMs = DEFAULT_SEARCH_HTTP_TIMEOUT_MS) {
-  const resolved = timeoutMs ?? defaultTimeoutMs;
-  if (!Number.isFinite(resolved) || resolved <= 0) {
-    throw new Error(`${requestLabel} timeout must be a positive finite number`);
-  }
-  return Math.floor(resolved);
-}
-function resolveSearchHttpFetcher(fetcher, requestLabel) {
-  if (fetcher) {
-    return fetcher;
-  }
-  if (typeof globalThis.fetch === "function") {
-    return globalThis.fetch.bind(globalThis);
-  }
-  throw new Error(`${requestLabel} execution requires a fetch implementation`);
-}
-async function readFailedSearchHttpResponseBody(response) {
-  try {
-    return (await response.text()).replaceAll(/\s+/g, " ").trim();
-  } catch (error) {
-    return `(failed to read response body: ${toErrorMessage(error)})`;
-  }
-}
-async function executeSearchJsonRequest(options) {
-  const controller = new AbortController();
-  const timeoutHandle = setTimeout(() => {
-    controller.abort();
-  }, options.timeoutMs);
-  try {
-    let response;
-    try {
-      response = await options.fetcher(options.endpoint, {
-        method: options.method,
-        headers: options.headers,
-        body: JSON.stringify(options.body),
-        signal: controller.signal
-      });
-    } catch (error) {
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error(`${options.requestLabel} timed out after ${options.timeoutMs}ms`);
-      }
-      throw new Error(`${options.requestLabel} execution failed: ${toErrorMessage(error)}`);
-    }
-    if (!response.ok) {
-      const responseBody = await readFailedSearchHttpResponseBody(response);
-      const detail = responseBody.length > 0 ? `: ${responseBody}` : "";
-      throw new Error(`${options.requestLabel} failed with status ${response.status} ${response.statusText}${detail}`);
-    }
-    try {
-      return await response.json();
-    } catch (error) {
-      throw new Error(`${options.responseLabel} JSON parse failed: ${toErrorMessage(error)}`);
-    }
-  } finally {
-    clearTimeout(timeoutHandle);
-  }
-}
-
-// dist/core/search/providers.js
-function resolveProviderConfigSource(activeName, configured) {
-  const active = toNonEmptyString(activeName);
-  if (!active) {
-    return "unconfigured";
-  }
-  const configuredValue = toNonEmptyString(configured);
-  return configuredValue && configuredValue.toLowerCase() === active.toLowerCase() ? "configured" : "auto-detected";
-}
-function normalizeOpenAiEmbeddingsEndpoint(baseUrl) {
-  const normalizedBaseUrl = trimTrailingSlashes(baseUrl);
-  const normalizedLower = normalizedBaseUrl.toLowerCase();
-  if (normalizedLower.endsWith("/embeddings")) {
-    return normalizedBaseUrl;
-  }
-  if (normalizedLower.endsWith("/v1")) {
-    return `${normalizedBaseUrl}/embeddings`;
-  }
-  return `${normalizedBaseUrl}/v1/embeddings`;
-}
-function resolveSearchEmbeddingModelOverride(settings) {
-  const candidate = settings.search?.embedding_model;
-  return toNonEmptyString(candidate) || null;
-}
-function resolveOpenAiProvider(settings) {
-  const baseUrl = toNonEmptyString(settings.providers?.openai?.base_url);
-  const model = toNonEmptyString(settings.providers?.openai?.model);
-  if (!baseUrl || !model) {
-    return null;
-  }
-  const override = resolveSearchEmbeddingModelOverride(settings);
-  const apiKey = toNonEmptyString(settings.providers?.openai?.api_key);
-  return {
-    name: "openai",
-    base_url: baseUrl,
-    model: override ?? model,
-    ...apiKey ? { api_key: apiKey } : {}
-  };
-}
-function resolveOllamaProvider(settings) {
-  const baseUrl = toNonEmptyString(settings.providers?.ollama?.base_url);
-  const model = toNonEmptyString(settings.providers?.ollama?.model);
-  if (!baseUrl || !model) {
-    return null;
-  }
-  const override = resolveSearchEmbeddingModelOverride(settings);
-  return {
-    name: "ollama",
-    base_url: baseUrl,
-    model: override ?? model
-  };
-}
-function normalizeEmbeddingInputs(input) {
-  const inputs = (Array.isArray(input) ? input : [input]).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-  if (inputs.length === 0) {
-    throw new Error("Embedding input must include at least one non-empty string");
-  }
-  return inputs;
-}
-function dedupeEmbeddingInputs(inputs) {
-  const uniqueInputs = [];
-  const originalToUniqueIndex = [];
-  const uniqueIndexByInput = /* @__PURE__ */ new Map();
-  for (const entry of inputs) {
-    const existingUniqueIndex = uniqueIndexByInput.get(entry);
-    if (existingUniqueIndex === void 0) {
-      const nextUniqueIndex = uniqueInputs.length;
-      uniqueInputs.push(entry);
-      uniqueIndexByInput.set(entry, nextUniqueIndex);
-      originalToUniqueIndex.push(nextUniqueIndex);
-      continue;
-    }
-    originalToUniqueIndex.push(existingUniqueIndex);
-  }
-  return {
-    uniqueInputs,
-    originalToUniqueIndex
-  };
-}
-function buildOrderedOpenAiEntries(data) {
-  const openAiEntries = data.map((entry, position) => ({
-    embedding: entry.embedding,
-    index: entry.index,
-    position
-  }));
-  const hasExplicitIndex = openAiEntries.some((entry) => entry.index !== void 0);
-  if (hasExplicitIndex) {
-    for (const entry of openAiEntries) {
-      if (!Number.isInteger(entry.index)) {
-        throw new TypeError(`OpenAI embedding response entry at position ${entry.position} is missing a valid integer index`);
-      }
-    }
-    return [...openAiEntries].sort((a, b) => {
-      const byIndex = a.index - b.index;
-      if (byIndex !== 0) {
-        return byIndex;
-      }
-      return a.position - b.position;
-    });
-  }
-  return openAiEntries;
-}
-function resolveEmbeddingProviders(settings) {
-  const openAi = resolveOpenAiProvider(settings);
-  const ollama = resolveOllamaProvider(settings);
-  const available = [openAi, ollama].filter((entry) => entry !== null);
-  const preferredName = toNonEmptyString(settings.search?.provider);
-  const preferredKey = preferredName ? preferredName.toLowerCase() : null;
-  const preferred = preferredKey ? available.find((entry) => entry.name === preferredKey) : void 0;
-  return {
-    active: preferred ?? available[0] ?? null,
-    available
-  };
-}
-function resolveEmbeddingRequestTarget(provider) {
-  const baseUrl = trimTrailingSlashes(provider.base_url);
-  if (provider.name === "openai") {
-    return {
-      provider: "openai",
-      endpoint: normalizeOpenAiEmbeddingsEndpoint(baseUrl),
-      model: provider.model
-    };
-  }
-  return {
-    provider: "ollama",
-    endpoint: `${baseUrl}/api/embed`,
-    model: provider.model
-  };
-}
-function buildEmbeddingRequestPlan(provider, input) {
-  const normalizedInputs = normalizeEmbeddingInputs(input);
-  if (provider.name === "openai") {
-    return {
-      target: resolveEmbeddingRequestTarget(provider),
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...provider.api_key ? { authorization: `Bearer ${provider.api_key}` } : {}
-      },
-      body: {
-        model: provider.model,
-        input: normalizedInputs.length === 1 ? normalizedInputs[0] : normalizedInputs
-      }
-    };
-  }
-  return {
-    target: resolveEmbeddingRequestTarget(provider),
-    method: "POST",
-    headers: {
-      "content-type": "application/json"
-    },
-    body: {
-      model: provider.model,
-      input: normalizedInputs
-    }
-  };
-}
-function normalizeEmbeddingResponse(provider, response) {
-  if (provider.name === "openai") {
-    const data = response.data;
-    if (!Array.isArray(data) || data.length === 0) {
-      throw new Error("OpenAI embedding response must include a non-empty data array");
-    }
-    const orderedEntries = buildOrderedOpenAiEntries(data);
-    return orderedEntries.map((entry, index) => {
-      const embedding = entry.embedding;
-      if (!isFiniteNumberArray(embedding)) {
-        throw new Error(`OpenAI embedding response entry at index ${index} is missing a numeric embedding vector`);
-      }
-      return [...embedding];
-    });
-  }
-  const singleEmbedding = response.embedding;
-  if (isFiniteNumberArray(singleEmbedding)) {
-    return [[...singleEmbedding]];
-  }
-  const multipleEmbeddings = response.embeddings;
-  if (Array.isArray(multipleEmbeddings) && multipleEmbeddings.length > 0) {
-    return multipleEmbeddings.map((entry, index) => {
-      if (!isFiniteNumberArray(entry)) {
-        throw new Error(`Ollama embedding response entry at index ${index} is missing a numeric embedding vector`);
-      }
-      return [...entry];
-    });
-  }
-  throw new Error("Ollama embedding response must include embedding or embeddings vectors");
-}
-async function executeEmbeddingRequest(provider, input, options = {}) {
-  const timeoutMs = normalizeSearchHttpTimeoutMs(options.timeout_ms, "Embedding request");
-  const fetcher = resolveSearchHttpFetcher(options.fetcher, "Embedding request");
-  const normalizedInputs = normalizeEmbeddingInputs(input);
-  const dedupedInputs = dedupeEmbeddingInputs(normalizedInputs);
-  const requestPlan = buildEmbeddingRequestPlan(provider, dedupedInputs.uniqueInputs);
-  const payload = await executeSearchJsonRequest({
-    endpoint: requestPlan.target.endpoint,
-    method: requestPlan.method,
-    headers: requestPlan.headers,
-    body: requestPlan.body,
-    timeoutMs,
-    fetcher,
-    requestLabel: "Embedding request",
-    responseLabel: "Embedding response"
-  });
-  const vectors = normalizeEmbeddingResponse(provider, payload);
-  if (vectors.length !== dedupedInputs.uniqueInputs.length) {
-    throw new Error(`Embedding response cardinality mismatch: expected ${dedupedInputs.uniqueInputs.length} vector(s), received ${vectors.length}`);
-  }
-  return dedupedInputs.originalToUniqueIndex.map((uniqueIndex) => [...vectors[uniqueIndex]]);
-}
-
-// dist/core/search/corpus.js
-var DEFAULT_SEARCH_CORPUS_FIELDS = [
-  "title",
-  "description",
-  "tags",
-  "status",
-  "type",
-  "priority",
-  "assignee",
-  "parent",
-  "goal",
-  "value",
-  "why_now",
-  "risk",
-  "confidence",
-  "estimated_minutes",
-  "acceptance_criteria",
-  "resolution",
-  "expected_result",
-  "actual_result",
-  "body",
-  "comments",
-  "notes",
-  "learnings",
-  "reminders",
-  "events",
-  "dependencies",
-  "plan"
-];
-function resolveSearchCorpusFields(settings) {
-  const configured = settings?.search?.corpus_fields;
-  if (!Array.isArray(configured)) {
-    return [...DEFAULT_SEARCH_CORPUS_FIELDS];
-  }
-  const knownFields = new Set(DEFAULT_SEARCH_CORPUS_FIELDS);
-  const selected = Array.from(new Set(configured.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0 && knownFields.has(entry))));
-  return selected.length > 0 ? selected : [...DEFAULT_SEARCH_CORPUS_FIELDS];
-}
-var DEFAULT_SEMANTIC_CORPUS_INPUT_MAX_CHARACTERS = 8e3;
-var OLLAMA_SEMANTIC_CORPUS_INPUT_MAX_CHARACTERS = 3200;
-var SEMANTIC_CORPUS_TRUNCATION_SUFFIX = "...[semantic corpus truncated]";
-var SEARCH_EMBEDDING_CORPUS_MAX_CHARACTERS_INVALID_WARNING = "search_embedding_corpus_max_characters_invalid:using_provider_default";
-function compactParts(parts) {
-  return parts.map((part) => part === void 0 || part === null ? "" : String(part).trim()).filter((part) => part.length > 0).join(" ");
-}
-function buildReminderCorpus(item) {
-  return (item.reminders ?? []).map((reminder) => compactParts([reminder.at, reminder.text]));
-}
-function buildEventCorpus(item) {
-  return (item.events ?? []).map((event) => compactParts([
-    event.start_at,
-    event.end_at,
-    event.title,
-    event.description,
-    event.location,
-    event.all_day === true ? "all day" : void 0,
-    event.timezone,
-    event.recurrence?.freq,
-    event.recurrence?.interval,
-    event.recurrence?.count,
-    event.recurrence?.until,
-    event.recurrence?.by_weekday?.join(" "),
-    event.recurrence?.by_month_day?.join(" "),
-    event.recurrence?.exdates?.join(" ")
-  ]));
-}
-function appendPlanStepFlatCorpus(segments, step) {
-  segments.push(step.title, step.body, step.status, step.owner, step.evidence, step.blocked_reason, step.superseded_by);
-  for (const link of step.linked_items ?? []) {
-    segments.push(`${link.kind} ${link.id}`, link.note);
-  }
-  for (const file of step.files ?? [])
-    segments.push(file.path, file.note);
-  for (const test of step.tests ?? [])
-    segments.push(test.command, test.path, test.note);
-  for (const doc of step.docs ?? [])
-    segments.push(doc.path, doc.note);
-}
-function appendPlanMetadataFlatCorpus(segments, item) {
-  for (const decision of item.plan_decisions ?? []) {
-    segments.push(decision.decision, decision.rationale, decision.evidence);
-  }
-  for (const discovery of item.plan_discoveries ?? []) {
-    segments.push(discovery.text);
-  }
-  for (const check of item.plan_validation ?? []) {
-    segments.push(check.text, check.command, check.expected);
-  }
-}
-function buildPlanFlatCorpus(item) {
-  const segments = [];
-  segments.push(item.plan_mode, item.plan_scope, item.plan_harness, item.plan_resume_context);
-  for (const step of item.plan_steps ?? []) {
-    appendPlanStepFlatCorpus(segments, step);
-  }
-  appendPlanMetadataFlatCorpus(segments, item);
-  return segments.filter((segment) => typeof segment === "string" && segment.length > 0).join(" ");
-}
-function buildPlanCorpus(item) {
-  const steps = (item.plan_steps ?? []).map((step) => compactParts([
-    step.order,
-    step.id,
-    step.title,
-    step.body,
-    step.status,
-    step.owner,
-    step.evidence,
-    step.blocked_reason,
-    step.superseded_by,
-    (step.linked_items ?? []).map((link) => compactParts([link.kind, link.id, link.note])).join(" "),
-    (step.files ?? []).map((file) => compactParts([file.path, file.note])).join(" "),
-    (step.tests ?? []).map((test) => compactParts([test.command, test.path, test.note])).join(" "),
-    (step.docs ?? []).map((doc) => compactParts([doc.path, doc.note])).join(" ")
-  ]));
-  const decisions = (item.plan_decisions ?? []).map((entry) => compactParts([entry.decision, entry.rationale, entry.evidence, entry.step_id]));
-  const discoveries = (item.plan_discoveries ?? []).map((entry) => compactParts([entry.text, entry.step_id]));
-  const validation = (item.plan_validation ?? []).map((entry) => compactParts([entry.text, entry.command, entry.expected]));
-  const hasPlanContent = item.plan_mode !== void 0 || item.plan_scope !== void 0 || item.plan_harness !== void 0 || item.plan_resume_context !== void 0 || steps.length > 0 || decisions.length > 0 || discoveries.length > 0 || validation.length > 0;
-  if (!hasPlanContent) {
-    return void 0;
-  }
-  return {
-    mode: item.plan_mode,
-    scope: item.plan_scope,
-    harness: item.plan_harness,
-    resume_context: item.plan_resume_context,
-    steps,
-    decisions,
-    discoveries,
-    validation
-  };
-}
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-var CORPUS_FIELD_BUILDERS = {
-  title: (document) => document.metadata.title,
-  description: (document) => document.metadata.description,
-  tags: (document) => document.metadata.tags,
-  status: (document) => document.metadata.status,
-  type: (document) => document.metadata.type,
-  priority: (document) => typeof document.metadata.priority === "number" ? document.metadata.priority : void 0,
-  assignee: (document) => isNonEmptyString(document.metadata.assignee) ? document.metadata.assignee : void 0,
-  parent: (document) => isNonEmptyString(document.metadata.parent) ? document.metadata.parent : void 0,
-  goal: (document) => isNonEmptyString(document.metadata.goal) ? document.metadata.goal : void 0,
-  value: (document) => isNonEmptyString(document.metadata.value) ? document.metadata.value : void 0,
-  why_now: (document) => isNonEmptyString(document.metadata.why_now) ? document.metadata.why_now : void 0,
-  risk: (document) => isNonEmptyString(document.metadata.risk) ? document.metadata.risk : void 0,
-  confidence: (document) => document.metadata.confidence !== void 0 && document.metadata.confidence !== null ? document.metadata.confidence : void 0,
-  estimated_minutes: (document) => typeof document.metadata.estimated_minutes === "number" ? document.metadata.estimated_minutes : void 0,
-  acceptance_criteria: (document) => isNonEmptyString(document.metadata.acceptance_criteria) ? document.metadata.acceptance_criteria : void 0,
-  resolution: (document) => isNonEmptyString(document.metadata.resolution) ? document.metadata.resolution : void 0,
-  expected_result: (document) => isNonEmptyString(document.metadata.expected_result) ? document.metadata.expected_result : void 0,
-  actual_result: (document) => isNonEmptyString(document.metadata.actual_result) ? document.metadata.actual_result : void 0,
-  body: (document) => document.body,
-  comments: (document) => (document.metadata.comments ?? []).map((entry) => entry.text),
-  notes: (document) => (document.metadata.notes ?? []).map((entry) => entry.text),
-  learnings: (document) => (document.metadata.learnings ?? []).map((entry) => entry.text),
-  reminders: (document) => buildReminderCorpus(document.metadata),
-  events: (document) => buildEventCorpus(document.metadata),
-  dependencies: (document) => (document.metadata.dependencies ?? []).map((entry) => ({
-    id: entry.id,
-    kind: entry.kind
-  })),
-  plan: (document) => buildPlanCorpus(document.metadata)
-};
-function buildSearchCorpus(document, options = {}) {
-  const fields = options.fields ?? DEFAULT_SEARCH_CORPUS_FIELDS;
-  const corpus = {};
-  for (const field of fields) {
-    const builder = CORPUS_FIELD_BUILDERS[field];
-    if (!builder) {
-      continue;
-    }
-    const value = builder(document);
-    if (value === void 0) {
-      continue;
-    }
-    corpus[field] = value;
-  }
-  return corpus;
-}
-function resolveSemanticCorpusInputCharacterLimit(providerName) {
-  if (providerName?.trim().toLowerCase() === "ollama") {
-    return OLLAMA_SEMANTIC_CORPUS_INPUT_MAX_CHARACTERS;
-  }
-  return DEFAULT_SEMANTIC_CORPUS_INPUT_MAX_CHARACTERS;
-}
-function resolveSemanticCorpusCharacterLimit(providerName, configuredMaxCharacters) {
-  const providerDefaultLimit = resolveSemanticCorpusInputCharacterLimit(providerName);
-  const parsed = coercePositiveInteger(configuredMaxCharacters);
-  if (parsed !== null) {
-    return {
-      maxCharacters: parsed,
-      warning: null
-    };
-  }
-  return {
-    maxCharacters: providerDefaultLimit,
-    warning: configuredMaxCharacters === void 0 || configuredMaxCharacters === null ? null : SEARCH_EMBEDDING_CORPUS_MAX_CHARACTERS_INVALID_WARNING
-  };
-}
-function buildSemanticCorpusInput(document, options = {}) {
-  const serialized = JSON.stringify(buildSearchCorpus(document, { fields: options.fields }));
-  const maxCharacters = resolveSemanticCorpusCharacterLimit(options.providerName, options.maxCharacters).maxCharacters;
-  if (serialized.length <= maxCharacters) {
-    return serialized;
-  }
-  if (maxCharacters <= SEMANTIC_CORPUS_TRUNCATION_SUFFIX.length) {
-    return SEMANTIC_CORPUS_TRUNCATION_SUFFIX.slice(0, maxCharacters);
-  }
-  const keepLength = Math.max(0, maxCharacters - SEMANTIC_CORPUS_TRUNCATION_SUFFIX.length);
-  return `${serialized.slice(0, keepLength)}${SEMANTIC_CORPUS_TRUNCATION_SUFFIX}`;
-}
-
-// dist/core/search/semantic-defaults.js
-import { spawnSync } from "node:child_process";
-var DISABLE_AUTO_DEFAULTS_ENV = "PM_DISABLE_OLLAMA_AUTO_DEFAULTS";
-var OLLAMA_MODEL_ENV = "PM_OLLAMA_MODEL";
-var DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434";
-var DEFAULT_OLLAMA_MODEL = "qwen3-embedding:0.6b";
-var DEFAULT_LANCEDB_PATH = ".agents/pm/search/lancedb/";
-var OLLAMA_VERSION_TIMEOUT_MS = 1500;
-var OLLAMA_LIST_TIMEOUT_MS = 2500;
-var QWEN_EMBEDDING_MODEL_PATTERN = /qwen.*(?:embed|embedding)|(?:embed|embedding).*qwen/i;
-var EMBEDDING_MODEL_PATTERN = /embed|embedding/i;
-var toOptionalNonEmptyString = toNonEmptyString;
-function isAutoDefaultsDisabled() {
-  const raw = toOptionalNonEmptyString(process.env[DISABLE_AUTO_DEFAULTS_ENV]);
-  if (!raw) {
-    return false;
-  }
-  const normalized = raw.toLowerCase();
-  return normalized === "1" || normalized === "true" || normalized === "yes";
-}
-function hasConfiguredValue(values) {
-  return values.some((entry) => toOptionalNonEmptyString(entry) !== null);
-}
-function hasCompetingProvider(provider) {
-  const normalized = toOptionalNonEmptyString(provider);
-  return Boolean(normalized && normalized.toLowerCase() !== "ollama");
-}
-function hasCompetingVectorAdapter(adapter) {
-  const normalized = toOptionalNonEmptyString(adapter);
-  return Boolean(normalized && normalized.toLowerCase() !== "lancedb");
-}
-function hasCompetingSemanticConfiguration(settings) {
-  if (hasCompetingProvider(settings.search?.provider)) {
-    return true;
-  }
-  if (hasCompetingVectorAdapter(settings.vector_store?.adapter)) {
-    return true;
-  }
-  if (hasConfiguredValue([
-    settings.providers?.openai?.base_url,
-    settings.providers?.openai?.model,
-    settings.providers?.openai?.api_key
-  ])) {
-    return true;
-  }
-  return hasConfiguredValue([
-    settings.vector_store?.qdrant?.url,
-    settings.vector_store?.qdrant?.api_key
-  ]);
-}
-function isOllamaInstalled() {
-  const result = spawnSync("ollama", ["--version"], {
-    encoding: "utf8",
-    timeout: OLLAMA_VERSION_TIMEOUT_MS
-  });
-  if (result.error) {
-    return false;
-  }
-  return result.status === 0;
-}
-function parseOllamaModelList(output) {
-  const lines = output.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
-  if (lines.length === 0) {
-    return null;
-  }
-  const models = lines.map((line) => line.split(/\s+/)[0]?.trim()).filter((entry) => Boolean(entry && entry.length > 0)).filter((entry) => entry.toUpperCase() !== "NAME");
-  if (models.length === 0) {
-    return null;
-  }
-  const preferredQwenEmbeddingModel = models.find((entry) => QWEN_EMBEDDING_MODEL_PATTERN.test(entry));
-  if (preferredQwenEmbeddingModel) {
-    return preferredQwenEmbeddingModel;
-  }
-  const embeddingModel = models.find((entry) => EMBEDDING_MODEL_PATTERN.test(entry));
-  return embeddingModel ?? null;
-}
-function resolveAutoOllamaModel(settings) {
-  const settingsModel = toOptionalNonEmptyString(settings.providers?.ollama?.model);
-  if (settingsModel) {
-    return settingsModel;
-  }
-  const envModel = toOptionalNonEmptyString(process.env[OLLAMA_MODEL_ENV]);
-  if (envModel) {
-    return envModel;
-  }
-  const listed = spawnSync("ollama", ["list"], {
-    encoding: "utf8",
-    timeout: OLLAMA_LIST_TIMEOUT_MS
-  });
-  if (!listed.error && listed.status === 0) {
-    const listedModel = parseOllamaModelList(typeof listed.stdout === "string" ? listed.stdout : "");
-    if (listedModel) {
-      return listedModel;
-    }
-  }
-  return DEFAULT_OLLAMA_MODEL;
-}
-function resolveSemanticDefaultNeeds(settings) {
-  return {
-    baseUrl: toOptionalNonEmptyString(settings.providers?.ollama?.base_url) === null,
-    model: toOptionalNonEmptyString(settings.providers?.ollama?.model) === null,
-    lancedbPath: toOptionalNonEmptyString(settings.vector_store?.lancedb?.path) === null,
-    embeddingModel: toOptionalNonEmptyString(settings.search?.embedding_model) === null
-  };
-}
-function needsAnySemanticDefault(needs) {
-  return needs.baseUrl || needs.model || needs.lancedbPath || needs.embeddingModel;
-}
-function applyOllamaProviderDefaults(settings, needs, resolvedModel) {
-  if (!needs.baseUrl && !needs.model) {
-    return;
-  }
-  const providers = settings.providers ??= {};
-  const ollama = providers.ollama ??= {};
-  if (needs.baseUrl) {
-    ollama.base_url = DEFAULT_OLLAMA_BASE_URL;
-  }
-  if (needs.model) {
-    ollama.model = resolvedModel;
-  }
-}
-function applyVectorStoreDefaults(settings, needs) {
-  if (!needs.lancedbPath) {
-    return;
-  }
-  const vectorStore = settings.vector_store ??= {};
-  const lancedb = vectorStore.lancedb ??= {};
-  lancedb.path = DEFAULT_LANCEDB_PATH;
-}
-function applySearchEmbeddingDefaults(settings, needs, resolvedModel) {
-  if (!needs.embeddingModel) {
-    return;
-  }
-  const search = settings.search ??= {};
-  search.embedding_model = resolvedModel;
-}
-function resolveSettingsWithSemanticRuntimeDefaults(settings) {
-  const unchanged = {
-    settings,
-    auto_ollama_defaults_applied: false
-  };
-  if (isAutoDefaultsDisabled()) {
-    return unchanged;
-  }
-  if (hasCompetingSemanticConfiguration(settings)) {
-    return unchanged;
-  }
-  const needs = resolveSemanticDefaultNeeds(settings);
-  if (!needsAnySemanticDefault(needs)) {
-    return unchanged;
-  }
-  if (needs.model && !isOllamaInstalled()) {
-    return unchanged;
-  }
-  const nextSettings = structuredClone(settings);
-  const resolvedModel = resolveAutoOllamaModel(nextSettings);
-  applyOllamaProviderDefaults(nextSettings, needs, resolvedModel);
-  applyVectorStoreDefaults(nextSettings, needs);
-  applySearchEmbeddingDefaults(nextSettings, needs, resolvedModel);
-  return {
-    settings: nextSettings,
-    auto_ollama_defaults_applied: true
-  };
-}
-
-// dist/core/search/vector-stores.js
-import { mkdir, readFile, stat, unlink } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-var DEFAULT_COLLECTION = "pm_items";
-var COLLECTION_SANITIZE_PATTERN = /[^a-zA-Z0-9_-]/g;
-var MAX_COLLECTION_NAME_LENGTH = 128;
-var LANCE_DB_LOCAL_SNAPSHOT_DIR = ".pm-cli-local-vectors";
-var LANCE_DB_LOCAL_SNAPSHOT_VERSION = 1;
-var lanceDbLocalTables = /* @__PURE__ */ new Map();
-function resolveStoreCollectionName(store) {
-  const candidate = toNonEmptyString(store.collection_name) ?? DEFAULT_COLLECTION;
-  return candidate.replaceAll(COLLECTION_SANITIZE_PATTERN, "_").slice(0, MAX_COLLECTION_NAME_LENGTH);
-}
-function normalizeVector(value) {
-  if (!isFiniteNumberArray(value) || value.length === 0) {
-    throw new Error("Vector values must be a non-empty numeric array");
-  }
-  return [...value];
-}
-function normalizeLimit(value) {
-  if (!Number.isFinite(value) || value <= 0) {
-    throw new Error("Vector query limit must be a positive number");
-  }
-  return Math.floor(value);
-}
-function normalizeQdrantQueryResponse(payload) {
-  const result = payload.result;
-  if (!Array.isArray(result)) {
-    throw new TypeError("Qdrant query response must include a result array");
-  }
-  const hits = result.map((entry, index) => {
-    const idValue = entry.id;
-    const idCandidate = typeof idValue === "number" ? String(idValue) : idValue;
-    const id = toNonEmptyString(idCandidate);
-    if (!id) {
-      throw new Error(`Qdrant query response entry at index ${index} is missing a non-empty id`);
-    }
-    const score = entry.score;
-    if (typeof score !== "number" || !Number.isFinite(score)) {
-      throw new TypeError(`Qdrant query response entry at index ${index} is missing a finite numeric score`);
-    }
-    const payloadValue = entry.payload;
-    if (payloadValue !== void 0 && (typeof payloadValue !== "object" || payloadValue === null || Array.isArray(payloadValue))) {
-      throw new Error(`Qdrant query response entry at index ${index} must provide payload as an object when set`);
-    }
-    return {
-      id,
-      score,
-      ...payloadValue ? { payload: payloadValue } : {}
-    };
-  });
-  hits.sort((left, right) => {
-    if (left.score !== right.score) {
-      return right.score - left.score;
-    }
-    return left.id.localeCompare(right.id);
-  });
-  return hits;
-}
-function normalizeQdrantUpsertResponse(payload) {
-  const nestedStatus = toNonEmptyString(payload.result?.status);
-  if (nestedStatus) {
-    return { status: nestedStatus };
-  }
-  const topLevelStatus = toNonEmptyString(payload.status);
-  if (topLevelStatus) {
-    return { status: topLevelStatus };
-  }
-  throw new Error("Qdrant upsert response must include status metadata");
-}
-async function executeRemoteVectorPlan(endpoint, plan, timeoutMs, fetcher, requestKind) {
-  return await executeSearchJsonRequest({
-    endpoint,
-    method: plan.method,
-    headers: plan.headers,
-    body: plan.body,
-    timeoutMs,
-    fetcher,
-    requestLabel: `Vector ${requestKind} request`,
-    responseLabel: `Vector ${requestKind} response`
-  });
-}
-function resolveQdrantStore(settings) {
-  const url = toNonEmptyString(settings.vector_store?.qdrant?.url);
-  if (!url) {
-    return null;
-  }
-  const collectionName = toNonEmptyString(settings.vector_store?.collection_name);
-  const apiKey = toNonEmptyString(settings.vector_store?.qdrant?.api_key);
-  return {
-    name: "qdrant",
-    url,
-    ...collectionName && collectionName !== DEFAULT_COLLECTION ? { collection_name: collectionName } : {},
-    ...apiKey ? { api_key: apiKey } : {}
-  };
-}
-function resolveLanceDbStore(settings) {
-  const lancedbPath = toNonEmptyString(settings.vector_store?.lancedb?.path);
-  if (!lancedbPath) {
-    return null;
-  }
-  const collectionName = toNonEmptyString(settings.vector_store?.collection_name);
-  return {
-    name: "lancedb",
-    path: lancedbPath,
-    ...collectionName && collectionName !== DEFAULT_COLLECTION ? { collection_name: collectionName } : {}
-  };
-}
-function normalizeVectorRecords(records) {
-  if (!Array.isArray(records) || records.length === 0) {
-    throw new Error("Vector upsert records must include at least one entry");
-  }
-  return records.map((record, index) => {
-    const id = toNonEmptyString(record.id);
-    if (!id) {
-      throw new Error(`Vector upsert record at index ${index} is missing a non-empty id`);
-    }
-    const vector = normalizeVector(record.vector);
-    const payload = record.payload;
-    if (payload !== void 0 && (typeof payload !== "object" || payload === null || Array.isArray(payload))) {
-      throw new Error(`Vector upsert record at index ${index} must provide payload as an object when set`);
-    }
-    return {
-      id,
-      vector,
-      ...payload ? { payload } : {}
-    };
-  });
-}
-function normalizeVectorDeleteIds(ids) {
-  if (!Array.isArray(ids) || ids.length === 0) {
-    throw new Error("Vector delete ids must include at least one entry");
-  }
-  const normalizedIds = ids.map((id, index) => {
-    const normalized = toNonEmptyString(id);
-    if (!normalized) {
-      throw new Error(`Vector delete id at index ${index} is missing a non-empty value`);
-    }
-    return normalized;
-  }).sort((left, right) => left.localeCompare(right));
-  const uniqueIds = [];
-  for (const id of normalizedIds) {
-    if (uniqueIds.at(-1) !== id) {
-      uniqueIds.push(id);
-    }
-  }
-  return uniqueIds;
-}
-function resolveQdrantDeleteTarget(upsertTarget) {
-  return upsertTarget.replace(/\/points\?wait=true$/, "/points/delete?wait=true");
-}
-function resolveQdrantCollectionTarget(upsertTarget) {
-  return upsertTarget.replace(/\/points\?wait=true$/, "");
-}
-function buildQdrantJsonHeaders(store) {
-  return {
-    "content-type": "application/json",
-    ...store.api_key ? { "api-key": store.api_key } : {}
-  };
-}
-function getLanceDbLocalTableKey(storePath, table) {
-  return getLanceDbSnapshotPath(storePath, table);
-}
-function getLanceDbSnapshotPath(storePath, table) {
-  return join(resolve(storePath), LANCE_DB_LOCAL_SNAPSHOT_DIR, `${table}.json`);
-}
-function isNodeErrorWithCode(error, code) {
-  return typeof error === "object" && error !== null && error.code === code;
-}
-function normalizeSnapshotRecord(entry, index, snapshotPath) {
-  const id = toNonEmptyString(entry.id);
-  if (!id) {
-    throw new Error(`LanceDB local snapshot '${snapshotPath}' record at index ${index} is missing a non-empty id`);
-  }
-  const vector = normalizeVector(entry.vector);
-  const payload = entry.payload;
-  if (payload !== void 0 && (typeof payload !== "object" || payload === null || Array.isArray(payload))) {
-    throw new Error(`LanceDB local snapshot '${snapshotPath}' record '${id}' must provide payload as an object when set`);
-  }
-  return {
-    id,
-    vector,
-    ...payload ? { payload } : {}
-  };
-}
-function parseLanceDbSnapshot(snapshotPath, expectedTable, raw) {
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch (error) {
-    throw new Error(`LanceDB local snapshot at '${snapshotPath}' is not valid JSON: ${toErrorMessage(error)}`);
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new Error(`LanceDB local snapshot at '${snapshotPath}' must be a JSON object`);
-  }
-  const version = parsed.version;
-  if (version !== LANCE_DB_LOCAL_SNAPSHOT_VERSION) {
-    throw new Error(`LanceDB local snapshot at '${snapshotPath}' must include version=${LANCE_DB_LOCAL_SNAPSHOT_VERSION}`);
-  }
-  const table = toNonEmptyString(parsed.table);
-  if (!table) {
-    throw new Error(`LanceDB local snapshot at '${snapshotPath}' must include a non-empty table value`);
-  }
-  if (table !== expectedTable) {
-    throw new Error(`LanceDB local snapshot at '${snapshotPath}' table mismatch: expected '${expectedTable}', received '${table}'`);
-  }
-  const recordsValue = parsed.records;
-  if (!Array.isArray(recordsValue)) {
-    throw new TypeError(`LanceDB local snapshot at '${snapshotPath}' must include a records array`);
-  }
-  const tableRecords = /* @__PURE__ */ new Map();
-  for (let index = 0; index < recordsValue.length; index += 1) {
-    const record = normalizeSnapshotRecord(recordsValue[index], index, snapshotPath);
-    tableRecords.set(record.id, record);
-  }
-  return tableRecords;
-}
-async function readLanceDbSnapshotStats(snapshotPath) {
-  try {
-    const stats = await stat(snapshotPath);
-    return { mtimeMs: stats.mtimeMs, size: stats.size };
-  } catch (error) {
-    if (!isNodeErrorWithCode(error, "ENOENT")) {
-      throw error;
-    }
-    return null;
-  }
-}
-function resolveMissingLanceDbSnapshotCache(key, cached) {
-  if (!cached) {
-    return null;
-  }
-  if (cached.mtimeMs === null && cached.size === null && cached.records.size === 0) {
-    return cached.records;
-  }
-  const loaded = /* @__PURE__ */ new Map();
-  lanceDbLocalTables.set(key, { records: loaded, mtimeMs: null, size: null });
-  return loaded;
-}
-function cachedLanceDbSnapshotMatches(cached, snapshotStats) {
-  return cached !== void 0 && snapshotStats !== null && cached.mtimeMs === snapshotStats.mtimeMs && cached.size === snapshotStats.size;
-}
-async function loadLanceDbLocalTable(storePath, table) {
-  const key = getLanceDbLocalTableKey(storePath, table);
-  const snapshotPath = getLanceDbSnapshotPath(storePath, table);
-  const snapshotStats = await readLanceDbSnapshotStats(snapshotPath);
-  const cached = lanceDbLocalTables.get(key);
-  if (!snapshotStats) {
-    const resolved = resolveMissingLanceDbSnapshotCache(key, cached);
-    if (resolved) {
-      return resolved;
-    }
-  }
-  if (cachedLanceDbSnapshotMatches(cached, snapshotStats)) {
-    return cached.records;
-  }
-  let loaded = /* @__PURE__ */ new Map();
-  try {
-    const raw = await readFile(snapshotPath, "utf8");
-    loaded = parseLanceDbSnapshot(snapshotPath, table, raw);
-  } catch (error) {
-    if (!isNodeErrorWithCode(error, "ENOENT")) {
-      throw error;
-    }
-  }
-  lanceDbLocalTables.set(key, {
-    records: loaded,
-    mtimeMs: snapshotStats?.mtimeMs ?? null,
-    size: snapshotStats?.size ?? null
-  });
-  return loaded;
-}
-function buildSnapshotRecords(table) {
-  const records = [...table.values()];
-  records.sort((left, right) => left.id.localeCompare(right.id));
-  return records.map((record) => ({
-    id: record.id,
-    vector: [...record.vector],
-    ...record.payload ? { payload: record.payload } : {}
-  }));
-}
-async function removeSnapshotFile(snapshotPath) {
-  try {
-    await unlink(snapshotPath);
-  } catch (error) {
-    if (!isNodeErrorWithCode(error, "ENOENT")) {
-      throw new Error(`LanceDB local snapshot delete failed at '${snapshotPath}': ${toErrorMessage(error)}`);
-    }
-  }
-}
-async function persistLanceDbLocalTable(storePath, tableName, table) {
-  const snapshotPath = getLanceDbSnapshotPath(storePath, tableName);
-  if (table.size === 0) {
-    await removeSnapshotFile(snapshotPath);
-    return;
-  }
-  const snapshotDir = dirname(snapshotPath);
-  try {
-    await mkdir(snapshotDir, { recursive: true });
-  } catch (error) {
-    throw new Error(`LanceDB local snapshot directory create failed at '${snapshotDir}': ${toErrorMessage(error)}`);
-  }
-  const serialized = `${JSON.stringify({
-    version: LANCE_DB_LOCAL_SNAPSHOT_VERSION,
-    table: tableName,
-    records: buildSnapshotRecords(table)
-  })}
-`;
-  try {
-    await writeFileAtomic(snapshotPath, serialized);
-  } catch (error) {
-    throw new Error(`LanceDB local snapshot write failed at '${snapshotPath}': ${toErrorMessage(error)}`);
-  }
-}
-async function resetLanceDbLocalTable(storePath, tableName) {
-  const key = getLanceDbLocalTableKey(storePath, tableName);
-  const snapshotPath = getLanceDbSnapshotPath(storePath, tableName);
-  await removeSnapshotFile(snapshotPath);
-  lanceDbLocalTables.delete(key);
-}
-function l2Norm(vector) {
-  let sumSq = 0;
-  for (let index = 0; index < vector.length; index += 1) {
-    sumSq += vector[index] * vector[index];
-  }
-  return Math.sqrt(sumSq);
-}
-function cosineSimilarity(left, right) {
-  let dotProd = 0;
-  for (let index = 0; index < left.length; index += 1) {
-    dotProd += left[index] * right[index];
-  }
-  const leftNorm = l2Norm(left);
-  const rightNorm = l2Norm(right);
-  if (leftNorm === 0 || rightNorm === 0) {
-    return 0;
-  }
-  return dotProd / (leftNorm * rightNorm);
-}
-function resolveVectorStores(settings) {
-  const qdrant = resolveQdrantStore(settings);
-  const lancedb = resolveLanceDbStore(settings);
-  const available = [qdrant, lancedb].filter((entry) => entry !== null);
-  const preferredName = toNonEmptyString(settings.vector_store?.adapter);
-  const preferredKey = preferredName ? preferredName.toLowerCase() : null;
-  const preferred = preferredKey ? available.find((entry) => entry.name === preferredKey) : void 0;
-  return {
-    active: preferred ?? available[0] ?? null,
-    available
-  };
-}
-function resolveVectorStoreRequestTarget(store) {
-  const collectionName = resolveStoreCollectionName(store);
-  if (store.name === "qdrant") {
-    const baseUrl = trimTrailingSlashes(store.url);
-    const encodedCollection2 = encodeURIComponent(collectionName);
-    return {
-      store: "qdrant",
-      query_target: `${baseUrl}/collections/${encodedCollection2}/points/search`,
-      upsert_target: `${baseUrl}/collections/${encodedCollection2}/points?wait=true`
-    };
-  }
-  const encodedPath = encodeURIComponent(store.path);
-  const encodedCollection = encodeURIComponent(collectionName);
-  return {
-    store: "lancedb",
-    query_target: `lancedb://${encodedPath}#${encodedCollection}`,
-    upsert_target: `lancedb://${encodedPath}#${encodedCollection}`
-  };
-}
-function buildVectorQueryPlan(store, vector, limit) {
-  const target = resolveVectorStoreRequestTarget(store);
-  const normalizedVector = normalizeVector(vector);
-  const normalizedLimit = normalizeLimit(limit);
-  if (store.name === "qdrant") {
-    return {
-      target,
-      method: "POST",
-      headers: buildQdrantJsonHeaders(store),
-      body: {
-        vector: normalizedVector,
-        limit: normalizedLimit,
-        with_payload: true
-      }
-    };
-  }
-  return {
-    target,
-    method: "LOCAL",
-    headers: {},
-    body: {
-      table: resolveStoreCollectionName(store),
-      vector: normalizedVector,
-      limit: normalizedLimit
-    }
-  };
-}
-function buildVectorUpsertPlan(store, records) {
-  const target = resolveVectorStoreRequestTarget(store);
-  const normalizedRecords = normalizeVectorRecords(records);
-  if (store.name === "qdrant") {
-    return {
-      target,
-      method: "POST",
-      headers: buildQdrantJsonHeaders(store),
-      body: {
-        points: normalizedRecords
-      }
-    };
-  }
-  return {
-    target,
-    method: "LOCAL",
-    headers: {},
-    body: {
-      table: resolveStoreCollectionName(store),
-      records: normalizedRecords
-    }
-  };
-}
-function buildVectorDeletePlan(store, ids) {
-  const target = resolveVectorStoreRequestTarget(store);
-  const normalizedIds = normalizeVectorDeleteIds(ids);
-  if (store.name === "qdrant") {
-    return {
-      target,
-      method: "POST",
-      headers: buildQdrantJsonHeaders(store),
-      body: {
-        points: normalizedIds
-      }
-    };
-  }
-  return {
-    target,
-    method: "LOCAL",
-    headers: {},
-    body: {
-      table: resolveStoreCollectionName(store),
-      ids: normalizedIds
-    }
-  };
-}
-async function executeVectorQuery(store, vector, limit, options = {}) {
-  const plan = buildVectorQueryPlan(store, vector, limit);
-  if (plan.method === "LOCAL") {
-    const lanceDbStore = store;
-    const queryBody = plan.body;
-    const table = await loadLanceDbLocalTable(lanceDbStore.path, queryBody.table);
-    if (table.size === 0) {
-      return [];
-    }
-    const queryVector = normalizeVector(queryBody.vector);
-    const queryLimit = normalizeLimit(queryBody.limit);
-    const hits = [];
-    let dimensionMismatchCount = 0;
-    for (const record of table.values()) {
-      if (record.vector.length !== queryVector.length) {
-        dimensionMismatchCount++;
-        continue;
-      }
-      hits.push({
-        id: record.id,
-        score: cosineSimilarity(queryVector, record.vector),
-        ...record.payload ? { payload: record.payload } : {}
-      });
-    }
-    if (dimensionMismatchCount > 0 && options.warnings) {
-      options.warnings.push(`vector_dimension_mismatch:${dimensionMismatchCount} records skipped (expected ${queryVector.length} dimensions)`);
-    }
-    hits.sort((left, right) => {
-      if (left.score !== right.score) {
-        return right.score - left.score;
-      }
-      return left.id.localeCompare(right.id);
-    });
-    return hits.slice(0, queryLimit);
-  }
-  const timeoutMs = normalizeSearchHttpTimeoutMs(options.timeout_ms, "Vector request");
-  const fetcher = resolveSearchHttpFetcher(options.fetcher, "Vector request");
-  const payload = await executeRemoteVectorPlan(plan.target.query_target, {
-    method: "POST",
-    headers: plan.headers,
-    body: plan.body
-  }, timeoutMs, fetcher, "query");
-  return normalizeQdrantQueryResponse(payload);
-}
-async function executeVectorUpsert(store, records, options = {}) {
-  const plan = buildVectorUpsertPlan(store, records);
-  if (plan.method === "LOCAL") {
-    const lanceDbStore = store;
-    const upsertBody = plan.body;
-    const key = getLanceDbLocalTableKey(lanceDbStore.path, upsertBody.table);
-    const table = await loadLanceDbLocalTable(lanceDbStore.path, upsertBody.table);
-    for (const record of upsertBody.records) {
-      table.set(record.id, record);
-    }
-    await persistLanceDbLocalTable(lanceDbStore.path, upsertBody.table, table);
-    const snapshotPath = getLanceDbSnapshotPath(lanceDbStore.path, upsertBody.table);
-    const snapshotStats = await stat(snapshotPath);
-    lanceDbLocalTables.set(key, {
-      records: table,
-      mtimeMs: snapshotStats.mtimeMs,
-      size: snapshotStats.size
-    });
-    return { status: "ok" };
-  }
-  const timeoutMs = normalizeSearchHttpTimeoutMs(options.timeout_ms, "Vector request");
-  const fetcher = resolveSearchHttpFetcher(options.fetcher, "Vector request");
-  const payload = await executeRemoteVectorPlan(plan.target.upsert_target, {
-    method: "POST",
-    headers: plan.headers,
-    body: plan.body
-  }, timeoutMs, fetcher, "upsert");
-  return normalizeQdrantUpsertResponse(payload);
-}
-async function executeVectorDelete(store, ids, options = {}) {
-  const plan = buildVectorDeletePlan(store, ids);
-  if (plan.method === "LOCAL") {
-    const lanceDbStore = store;
-    const deleteBody = plan.body;
-    const key = getLanceDbLocalTableKey(lanceDbStore.path, deleteBody.table);
-    const table = await loadLanceDbLocalTable(lanceDbStore.path, deleteBody.table);
-    if (table.size === 0) {
-      return { status: "ok" };
-    }
-    for (const id of deleteBody.ids) {
-      table.delete(id);
-    }
-    await persistLanceDbLocalTable(lanceDbStore.path, deleteBody.table, table);
-    if (table.size === 0) {
-      lanceDbLocalTables.delete(key);
-    } else {
-      const snapshotPath = getLanceDbSnapshotPath(lanceDbStore.path, deleteBody.table);
-      const snapshotStats = await stat(snapshotPath);
-      lanceDbLocalTables.set(key, {
-        records: table,
-        mtimeMs: snapshotStats.mtimeMs,
-        size: snapshotStats.size
-      });
-    }
-    return { status: "ok" };
-  }
-  const timeoutMs = normalizeSearchHttpTimeoutMs(options.timeout_ms, "Vector request");
-  const fetcher = resolveSearchHttpFetcher(options.fetcher, "Vector request");
-  const payload = await executeRemoteVectorPlan(resolveQdrantDeleteTarget(plan.target.upsert_target), {
-    method: "POST",
-    headers: plan.headers,
-    body: plan.body
-  }, timeoutMs, fetcher, "delete");
-  return normalizeQdrantUpsertResponse(payload);
-}
-async function executeVectorReset(store, knownIds = [], options = {}, vectorDimension) {
-  if (store.name === "lancedb") {
-    await resetLanceDbLocalTable(store.path, resolveStoreCollectionName(store));
-    return { status: "ok" };
-  }
-  if (vectorDimension !== void 0) {
-    if (!Number.isInteger(vectorDimension) || vectorDimension <= 0) {
-      throw new Error("Vector reset dimension must be a positive integer when provided");
-    }
-    const target = resolveVectorStoreRequestTarget(store);
-    const collectionTarget = resolveQdrantCollectionTarget(target.upsert_target);
-    const timeoutMs = normalizeSearchHttpTimeoutMs(options.timeout_ms, "Vector request");
-    const fetcher = resolveSearchHttpFetcher(options.fetcher, "Vector request");
-    const headers = buildQdrantJsonHeaders(store);
-    try {
-      await executeRemoteVectorPlan(collectionTarget, {
-        method: "DELETE",
-        headers,
-        body: {}
-      }, timeoutMs, fetcher, "delete");
-    } catch (error) {
-      if (!toErrorMessage(error).includes("failed with status 404")) {
-        throw error;
-      }
-    }
-    const payload = await executeRemoteVectorPlan(collectionTarget, {
-      method: "PUT",
-      headers,
-      body: {
-        vectors: {
-          size: vectorDimension,
-          distance: "Cosine"
-        }
-      }
-    }, timeoutMs, fetcher, "upsert");
-    return normalizeQdrantUpsertResponse(payload);
-  }
-  const idsToDelete = knownIds.map((id) => id.trim()).filter((id) => id.length > 0);
-  if (idsToDelete.length === 0) {
-    return { status: "ok" };
-  }
-  return await executeVectorDelete(store, idsToDelete, options);
-}
-
-// dist/core/search/vectorization-metadata.js
-function buildVectorizationEmbeddingIdentity(provider, model) {
-  const normalizedProvider = toNonEmptyString(provider);
-  const normalizedModel = toNonEmptyString(model);
-  if (!normalizedProvider || !normalizedModel) {
-    return null;
-  }
-  return {
-    provider: normalizedProvider,
-    model: normalizedModel
-  };
-}
-function normalizeVectorizationEmbeddingMetadata(value) {
-  if (value === void 0 || value === null) {
-    return null;
-  }
-  if (typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("Vectorization embedding metadata must be an object when set");
-  }
-  const identity = buildVectorizationEmbeddingIdentity(value.provider, value.model);
-  const vectorDimension = value.vector_dimension;
-  if (!identity || typeof vectorDimension !== "number" || !Number.isInteger(vectorDimension) || vectorDimension <= 0) {
-    throw new Error("Vectorization embedding metadata must include provider, model, and positive vector_dimension");
-  }
-  return {
-    ...identity,
-    vector_dimension: vectorDimension
-  };
-}
-function buildVectorizationEmbeddingMetadata(identity, vectorDimension) {
-  if (!Number.isInteger(vectorDimension) || vectorDimension <= 0) {
-    throw new Error("Vectorization embedding metadata requires a positive vector dimension");
-  }
-  return {
-    provider: identity.provider,
-    model: identity.model,
-    vector_dimension: vectorDimension
-  };
-}
-function hasVectorizationEmbeddingIdentityChanged(metadata, identity) {
-  return !metadata || metadata.provider !== identity.provider || metadata.model !== identity.model;
-}
-function hasVectorizationVectorDimensionChanged(metadata, vectorDimension) {
-  return Boolean(metadata && metadata.vector_dimension !== vectorDimension);
-}
-function inferConsistentVectorDimension(vectors, context) {
-  if (vectors.length === 0) {
-    throw new Error(`${context} returned no vectors`);
-  }
-  const firstVector = vectors[0];
-  const dimension = firstVector.length;
-  if (!Number.isInteger(dimension) || dimension <= 0) {
-    throw new Error(`${context} returned an empty vector`);
-  }
-  for (let index = 1; index < vectors.length; index += 1) {
-    if (vectors[index]?.length !== dimension) {
-      throw new Error(`${context} returned mixed vector dimensions`);
-    }
-  }
-  return dimension;
-}
-
-// dist/core/search/cache.js
-import path2 from "node:path";
-
-// dist/core/search/embedding-batches.js
-function resolveBatchRuntime(settings, maxInputCharacters) {
-  const batchSizeCandidate = settings.search.embedding_batch_size;
-  const timeoutMsCandidate = settings.search.embedding_timeout_ms;
-  const maxRetriesCandidate = settings.search.scanner_max_batch_retries;
-  const batchSize = Number.isFinite(batchSizeCandidate) && batchSizeCandidate > 0 ? Math.floor(batchSizeCandidate) : 1;
-  const timeoutMs = Number.isFinite(timeoutMsCandidate) && timeoutMsCandidate > 0 ? Math.floor(timeoutMsCandidate) : 3e4;
-  const maxRetries = Number.isFinite(maxRetriesCandidate) && maxRetriesCandidate >= 0 ? Math.floor(maxRetriesCandidate) : 0;
-  return {
-    batchSize,
-    timeoutMs,
-    maxRetries,
-    maxBatchInputCharacters: Number.POSITIVE_INFINITY,
-    maxInputCharacters
-  };
-}
-function createBatches(inputs, batchSize, maxBatchInputCharacters) {
-  const batches = [];
-  let currentBatch = [];
-  let currentCharacters = 0;
-  for (const input of inputs) {
-    const wouldExceedCount = currentBatch.length >= batchSize;
-    const wouldExceedCharacters = currentBatch.length > 0 && Number.isFinite(maxBatchInputCharacters) && currentCharacters + input.length > maxBatchInputCharacters;
-    if (wouldExceedCount || wouldExceedCharacters) {
-      batches.push(currentBatch);
-      currentBatch = [];
-      currentCharacters = 0;
-    }
-    currentBatch.push(input);
-    currentCharacters += input.length;
-  }
-  batches.push(currentBatch);
-  return batches;
-}
-function resolveProviderBatchRuntime(provider, runtime) {
-  if (provider.name !== "ollama") {
-    return runtime;
-  }
-  return {
-    ...runtime,
-    maxBatchInputCharacters: OLLAMA_SEMANTIC_CORPUS_INPUT_MAX_CHARACTERS
-  };
-}
-function truncateInputForRuntime(input, maxInputCharacters) {
-  if (!Number.isFinite(maxInputCharacters) || maxInputCharacters <= 0 || input.length <= maxInputCharacters) {
-    return input;
-  }
-  const keepLength = Math.max(0, maxInputCharacters - SEMANTIC_CORPUS_TRUNCATION_SUFFIX.length);
-  return `${input.slice(0, keepLength)}${SEMANTIC_CORPUS_TRUNCATION_SUFFIX}`.slice(0, maxInputCharacters);
-}
-function isEmbeddingTimeoutError(error) {
-  const message = toErrorMessage(error).toLowerCase();
-  return message.includes("timed out") || message.includes("timeout");
-}
-function buildEmbeddingFailureMessage(provider, batchLabel, batchSize, timeoutMs, attempts, error) {
-  const base = `Embedding batch ${batchLabel} failed after ${attempts} attempt(s): ${toErrorMessage(error)}`;
-  const details = `provider=${provider.name} model=${provider.model} batch_size=${batchSize} timeout_ms=${timeoutMs}`;
-  if (!isEmbeddingTimeoutError(error)) {
-    return `${base} (${details})`;
-  }
-  return `${base} (${details}; guidance=check provider availability or lower search.embedding_batch_size, raise search.embedding_timeout_ms, or run keyword search while semantic indexing catches up)`;
-}
-async function executeBatchWithAdaptiveSplit(provider, batch, batchLabel, timeoutMs, maxRetries, warnings) {
-  let lastError = null;
-  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
-    try {
-      const batchVectors = await executeEmbeddingRequest(provider, batch, { timeout_ms: timeoutMs });
-      if (attempt > 0) {
-        warnings.push(`search_embedding_batch_retry_succeeded:batch=${batchLabel}:attempt=${attempt + 1}:size=${batch.length}`);
-      }
-      return batchVectors;
-    } catch (error) {
-      lastError = error;
-      if (isEmbeddingTimeoutError(error) && batch.length > 1) {
-        const midpoint = Math.ceil(batch.length / 2);
-        const left = batch.slice(0, midpoint);
-        const right = batch.slice(midpoint);
-        warnings.push(`search_embedding_batch_split_after_timeout:batch=${batchLabel}:size=${batch.length}:parts=${left.length}|${right.length}`);
-        return [
-          ...await executeBatchWithAdaptiveSplit(provider, left, `${batchLabel}.1`, timeoutMs, maxRetries, warnings),
-          ...await executeBatchWithAdaptiveSplit(provider, right, `${batchLabel}.2`, timeoutMs, maxRetries, warnings)
-        ];
-      }
-      if (attempt < maxRetries) {
-        const delayMs = Math.min(1e3 * 2 ** attempt, 8e3);
-        await new Promise((resolve2) => setTimeout(resolve2, delayMs));
-      }
-    }
-  }
-  throw new Error(buildEmbeddingFailureMessage(provider, batchLabel, batch.length, timeoutMs, maxRetries + 1, lastError));
-}
-async function executeEmbeddingBatchesWithRetry(provider, settings, inputs, options = {}) {
-  if (inputs.length === 0) {
-    return {
-      vectors: [],
-      warnings: []
-    };
-  }
-  const warnings = [];
-  const corpusLimitResolution = resolveSemanticCorpusCharacterLimit(provider.name, settings.search.embedding_corpus_max_characters);
-  if (corpusLimitResolution.warning) {
-    warnings.push(corpusLimitResolution.warning);
-  }
-  const runtime = resolveProviderBatchRuntime(provider, resolveBatchRuntime(settings, corpusLimitResolution.maxCharacters));
-  let truncatedInputCount = 0;
-  const normalizedInputs = inputs.map((input) => {
-    const normalized = truncateInputForRuntime(input, runtime.maxInputCharacters);
-    if (normalized.length < input.length) {
-      truncatedInputCount += 1;
-    }
-    return normalized;
-  });
-  if (truncatedInputCount > 0) {
-    warnings.push(`search_embedding_input_truncated:count=${truncatedInputCount}:max_characters=${runtime.maxInputCharacters}`);
-  }
-  const batches = createBatches(normalizedInputs, runtime.batchSize, runtime.maxBatchInputCharacters);
-  const vectors = [];
-  let completedInputs = 0;
-  for (let batchIndex = 0; batchIndex < batches.length; batchIndex += 1) {
-    const batch = batches[batchIndex];
-    options.onProgress?.({
-      batch_index: batchIndex + 1,
-      batch_total: batches.length,
-      batch_size: batch.length,
-      completed_inputs: completedInputs,
-      total_inputs: normalizedInputs.length,
-      phase: "start"
-    });
-    vectors.push(...await executeBatchWithAdaptiveSplit(provider, batch, String(batchIndex + 1), runtime.timeoutMs, runtime.maxRetries, warnings));
-    completedInputs += batch.length;
-    options.onProgress?.({
-      batch_index: batchIndex + 1,
-      batch_total: batches.length,
-      batch_size: batch.length,
-      completed_inputs: completedInputs,
-      total_inputs: normalizedInputs.length,
-      phase: "complete"
-    });
-  }
-  return {
-    vectors,
-    warnings
-  };
-}
-
-// dist/core/search/background-refresh.js
-import { spawn } from "node:child_process";
-import { mkdirSync, rmSync, statSync } from "node:fs";
-import path from "node:path";
-var REINDEX_LOCK_ID = "reindex";
-var PENDING_QUEUE_REL_PATH = "search/pending-refresh.json";
-var PENDING_QUEUE_GATE_REL_PATH = "search/pending-refresh.gate.lock";
-var PENDING_QUEUE_GATE_STALE_MS = 3e4;
-var SEARCH_REFRESH_INLINE_ENV = "PM_SEARCH_REFRESH_INLINE";
-var SEARCH_REFRESH_CHILD_ENV = "PM_SEARCH_REFRESH_CHILD";
-function parseBooleanTrueLike(value) {
-  if (typeof value !== "string") {
-    return false;
-  }
-  const normalized = value.trim().toLowerCase();
-  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
-}
-function shouldRunSearchRefreshInForeground() {
-  if (parseBooleanTrueLike(process.env[SEARCH_REFRESH_INLINE_ENV])) {
-    return true;
-  }
-  if (parseBooleanTrueLike(process.env[SEARCH_REFRESH_CHILD_ENV])) {
-    return true;
-  }
-  const nodeEnv = (process.env.NODE_ENV ?? "").trim().toLowerCase();
-  return typeof process.env.VITEST === "string" || typeof process.env.VITEST_WORKER_ID === "string" || nodeEnv === "test";
-}
-function pendingQueuePath(pmRoot) {
-  return path.join(pmRoot, PENDING_QUEUE_REL_PATH);
-}
-function pendingQueueGatePath(pmRoot) {
-  return path.join(pmRoot, PENDING_QUEUE_GATE_REL_PATH);
-}
-function acquireQueueGate(pmRoot) {
-  const gatePath = pendingQueueGatePath(pmRoot);
-  try {
-    if (Date.now() - statSync(gatePath).mtimeMs < PENDING_QUEUE_GATE_STALE_MS) {
-      return false;
-    }
-    rmSync(gatePath, { recursive: true, force: true });
-  } catch {
-  }
-  try {
-    mkdirSync(path.dirname(gatePath), { recursive: true });
-    mkdirSync(gatePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function releaseQueueGate(pmRoot) {
-  try {
-    rmSync(pendingQueueGatePath(pmRoot), { recursive: true, force: true });
-  } catch {
-  }
-}
-async function withQueueGate(pmRoot, fn, fallback) {
-  for (let attempt = 0; attempt < 50; attempt += 1) {
-    if (acquireQueueGate(pmRoot)) {
-      try {
-        return await fn();
-      } finally {
-        releaseQueueGate(pmRoot);
-      }
-    }
-    await delay(20);
-  }
-  return fallback;
-}
-function delay(ms) {
-  return new Promise((resolve2) => {
-    setTimeout(resolve2, ms);
-  });
-}
-async function readPendingQueueIds(pmRoot) {
-  const raw = await readFileIfExists(pendingQueuePath(pmRoot));
-  if (!raw || raw.trim().length === 0) {
-    return [];
-  }
-  try {
-    const parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed.ids)) {
-      return [];
-    }
-    return parsed.ids.filter((id) => typeof id === "string" && id.length > 0);
-  } catch {
-    return [];
-  }
-}
-async function writePendingQueueIds(pmRoot, ids) {
-  await writeFileAtomic(pendingQueuePath(pmRoot), `${JSON.stringify({ ids })}
-`);
-}
-async function enqueuePendingRefreshIds(pmRoot, itemIds) {
-  const incoming = itemIds.filter((id) => typeof id === "string" && id.trim().length > 0);
-  if (incoming.length === 0) {
-    return;
-  }
-  const mergeIncoming = async () => {
-    const existing = await readPendingQueueIds(pmRoot);
-    const merged = [.../* @__PURE__ */ new Set([...existing, ...incoming])].sort((left, right) => left.localeCompare(right));
-    await writePendingQueueIds(pmRoot, merged);
-  };
-  const gated = await withQueueGate(pmRoot, async () => {
-    await mergeIncoming();
-    return true;
-  }, false);
-  if (!gated) {
-    await mergeIncoming();
-  }
-}
-function searchRefreshRunnerPath() {
-  return path.join(resolvePmPackageRootFromModule(import.meta.url, ["../../.."]), "dist", "cli", "search-refresh.js");
-}
-function dispatchRefreshChild(pmRoot) {
-  try {
-    const child = spawn(process.execPath, [searchRefreshRunnerPath()], {
-      detached: true,
-      stdio: "ignore",
-      env: {
-        ...process.env,
-        PM_PATH: pmRoot,
-        [SEARCH_REFRESH_CHILD_ENV]: "1"
-      }
-    });
-    child.on("error", () => {
-    });
-    child.unref();
-  } catch {
-  }
-}
-async function scheduleBackgroundSemanticRefresh(pmRoot, itemIds) {
-  await enqueuePendingRefreshIds(pmRoot, itemIds);
-  dispatchRefreshChild(pmRoot);
-}
-
-// dist/core/search/cache.js
-var SEARCH_CACHE_ARTIFACT_PATHS = ["index/manifest.json", "search/embeddings.jsonl"];
-var VECTORIZATION_STATUS_LEDGER_PATH = "search/vectorization-status.json";
-function formatInvalidationWarning(relativePath, error) {
-  return `search_cache_invalidation_failed:${relativePath}:${String(error)}`;
-}
-function toUniqueSorted(values) {
-  return [...new Set([...values].map((value) => value.trim()).filter((value) => value.length > 0))].sort((left, right) => left.localeCompare(right));
-}
-function isValidUpdatedAt(value) {
-  return typeof value === "string" && value.trim().length > 0 && Number.isFinite(Date.parse(value));
-}
-function normalizeVectorizationLedgerEntries(entries) {
-  const normalized = /* @__PURE__ */ new Map();
-  for (const [rawId, rawUpdatedAt] of Object.entries(entries)) {
-    const id = rawId.trim();
-    if (id.length === 0 || !isValidUpdatedAt(rawUpdatedAt)) {
-      continue;
-    }
-    normalized.set(id, rawUpdatedAt);
-  }
-  return Object.fromEntries([...normalized.entries()].sort((left, right) => left[0].localeCompare(right[0])));
-}
-async function readVectorizationStatusLedger(pmRoot) {
-  const ledgerPath = path2.join(pmRoot, VECTORIZATION_STATUS_LEDGER_PATH);
-  const raw = await readFileIfExists(ledgerPath);
-  if (raw === null || raw.trim().length === 0) {
-    return {
-      entries: {},
-      embedding: null,
-      warnings: []
-    };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return {
-      entries: {},
-      embedding: null,
-      warnings: ["search_vectorization_status_ledger_invalid"]
-    };
-  }
-  if (typeof parsed !== "object" || parsed === null || parsed.version !== 1 || !Array.isArray(parsed.items)) {
-    return {
-      entries: {},
-      embedding: null,
-      warnings: ["search_vectorization_status_ledger_invalid"]
-    };
-  }
-  const mapped = /* @__PURE__ */ new Map();
-  for (const entry of parsed.items) {
-    if (typeof entry !== "object" || entry === null) {
-      return {
-        entries: {},
-        embedding: null,
-        warnings: ["search_vectorization_status_ledger_invalid"]
-      };
-    }
-    const id = entry.id;
-    const updatedAt = entry.updated_at;
-    if (typeof id !== "string" || id.trim().length === 0 || !isValidUpdatedAt(updatedAt)) {
-      return {
-        entries: {},
-        embedding: null,
-        warnings: ["search_vectorization_status_ledger_invalid"]
-      };
-    }
-    mapped.set(id.trim(), updatedAt);
-  }
-  let embedding = null;
-  try {
-    embedding = normalizeVectorizationEmbeddingMetadata(parsed.embedding);
-  } catch {
-    return {
-      entries: {},
-      embedding: null,
-      warnings: ["search_vectorization_status_ledger_invalid"]
-    };
-  }
-  return {
-    entries: Object.fromEntries([...mapped.entries()].sort((left, right) => left[0].localeCompare(right[0]))),
-    embedding,
-    warnings: []
-  };
-}
-async function writeVectorizationStatusLedger(pmRoot, entries, embedding) {
-  const normalizedEntries = normalizeVectorizationLedgerEntries(entries);
-  const ledgerPath = path2.join(pmRoot, VECTORIZATION_STATUS_LEDGER_PATH);
-  const serialized = `${JSON.stringify({
-    version: 1,
-    generated_at: nowIso(),
-    ...embedding ? { embedding } : {},
-    items: Object.entries(normalizedEntries).map(([id, updated_at]) => ({
-      id,
-      updated_at
-    }))
-  }, null, 2)}
-`;
-  await writeFileAtomic(ledgerPath, serialized);
-}
-function buildVectorPayload(item) {
-  return {
-    id: item.id,
-    type: item.type,
-    status: item.status,
-    priority: item.priority,
-    updated_at: item.updated_at
-  };
-}
-function buildVectorizationIdentityForProvider(provider) {
-  const identity = buildVectorizationEmbeddingIdentity(provider.name, provider.model);
-  if (!identity) {
-    throw new Error("Embedding provider must include a provider name and model");
-  }
-  return identity;
-}
-function buildSkippedSemanticRefreshResult(itemIds, warning) {
-  return {
-    refreshed: [],
-    skipped: itemIds,
-    warnings: [warning]
-  };
-}
-async function resolveSemanticRefreshRuntimeContext(pmRoot, normalizedItemIds, options) {
-  if (!options.settings && !await pathExists(getSettingsPath(pmRoot))) {
-    return buildSkippedSemanticRefreshResult(normalizedItemIds, "search_semantic_refresh_skipped:settings_not_initialized");
-  }
-  let settings;
-  try {
-    settings = options.settings ?? await readSettings(pmRoot);
-  } catch (error) {
-    return buildSkippedSemanticRefreshResult(normalizedItemIds, `search_semantic_refresh_skipped:settings_read_failed:${toErrorMessage(error)}`);
-  }
-  const effectiveSettings = options.apply_runtime_defaults ? resolveSettingsWithSemanticRuntimeDefaults(settings).settings : settings;
-  const provider = resolveEmbeddingProviders(effectiveSettings).active;
-  if (!provider) {
-    return buildSkippedSemanticRefreshResult(normalizedItemIds, "search_semantic_refresh_skipped:provider_unconfigured");
-  }
-  const vectorStore = resolveVectorStores(effectiveSettings).active;
-  if (!vectorStore) {
-    return buildSkippedSemanticRefreshResult(normalizedItemIds, "search_semantic_refresh_skipped:vector_store_unconfigured");
-  }
-  return {
-    settings: effectiveSettings,
-    provider,
-    vectorStore
-  };
-}
-async function collectSemanticRefreshWorkload(pmRoot, idPrefix, preferredFormat, normalizedItemIds, typeToFolder, schema) {
-  const warnings = [];
-  const skipped = /* @__PURE__ */ new Set();
-  const missing = /* @__PURE__ */ new Set();
-  const documents = [];
-  for (const itemId of normalizedItemIds) {
-    const located = await locateItem(pmRoot, itemId, idPrefix, preferredFormat, typeToFolder);
-    if (!located) {
-      missing.add(itemId);
-      continue;
-    }
-    try {
-      const loaded = await readLocatedItem(located, { schema });
-      documents.push({
-        id: loaded.document.metadata.id,
-        document: loaded.document
-      });
-    } catch (error) {
-      skipped.add(located.id);
-      warnings.push(`search_semantic_refresh_item_read_failed:${located.id}:${toErrorMessage(error)}`);
-    }
-  }
-  documents.sort((left, right) => left.id.localeCompare(right.id));
-  return {
-    documents,
-    missingIds: toUniqueSorted(missing),
-    skippedIds: toUniqueSorted(skipped),
-    warnings
-  };
-}
-async function embedLocatedSemanticVectors(settings, provider, documents) {
-  const corpusCharacterLimit = resolveSemanticCorpusCharacterLimit(provider.name, settings.search.embedding_corpus_max_characters).maxCharacters;
-  const corpusFields = resolveSearchCorpusFields(settings);
-  const corpusInputs = documents.map((entry) => buildSemanticCorpusInput(entry.document, {
-    providerName: provider.name,
-    maxCharacters: corpusCharacterLimit,
-    fields: corpusFields
-  }));
-  const embeddingResult = await executeEmbeddingBatchesWithRetry(provider, settings, corpusInputs);
-  return {
-    vectors: embeddingResult.vectors,
-    vector_dimension: inferConsistentVectorDimension(embeddingResult.vectors, "Semantic refresh embedding"),
-    warnings: embeddingResult.warnings
-  };
-}
-async function upsertLocatedSemanticVectors(vectorStore, documents, vectors) {
-  await executeVectorUpsert(vectorStore, documents.map((entry, index) => ({
-    id: entry.id,
-    vector: vectors[index],
-    payload: buildVectorPayload(entry.document.metadata)
-  })));
-  return {
-    refreshed: documents.map((entry) => entry.id),
-    skipped: [],
-    warnings: []
-  };
-}
-async function pruneMissingSemanticVectors(vectorStore, missingIds) {
-  if (missingIds.length === 0) {
-    return { refreshed: [], skipped: [], warnings: [] };
-  }
-  try {
-    await executeVectorDelete(vectorStore, missingIds);
-    return {
-      refreshed: [],
-      skipped: [],
-      warnings: []
-    };
-  } catch (error) {
-    return {
-      refreshed: [],
-      skipped: missingIds,
-      warnings: [`search_semantic_refresh_delete_failed:${toErrorMessage(error)}`]
-    };
-  }
-}
-async function invalidateSearchCacheArtifacts(pmRoot) {
-  const invalidated = [];
-  const warnings = [];
-  for (const relativePath of SEARCH_CACHE_ARTIFACT_PATHS) {
-    const artifactPath = path2.join(pmRoot, relativePath);
-    try {
-      if (!await pathExists(artifactPath)) {
-        continue;
-      }
-      await removeFileIfExists(artifactPath);
-      invalidated.push(relativePath);
-    } catch (error) {
-      warnings.push(formatInvalidationWarning(relativePath, error));
-    }
-  }
-  return {
-    invalidated,
-    warnings
-  };
-}
-async function refreshSemanticEmbeddingsForMutatedItems(pmRoot, itemIds, options = {}) {
-  const normalizedItemIds = toUniqueSorted(itemIds);
-  if (normalizedItemIds.length === 0) {
-    return {
-      refreshed: [],
-      skipped: [],
-      warnings: []
-    };
-  }
-  const runtimeContext = await resolveSemanticRefreshRuntimeContext(pmRoot, normalizedItemIds, options);
-  if (!("settings" in runtimeContext)) {
-    return runtimeContext;
-  }
-  const typeRegistry = resolveItemTypeRegistry(runtimeContext.settings, getActiveExtensionRegistrations());
-  const workload = await collectSemanticRefreshWorkload(pmRoot, runtimeContext.settings.id_prefix, runtimeContext.settings.item_format, normalizedItemIds, typeRegistry.type_to_folder, runtimeContext.settings.schema);
-  const ledgerRead = workload.documents.length > 0 || workload.missingIds.length > 0 ? await readVectorizationStatusLedger(pmRoot) : { entries: {}, embedding: null, warnings: [] };
-  const embeddingIdentity = buildVectorizationIdentityForProvider(runtimeContext.provider);
-  const nextLedgerBaseEntries = ledgerRead.entries;
-  let refreshedResult = { refreshed: [], skipped: [], warnings: [] };
-  let nextEmbeddingMetadata = ledgerRead.embedding;
-  if (workload.documents.length > 0) {
-    if (ledgerRead.embedding && hasVectorizationEmbeddingIdentityChanged(ledgerRead.embedding, embeddingIdentity)) {
-      refreshedResult = {
-        refreshed: [],
-        skipped: workload.documents.map((entry) => entry.id),
-        warnings: ["search_semantic_refresh_requires_reindex:embedding_identity_changed"]
-      };
-    } else {
-      try {
-        const embedded = await embedLocatedSemanticVectors(runtimeContext.settings, runtimeContext.provider, workload.documents);
-        if (hasVectorizationVectorDimensionChanged(ledgerRead.embedding, embedded.vector_dimension)) {
-          refreshedResult = {
-            refreshed: [],
-            skipped: workload.documents.map((entry) => entry.id),
-            warnings: [...embedded.warnings, "search_semantic_refresh_requires_reindex:vector_dimension_changed"]
-          };
-        } else {
-          nextEmbeddingMetadata = buildVectorizationEmbeddingMetadata(embeddingIdentity, embedded.vector_dimension);
-          const upserted = await upsertLocatedSemanticVectors(runtimeContext.vectorStore, workload.documents, embedded.vectors);
-          refreshedResult = {
-            refreshed: upserted.refreshed,
-            skipped: upserted.skipped,
-            warnings: [...embedded.warnings, ...upserted.warnings]
-          };
-        }
-      } catch (error) {
-        refreshedResult = {
-          refreshed: [],
-          skipped: workload.documents.map((entry) => entry.id),
-          warnings: [`search_semantic_refresh_failed:${toErrorMessage(error)}`]
-        };
-      }
-    }
-  }
-  const pruneResult = await pruneMissingSemanticVectors(runtimeContext.vectorStore, workload.missingIds);
-  const refreshedIdSet = new Set(refreshedResult.refreshed);
-  const refreshedEntries = Object.fromEntries(workload.documents.filter((entry) => refreshedIdSet.has(entry.id)).map((entry) => [entry.id, entry.document.metadata.updated_at]));
-  const ledgerWarnings = [];
-  if (Object.keys(refreshedEntries).length > 0 || workload.missingIds.length > 0) {
-    const nextEntries = {
-      ...nextLedgerBaseEntries,
-      ...normalizeVectorizationLedgerEntries(refreshedEntries)
-    };
-    for (const missingId of workload.missingIds) {
-      delete nextEntries[missingId];
-    }
-    try {
-      await writeVectorizationStatusLedger(pmRoot, nextEntries, nextEmbeddingMetadata);
-    } catch (error) {
-      ledgerWarnings.push(`search_vectorization_status_ledger_write_failed:${toErrorMessage(error)}`);
-    }
-    ledgerWarnings.push(...ledgerRead.warnings);
-  }
-  return {
-    refreshed: toUniqueSorted([...refreshedResult.refreshed, ...pruneResult.refreshed]),
-    skipped: toUniqueSorted([...workload.skippedIds, ...refreshedResult.skipped, ...pruneResult.skipped]),
-    warnings: [...workload.warnings, ...refreshedResult.warnings, ...pruneResult.warnings, ...ledgerWarnings]
-  };
-}
-function isSemanticRefreshActive(settings, applyRuntimeDefaults) {
-  const effectiveSettings = applyRuntimeDefaults ? resolveSettingsWithSemanticRuntimeDefaults(settings).settings : settings;
-  return Boolean(resolveEmbeddingProviders(effectiveSettings).active && resolveVectorStores(effectiveSettings).active);
-}
-async function refreshSearchArtifactsForMutation(pmRoot, itemIds, options = {}) {
-  const invalidation = await invalidateSearchCacheArtifacts(pmRoot);
-  const normalizedItemIds = toUniqueSorted(itemIds);
-  if (normalizedItemIds.length === 0) {
-    return {
-      invalidated: invalidation.invalidated,
-      refreshed: [],
-      skipped: [],
-      warnings: invalidation.warnings
-    };
-  }
-  if (!await pathExists(getSettingsPath(pmRoot))) {
-    const semanticRefresh2 = await refreshSemanticEmbeddingsForMutatedItems(pmRoot, normalizedItemIds);
-    return {
-      invalidated: invalidation.invalidated,
-      refreshed: semanticRefresh2.refreshed,
-      skipped: semanticRefresh2.skipped,
-      warnings: [...invalidation.warnings, ...semanticRefresh2.warnings]
-    };
-  }
-  let settings;
-  try {
-    settings = await readSettings(pmRoot);
-  } catch (error) {
-    return {
-      invalidated: invalidation.invalidated,
-      refreshed: [],
-      skipped: normalizedItemIds,
-      warnings: [
-        ...invalidation.warnings,
-        `search_semantic_refresh_skipped:settings_read_failed:${toErrorMessage(error)}`
-      ]
-    };
-  }
-  if (settings.search.mutation_refresh_policy === "cache_only") {
-    return {
-      invalidated: invalidation.invalidated,
-      refreshed: [],
-      skipped: normalizedItemIds,
-      warnings: invalidation.warnings
-    };
-  }
-  const applyRuntimeDefaults = settings.search.mutation_refresh_policy === "semantic_auto";
-  if (options.background && isSemanticRefreshActive(settings, applyRuntimeDefaults)) {
-    await scheduleBackgroundSemanticRefresh(pmRoot, normalizedItemIds);
-    return {
-      invalidated: invalidation.invalidated,
-      refreshed: [],
-      skipped: [],
-      warnings: [...invalidation.warnings, "search_semantic_refresh_scheduled_background"],
-      scheduled: true
-    };
-  }
-  const semanticRefresh = await refreshSemanticEmbeddingsForMutatedItems(pmRoot, normalizedItemIds, {
-    settings,
-    apply_runtime_defaults: applyRuntimeDefaults
-  });
-  return {
-    invalidated: invalidation.invalidated,
-    refreshed: semanticRefresh.refreshed,
-    skipped: semanticRefresh.skipped,
-    warnings: [...invalidation.warnings, ...semanticRefresh.warnings]
-  };
-}
-
-export {
-  resolveProviderConfigSource,
-  resolveEmbeddingProviders,
-  executeEmbeddingRequest,
-  resolveSearchCorpusFields,
-  buildReminderCorpus,
-  buildEventCorpus,
-  buildPlanFlatCorpus,
-  buildSearchCorpus,
-  resolveSemanticCorpusCharacterLimit,
-  buildSemanticCorpusInput,
-  executeEmbeddingBatchesWithRetry,
-  resolveSettingsWithSemanticRuntimeDefaults,
-  REINDEX_LOCK_ID,
-  shouldRunSearchRefreshInForeground,
-  resolveVectorStores,
-  executeVectorQuery,
-  executeVectorUpsert,
-  executeVectorDelete,
-  executeVectorReset,
-  buildVectorizationEmbeddingIdentity,
-  buildVectorizationEmbeddingMetadata,
-  hasVectorizationEmbeddingIdentityChanged,
-  hasVectorizationVectorDimensionChanged,
-  inferConsistentVectorDimension,
-  readVectorizationStatusLedger,
-  writeVectorizationStatusLedger,
-  refreshSemanticEmbeddingsForMutatedItems,
-  refreshSearchArtifactsForMutation
-};
-//# sourceMappingURL=chunk-7QH7DHUB.js.map
-
-//# debugId=c63a3843-4fe5-59f1-a28c-51139dae3ccd