@javierkaiser/opencode-indexing 0.1.0 → 0.2.0

package/src/lancedb-support.ts

@@ -0,0 +1,83 @@
+import { settingsFilePath } from "./settings.ts"
+
+/**
+ * Which platforms the LanceDB binding can actually run on.
+ *
+ * `@lancedb/lancedb` is a JavaScript wrapper that `require()`s one of seven
+ * per-platform native binaries, each published as its own optional dependency.
+ * There is no WASM build, so a platform outside that list cannot use LanceDB at
+ * all, and installing it again will not change that.
+ *
+ * macOS on Intel is the one that bites: `lancedb-darwin-x64` is not published,
+ * so LanceDB works on Apple Silicon only. The list is here so the plugin can say
+ * so plainly instead of surfacing a module-resolution stack trace; the import
+ * itself stays the authority on whether the binary loaded.
+ */
+
+export const LANCEDB_VERSION = "0.26.2"
+
+/** `platform-arch`, the way a native package would be named. */
+export function platformId(platform: string = process.platform, arch: string = process.arch): string {
+  return `${platform}-${arch}`
+}
+
+const SUPPORTED = new Set([
+  "win32-x64",
+  "win32-arm64",
+  "darwin-arm64",
+  "linux-x64",
+  "linux-arm64",
+])
+
+export interface LanceDbSupport {
+  /** `platform-arch` of the current process. */
+  id: string
+  /** Whether a native binary is published for it. */
+  supported: boolean
+}
+
+export function lanceDbSupport(
+  platform: string = process.platform,
+  arch: string = process.arch,
+): LanceDbSupport {
+  const id = platformId(platform, arch)
+  return { id, supported: SUPPORTED.has(id) }
+}
+
+/**
+ * Node appends the resolution chain to a MODULE_NOT_FOUND message, which buries
+ * the one line that says what went wrong under seven lines of internal files.
+ * The cause is still there; it is just what a reader acts on that is kept.
+ */
+function causeSummary(cause: unknown): string {
+  const message = cause instanceof Error ? cause.message : String(cause)
+  const atRequireStack = message.indexOf("Require stack:")
+  return (atRequireStack === -1 ? message : message.slice(0, atRequireStack)).trim()
+}
+
+/**
+ * The message shown when LanceDB cannot be loaded.
+ *
+ * The two cases need different advice, so they get different words: a platform
+ * with no binary cannot be fixed by installing anything, while a supported
+ * platform that failed to load usually means the optional dependency was
+ * skipped.
+ */
+export function lanceDbUnavailableMessage(
+  cause: unknown,
+  support: LanceDbSupport = lanceDbSupport(),
+): string {
+  const { id, supported } = support
+  if (!supported) {
+    return (
+      `LanceDB is the default store for the own index but has no native binary for ${id}. ` +
+      `It cannot run on this platform and reinstalling will not change that. ` +
+      `Set vectorStore=qdrant explicitly in ${settingsFilePath()} to use a Qdrant server instead.`
+    )
+  }
+  return (
+    `LanceDB could not be loaded for ${id}. It ships as an optional dependency: ` +
+    `install @lancedb/lancedb@${LANCEDB_VERSION}, or set vectorStore=qdrant. ` +
+    `Cause: ${causeSummary(cause)}`
+  )
+}

package/src/registry.ts

@@ -4,42 +4,71 @@ import { createHash } from "node:crypto"
  * Embedding model catalog, mirrored from Kilo Code / Roo Code
  * (`packages/kilo-indexing/src/indexing/model-registry.ts`) so that query
  * embeddings are compatible with existing Kilo indexes.
+ *
+ * The mirror is the compatibility contract: an import is accepted only when
+ * provider, model id and dimension match byte for byte, so an entry here that
+ * drifts from Kilo's silently makes an index un-importable. Entries marked
+ * `kiloMirror: false` are ours alone and can never be imported.
  */
 
 import type { EmbedderProvider, ModelProfile } from "./types.ts"
 
+/** Input ceilings and batch limits are from each provider's own documentation. */
 const profiles: Partial<Record<EmbedderProvider, Record<string, ModelProfile>>> = {
   openai: {
-    "text-embedding-3-small": { dimension: 1536, scoreThreshold: 0.4 },
-    "text-embedding-3-large": { dimension: 3072, scoreThreshold: 0.4 },
-    "text-embedding-ada-002": { dimension: 1536, scoreThreshold: 0.4 },
+    "text-embedding-3-small": { dimension: 1536, scoreThreshold: 0.4, maxInputTokens: 8192, maxBatchItems: 2048, maxBatchTokens: 300_000 },
+    "text-embedding-3-large": { dimension: 3072, scoreThreshold: 0.4, maxInputTokens: 8192, maxBatchItems: 2048, maxBatchTokens: 300_000 },
+    "text-embedding-ada-002": { dimension: 1536, scoreThreshold: 0.4, maxInputTokens: 8192, maxBatchItems: 2048, maxBatchTokens: 300_000 },
   },
   ollama: {
-    "nomic-embed-text": { dimension: 768, scoreThreshold: 0.3, queryPrefix: "search_query: " },
-    "nomic-embed-text:latest": { dimension: 768, scoreThreshold: 0.3, queryPrefix: "search_query: " },
-    "mxbai-embed-large": { dimension: 1024, scoreThreshold: 0.3 },
-    "all-minilm": { dimension: 384, scoreThreshold: 0.3 },
+    // 512 tokens is the smallest input in the catalog by a wide margin. A chunk of
+    // real code is routinely longer, and Ollama truncates by default, so this one
+    // is also the reason the Ollama adapter refuses to truncate silently.
+    "mxbai-embed-large": { dimension: 1024, scoreThreshold: 0.3, maxInputTokens: 512, normalized: true },
+    "nomic-embed-text": { dimension: 768, scoreThreshold: 0.3, queryPrefix: "search_query: ", maxInputTokens: 2048, normalized: true },
+    // Ollama reports the tag, but Kilo stores whatever its config names, so an
+    // index carrying this id was written by us and cannot be imported.
+    "nomic-embed-text:latest": { dimension: 768, scoreThreshold: 0.3, queryPrefix: "search_query: ", maxInputTokens: 2048, normalized: true, kiloMirror: false },
+    "all-minilm": { dimension: 384, scoreThreshold: 0.3, maxInputTokens: 512, normalized: true },
+    "bge-m3": { dimension: 1024, scoreThreshold: 0.3, maxInputTokens: 8192, normalized: true, kiloMirror: false },
   },
   gemini: {
-    "gemini-embedding-001": { dimension: 3072, scoreThreshold: 0.35 },
-    "text-embedding-004": { dimension: 768, scoreThreshold: 0.35 },
-    "embedding-001": { dimension: 768, scoreThreshold: 0.35 },
+    // gemini-embedding-001 accepts only 2048 tokens, the tightest cloud ceiling here.
+    // gemini-embedding-2 takes 8192 and is the better default despite costing more.
+    "gemini-embedding-001": { dimension: 3072, scoreThreshold: 0.35, maxInputTokens: 2048 },
+    "gemini-embedding-2": { dimension: 3072, scoreThreshold: 0.35, maxInputTokens: 8192, normalized: true, kiloMirror: false },
+    "text-embedding-004": { dimension: 768, scoreThreshold: 0.35, maxInputTokens: 2048 },
+    "embedding-001": { dimension: 768, scoreThreshold: 0.35, maxInputTokens: 2048 },
   },
   mistral: {
-    "codestral-embed-2505": { dimension: 1536, scoreThreshold: 0.35 },
-    "codestral-embed": { dimension: 1536, scoreThreshold: 0.35 },
-    "mistral-embed": { dimension: 1024, scoreThreshold: 0.35 },
+    "codestral-embed-2505": { dimension: 1536, scoreThreshold: 0.35, maxInputTokens: 8192, normalized: true },
+    "codestral-embed": { dimension: 1536, scoreThreshold: 0.35, maxInputTokens: 8192, normalized: true },
+    "mistral-embed": { dimension: 1024, scoreThreshold: 0.35, maxInputTokens: 8192, normalized: true },
   },
   voyage: {
-    "voyage-code-3": { dimension: 1024, scoreThreshold: 0.35 },
-    "voyage-3": { dimension: 1024, scoreThreshold: 0.35 },
-    "voyage-3-lite": { dimension: 512, scoreThreshold: 0.35 },
+    // 32k of context on a code-specific model: four times any other entry here, and
+    // the reason voyage is a better default than codestral for code chunks.
+    "voyage-code-4": { dimension: 1024, scoreThreshold: 0.35, maxInputTokens: 32_000, maxBatchItems: 1000, maxBatchTokens: 120_000, normalized: true, kiloMirror: false },
+    "voyage-code-3": { dimension: 1024, scoreThreshold: 0.35, maxInputTokens: 32_000, maxBatchItems: 1000, maxBatchTokens: 120_000, normalized: true },
+    "voyage-4-large": { dimension: 1024, scoreThreshold: 0.35, maxInputTokens: 32_000, maxBatchItems: 1000, maxBatchTokens: 120_000, normalized: true, kiloMirror: false },
+    "voyage-4": { dimension: 1024, scoreThreshold: 0.35, maxInputTokens: 32_000, maxBatchItems: 1000, maxBatchTokens: 320_000, normalized: true, kiloMirror: false },
+    "voyage-4-lite": { dimension: 1024, scoreThreshold: 0.35, maxInputTokens: 32_000, maxBatchItems: 1000, maxBatchTokens: 1_000_000, normalized: true, kiloMirror: false },
+    "voyage-3": { dimension: 1024, scoreThreshold: 0.35, maxInputTokens: 32_000, maxBatchItems: 1000, normalized: true },
+    "voyage-3-lite": { dimension: 512, scoreThreshold: 0.35, maxInputTokens: 32_000, maxBatchItems: 1000, normalized: true },
   },
   openrouter: {
-    "openai/text-embedding-3-small": { dimension: 1536, scoreThreshold: 0.4 },
-    "openai/text-embedding-3-large": { dimension: 3072, scoreThreshold: 0.4 },
-    "google/gemini-embedding-001": { dimension: 3072, scoreThreshold: 0.35 },
+    "openai/text-embedding-3-small": { dimension: 1536, scoreThreshold: 0.4, maxInputTokens: 8192, maxBatchTokens: 300_000 },
+    "openai/text-embedding-3-large": { dimension: 3072, scoreThreshold: 0.4, maxInputTokens: 8192, maxBatchTokens: 300_000 },
+    // Kilo's registry names this `google/gemini-embedding-2-preview`. Ours said
+    // `google/gemini-embedding-001`, which can never match a Kilo index: the
+    // profile comparison is exact string equality, so the drift was invisible and
+    // simply made every Gemini-via-OpenRouter index un-importable.
+    "google/gemini-embedding-2-preview": { dimension: 3072, scoreThreshold: 0.35, maxInputTokens: 8192 },
   },
+  // Kilo's registry also lists `bedrock` and `vercel-ai-gateway`. Both are
+  // deliberately absent: bedrock needs SigV4 request signing, and neither is a
+  // provider this plugin offers. A catalog entry with no implemented adapter is
+  // worse than a missing model, because it looks selectable and then fails.
   "openai-compatible": {},
 }
 
@@ -49,6 +78,7 @@ const defaults: Record<string, string> = {
   gemini: "gemini-embedding-001",
   mistral: "codestral-embed-2505",
   voyage: "voyage-code-3",
+  bedrock: "amazon.titan-embed-text-v2:0",
   openrouter: "openai/text-embedding-3-small",
   "openai-compatible": "",
 }
@@ -59,6 +89,15 @@ export const DEFAULT_EMBEDDING_BATCH_SIZE = 60
 export const DEFAULT_MAX_FILE_SIZE_BYTES = 1024 * 1024
 export const MAX_SEARCH_RESULTS = 200
 
+/**
+ * Ceiling used when a model is not in the catalog.
+ *
+ * `mxbai-embed-large` takes 512 tokens, and Ollama truncates anything longer
+ * without saying so. For an unknown model the safe assumption is the tightest
+ * documented one: a shorter index beat a silently wrong index.
+ */
+export const FALLBACK_MAX_INPUT_TOKENS = 512
+
 /** Scanner extension allowlist mirrored from Kilo's tree-sitter index. */
 export const DEFAULT_SCANNER_EXTENSIONS: readonly string[] = [
   ".bash",
@@ -145,6 +184,41 @@ export function getDefaultModelId(provider: EmbedderProvider): string {
   return defaults[provider] ?? ""
 }
 
+/**
+ * Providers whose adapter has been exercised against the real service.
+ *
+ * Not a quality judgement, a statement of fact. The others were written from
+ * each provider's documentation and tested against fixtures written alongside
+ * them, so a wrong assumption about a field name or a response shape would pass
+ * every test and fail on first use. Surfacing that where a provider is chosen is
+ * cheaper than letting a user discover it from a failed indexing run.
+ */
+export const LIVE_TESTED_PROVIDERS: ReadonlySet<string> = new Set(["mistral"])
+
+export function isLiveTested(provider: EmbedderProvider): boolean {
+  return LIVE_TESTED_PROVIDERS.has(provider)
+}
+
+/**
+ * Every model id the catalog knows for a provider, in catalog order.
+ */
+export function listModelIds(provider: EmbedderProvider): string[] {
+  return Object.keys(profiles[provider] ?? {})
+}
+
+/**
+ * Whether an index built with this profile could ever be imported from Kilo.
+ *
+ * `undefined` means the profile is unknown to us, which is a different thing
+ * from "not importable": a model we have never heard of may still be exactly
+ * what a Kilo index holds.
+ */
+export function isKiloMirrored(provider: EmbedderProvider, modelId: string): boolean | undefined {
+  const profile = getModelProfile(provider, modelId)
+  if (!profile) return undefined
+  return profile.kiloMirror !== false
+}
+
 export function getModelProfile(provider: EmbedderProvider, modelId: string): ModelProfile | undefined {
   return profiles[provider]?.[modelId]
 }
@@ -161,6 +235,18 @@ export function getModelQueryPrefix(provider: EmbedderProvider, modelId: string)
   return getModelProfile(provider, modelId)?.queryPrefix
 }
 
+/**
+ * Largest input the model accepts, in tokens.
+ *
+ * Falls back to the most conservative ceiling any catalog model has, rather than
+ * the most generous: guessing high means sending a 32,000-character chunk to a
+ * model that accepts 512, which comes back silently truncated and gets indexed
+ * as if it covered the whole function.
+ */
+export function getModelMaxInputTokens(provider: EmbedderProvider, modelId: string): number {
+  return getModelProfile(provider, modelId)?.maxInputTokens ?? FALLBACK_MAX_INPUT_TOKENS
+}
+
 /** sha256 hex of a workspace path (no normalization, mirrors Kilo). */
 export function workspaceHash(root: string): string {
   return createHash("sha256").update(root).digest("hex")

package/src/rpc.ts

@@ -32,8 +32,7 @@ const settingsShape = {
     importFromKilo: { type: "boolean" },
     autoRefresh: { type: "boolean" },
     searchMaxResults: { type: "number" },
-    hasMistralKey: { type: "boolean" },
-    hasOpenAiKey: { type: "boolean" },
+    configuredProviders: { type: "array", items: { type: "string" } },
     settingsFile: { type: "string" },
   },
   required: ["vectorStore", "qdrantUrl", "provider", "importFromKilo", "settingsFile"],

package/src/search.ts

@@ -8,6 +8,7 @@ import { getModelScoreThreshold, profileKey, workspaceHash } from "./registry.ts
 import { withProfile } from "./config.ts"
 import type { EmbedderProvider, IndexingSettings, KVStore, QueryHit, SearchHit } from "./types.ts"
 import type { Qdrant } from "./qdrant.ts"
+import type { VectorStoreAdapter } from "./vector-store.ts"
 import { describeError } from "./errors.ts"
 
 export interface SearchDeps {
@@ -15,6 +16,13 @@ export interface SearchDeps {
   kv: KVStore
   root: string
   settings: IndexingSettings
+  /**
+   * The own-index store. Built from the settings when omitted.
+   *
+   * Injected so a caller that already holds one does not build a second
+   * identical client, and so the search can be exercised without a server.
+   */
+  ownStore?: VectorStoreAdapter
 }
 
 export interface SearchMeta {
@@ -80,7 +88,7 @@ export async function searchCode(deps: SearchDeps, query: string, pathPrefix?: s
   const errors: string[] = []
   const limit = Math.max(1, Math.min(overrideLimit ?? settings.searchMaxResults, 200))
 
-  const ownStore = createOwnStore(settings, root)
+  const ownStore = deps.ownStore ?? createOwnStore(settings, root)
   const qdrantClient = settings.vectorStore === "qdrant" ? qdrant : createSettingsQdrant(settings)
   const [ownInfo, kiloCollection] = await Promise.all([
     ownStore.info().catch(() => null),
@@ -102,6 +110,7 @@ export async function searchCode(deps: SearchDeps, query: string, pathPrefix?: s
   if (!profiles.has(profileKey(baseProfile))) profiles.set(profileKey(baseProfile), baseProfile)
 
   const vectors = new Map<string, number[]>()
+  const embedFailures = new Map<string, string>()
   for (const [key, profile] of profiles) {
     try {
       const embedder = createEmbedder(withProfile(settings, profile))
@@ -109,10 +118,32 @@ export async function searchCode(deps: SearchDeps, query: string, pathPrefix?: s
       if (!vector) throw new Error("empty embedding")
       vectors.set(key, vector)
     } catch (error) {
-      errors.push(`embed ${key}: ${describeError(error)}`)
+      embedFailures.set(key, describeError(error))
     }
   }
 
+  /**
+   * Refuse to answer from part of the corpus.
+   *
+   * A stored index whose profile cannot be embedded is unreachable, and
+   * returning only the half that worked looks exactly like a complete answer
+   * whose other half ranked lower. The caller asked what matches, not what
+   * matches in whichever part happened to be readable, so this is an error.
+   * An index with no points needs no query vector and is not a problem.
+   */
+  const unreachable = (label: string, profile: ProfileRef | undefined, points: number | null | undefined): void => {
+    if (!profile || (points ?? 0) <= 0) return
+    const key = profileKey(profile)
+    if (vectors.has(key)) return
+    const cause = embedFailures.get(key)
+    throw new Error(
+      `Cannot search ${label}: it holds ${points} points built with ${key}, and that profile could not be embedded` +
+        `${cause ? ` (${cause})` : ""}. Searching only the other index would return an incomplete result set as if it were complete.`,
+    )
+  }
+  unreachable("the own index", ownInfo?.profile, ownInfo?.pointsCount)
+  unreachable("Kilo's index", kiloInfo?.profile, kiloInfo?.pointsCount)
+
   const minScore = settings.searchMinScore
 
   const kiloHits = (async (): Promise<SearchHit[]> => {
@@ -129,6 +160,11 @@ export async function searchCode(deps: SearchDeps, query: string, pathPrefix?: s
     })
     return hits.map((hit) => toSearchHit(hit, "kilo")).filter((hit): hit is SearchHit => hit !== undefined)
   })().catch((error) => {
+    // Kilo's index exists and holds points; failing to read it would drop those
+    // results from an answer that still looks complete.
+    if ((kiloInfo?.pointsCount ?? 0) > 0) {
+      throw new Error(`Cannot read Kilo's index (${kiloCollection}): ${describeError(error)}`)
+    }
     errors.push(`kilo search: ${describeError(error)}`)
     return [] as SearchHit[]
   })
@@ -147,6 +183,9 @@ export async function searchCode(deps: SearchDeps, query: string, pathPrefix?: s
     })
     return hits.map((hit) => toSearchHit(hit, "own")).filter((hit): hit is SearchHit => hit !== undefined)
   })().catch((error) => {
+    if ((ownInfo?.pointsCount ?? 0) > 0) {
+      throw new Error(`Cannot read the own index (${ownStore.name}): ${describeError(error)}`)
+    }
     errors.push(`own search: ${describeError(error)}`)
     return [] as SearchHit[]
   })

package/src/settings-commands.ts

@@ -172,10 +172,12 @@ const KEY_SPECS: Record<string, KeySpec> = {
     description: "Embedding provider",
     toPatch: (value) => {
       const provider = value as (typeof PROVIDERS)[number]
-      // Reset the model so the provider default applies unless the user sets
-      // one explicitly afterwards.
-      void provider
-      return { provider: provider as SettingsFile["provider"] }
+      // Clear the model so the new provider's default applies. Model ids are
+      // namespaced per provider, so keeping the old one is never right: it
+      // turned a switch to Voyage into `voyage` + `codestral-embed-2505`. The
+      // previous code claimed to do this and returned only the provider, which
+      // left the stale model in the file and outranked the default.
+      return { provider: provider as SettingsFile["provider"], model: "" }
     },
     display: (settings) => settings.provider,
   },

package/src/settings.ts

@@ -93,6 +93,18 @@ function compact<T extends Record<string, unknown>>(input: T): T {
   return out as T
 }
 
+/**
+ * Merge the two objects a level deep.
+ *
+ * Derived from the incoming keys rather than listing the provider names here.
+ * The hand-written list this replaced silently dropped any credential added to
+ * the shape but not to the list: the field existed, the resolver read it, and
+ * the value never reached the file.
+ */
+function mergeNested<T extends Record<string, unknown>>(current: T | undefined, incoming: T): T {
+  return compact({ ...(current ?? {}), ...incoming }) as T
+}
+
 function deepMerge(base: SettingsFile, patch: SettingsFile): SettingsFile {
   const out: SettingsFile = { ...base }
   for (const [key, value] of Object.entries(patch)) {
@@ -108,19 +120,22 @@ function deepMerge(base: SettingsFile, patch: SettingsFile): SettingsFile {
     if (key === "apiKeys") {
       const current = out.apiKeys ?? {}
       const incoming = value as NonNullable<SettingsFile["apiKeys"]>
-      out.apiKeys = compact({
-        ...current,
-        mistral: incoming.mistral ?? current.mistral,
-        openai: incoming.openai ?? current.openai,
-        gemini: incoming.gemini ?? current.gemini,
-        voyage: incoming.voyage ?? current.voyage,
-        openrouter: incoming.openrouter ?? current.openrouter,
-        ollama: incoming.ollama !== undefined ? compact({ ...current.ollama, ...incoming.ollama }) : current.ollama,
-        "openai-compatible":
-          incoming["openai-compatible"] !== undefined
-            ? compact({ ...current["openai-compatible"], ...incoming["openai-compatible"] })
-            : current["openai-compatible"],
-      }) as SettingsFile["apiKeys"]
+      const merged: Record<string, unknown> = { ...current }
+      for (const [provider, providerValue] of Object.entries(incoming)) {
+        if (providerValue === undefined) continue
+        // ollama and openai-compatible are objects; the rest are plain keys.
+        // Both shapes merge the same way, so no per-provider branch is needed.
+        merged[provider] =
+          typeof providerValue === "object" && providerValue !== null
+            ? mergeNested(
+                typeof merged[provider] === "object" && merged[provider] !== null
+                  ? (merged[provider] as Record<string, unknown>)
+                  : undefined,
+                providerValue as Record<string, unknown>,
+              )
+            : providerValue
+      }
+      out.apiKeys = compact(merged) as SettingsFile["apiKeys"]
       continue
     }
     ;(out as Record<string, unknown>)[key] = value

package/src/status.ts

@@ -5,10 +5,11 @@ import { getKiloStoreInfo, resolveKiloCollection } from "./kilo-store.ts"
 import { discoverKiloSources, type KiloSourceInfo } from "./import.ts"
 import { createOwnStore, createSettingsQdrant } from "./store-factory.ts"
 import { diffFiles, loadManifest } from "./manifest.ts"
-import { workspaceHash } from "./registry.ts"
+import { getModelDimension, profileKey, workspaceHash } from "./registry.ts"
 import { scanWorkspace } from "./scanner.ts"
 import type { IndexingSettings, KVStore } from "./types.ts"
 import type { Qdrant } from "./qdrant.ts"
+import type { VectorStoreAdapter } from "./vector-store.ts"
 import { describeError } from "./errors.ts"
 
 export interface StatusDeps {
@@ -16,6 +17,8 @@ export interface StatusDeps {
   kv: KVStore
   root: string
   settings: IndexingSettings
+  /** The own-index store. Built from the settings when omitted. */
+  ownStore?: VectorStoreAdapter
 }
 
 export interface IndexStatus {
@@ -56,16 +59,29 @@ const KILO_CACHE_PREFIX = "kiloCollection/"
 
 export async function getStatus(deps: StatusDeps, options?: { checkFreshness?: boolean }): Promise<IndexStatus> {
   const { qdrant, kv, root, settings } = deps
-  const warnings: string[] = []
+  // Configuration warnings are produced once per resolution and were previously
+  // never shown, so a store that cannot work on this platform looked simply
+  // absent rather than misconfigured.
+  const warnings: string[] = [...settings.warnings]
   let reachable = true
   try {
     await qdrant.listCollections()
   } catch (error) {
     reachable = false
-    warnings.push(`Qdrant unreachable at ${settings.qdrantUrl}: ${describeError(error)}`)
+    // Only worth reporting when Qdrant is actually part of this setup. With the
+    // own index on LanceDB and no Qdrant-backed Kilo index, a dead Qdrant is
+    // not a problem the user has, and saying so would train them to ignore it.
+    const qdrantIsOurs = settings.vectorStore === "qdrant" || settings.kiloVectorStore === "qdrant"
+    if (qdrantIsOurs) {
+      warnings.push(
+        settings.vectorStore === "qdrant"
+          ? `Qdrant unreachable at ${settings.qdrantUrl}: ${describeError(error)}`
+          : `Qdrant unreachable at ${settings.qdrantUrl}, so a Kilo index stored there cannot be imported: ${describeError(error)}`,
+      )
+    }
   }
 
-  const ownStore = createOwnStore(settings, root)
+  const ownStore = deps.ownStore ?? createOwnStore(settings, root)
   const cacheKey = KILO_CACHE_PREFIX + workspaceHash(root).slice(0, 16)
   const cachedKilo = await kv.get(cacheKey)
   const kiloCollection = reachable
@@ -110,8 +126,40 @@ export async function getStatus(deps: StatusDeps, options?: { checkFreshness?: b
     : null
 
   const compatibleSource = kiloSources.find((source) => source.compatible)
+
+  /**
+   * A profile change destroys the own index and re-embeds everything.
+   *
+   * Saying so here is the point: the rebuild happens on the next build or
+   * refresh, so a user who changes provider to save money can spend the whole
+   * repository on embeddings before seeing any indication that it happened.
+   * The count is reported because it is the only estimate of the cost.
+   */
+  const configuredProfile = {
+    provider: settings.provider,
+    modelId: settings.modelId,
+    dimension: settings.dimension || getModelDimension(settings.provider, settings.modelId) || 0,
+  }
+  const storedProfile = ownInfo?.profile
+  const profileChanged =
+    storedProfile !== undefined &&
+    (storedProfile.provider !== configuredProfile.provider ||
+      storedProfile.modelId !== configuredProfile.modelId ||
+      (configuredProfile.dimension > 0 && storedProfile.dimension !== configuredProfile.dimension))
+  if (profileChanged && (ownInfo?.pointsCount ?? 0) > 0) {
+    warnings.push(
+      `The own index holds ${ownInfo?.pointsCount} points built with ${profileKey(storedProfile)} but the configured ` +
+        `model is ${profileKey(configuredProfile)}. The next build or refresh will delete them and re-embed the whole ` +
+        `workspace. Set the model back to reuse them, or re-import from Kilo if a matching source exists.`,
+    )
+  }
+
   let recommendation: string
-  if (!reachable && settings.vectorStore === "qdrant") {
+  if (profileChanged) {
+    recommendation =
+      `The embedding model changed since the own index was built (${profileKey(storedProfile!)} -> ` +
+      `${profileKey(configuredProfile)}). Run indexing_build to rebuild it, which re-embeds every file.`
+  } else if (!reachable && settings.vectorStore === "qdrant") {
     recommendation = "Start Qdrant (e.g. `docker run -p 6333:6333 qdrant/qdrant` or Podman equivalent), then re-run indexing_status."
   } else if (!kiloCollection && !ownInfo?.exists && kiloSources.length === 0) {
     recommendation = "No index found. Run indexing_build to create an independent index (works without Kilo Code)."

package/src/types.ts

@@ -22,6 +22,38 @@ export interface ModelProfile {
   dimension: number
   scoreThreshold?: number
   queryPrefix?: string
+  /**
+   * Largest input the model accepts, in tokens.
+   *
+   * Not the same for every model, and the spread is wide: `mxbai-embed-large`
+   * takes 512 while `voyage-code-4` takes 32,000. Sizing every request by one
+   * global constant silently truncates every chunk past the smallest model's
+   * limit, and that truncated vector is stored as if it covered the whole
+   * function.
+   */
+  maxInputTokens?: number
+  /** Documented ceiling on items in one request, where the provider publishes one. */
+  maxBatchItems?: number
+  /** Documented ceiling on tokens in one request, where the provider publishes one. */
+  maxBatchTokens?: number
+  /**
+   * Whether the provider documents its output as already L2-normalised.
+   *
+   * The provider's claim, not a measurement we rely on. Mistral documents its
+   * embeddings as "norm 1" and a live call measured 0.9913, which is why every
+   * comparison here uses cosine regardless: it is correct either way, and this
+   * field exists only so a future fast path knows whether a bare dot product
+   * would be equivalent.
+   */
+  normalized?: boolean
+  /**
+   * Marks a model we know about that Kilo's registry does not.
+   *
+   * The catalog is a mirror, so that query embeddings stay interchangeable with
+   * a Kilo index. An entry with no Kilo counterpart is still useful, but it can
+   * never be import-compatible, and the status report has to be able to say so.
+   */
+  kiloMirror?: boolean
 }
 
 export interface ProviderCredentials {
@@ -39,6 +71,15 @@ export interface ProviderCredentials {
 export interface IndexingSettings extends EmbeddingProfile {
   /** Backend for the plugin's OWN index. */
   vectorStore: "qdrant" | "lancedb"
+  /**
+   * Store Kilo keeps its own index in, when kilo.jsonc says so.
+   *
+   * Kept alongside `vectorStore` rather than folded into it: Kilo decides where
+   * an import reads from, the own index decides where it writes, and the status
+   * report needs both to know whether an unreachable Qdrant is a problem here or
+   * simply not this user's business.
+   */
+  kiloVectorStore: "qdrant" | "lancedb" | null
   qdrantUrl: string
   qdrantApiKey?: string
   /** Base directory for the plugin's own LanceDB stores. */

package/tui/settings-page-data.ts

@@ -24,8 +24,8 @@ export interface SettingsView {
   /** Master switch for writing the own index. */
   enabled: boolean
   searchMaxResults: number
-  hasMistralKey: boolean
-  hasOpenAiKey: boolean
+  /** Providers that have a usable credential or base URL configured. */
+  configuredProviders: string[]
   settingsFile: string
 }
 
@@ -101,8 +101,7 @@ export const UNKNOWN_SETTINGS: SettingsView = {
   enabled: false,
   autoRefresh: false,
   searchMaxResults: 0,
-  hasMistralKey: false,
-  hasOpenAiKey: false,
+  configuredProviders: [],
   settingsFile: "(unavailable)",
 }
 
@@ -149,10 +148,10 @@ export function configRows(settings: SettingsView): ConfigRow[] {
     { label: "Max results", value: String(settings.searchMaxResults) },
     { label: "Settings file", value: settings.settingsFile },
   ]
-  const keys: string[] = []
-  if (settings.hasMistralKey) keys.push("mistral")
-  if (settings.hasOpenAiKey) keys.push("openai")
-  rows.push({ label: "API keys", value: keys.length > 0 ? `${keys.join(", ")} configured` : "none configured" })
+  // Derived from the server's list rather than a pair of booleans, so a
+  // provider added anywhere else shows up here without a change to this file.
+  const keys = settings.configuredProviders
+  rows.push({ label: "Credentials", value: keys.length > 0 ? `${keys.join(", ")} configured` : "none configured" })
   return rows
 }