@javierkaiser/opencode-indexing 0.1.1 → 0.2.1

package/src/indexer.ts

@@ -95,7 +95,18 @@ export async function runIndex(deps: IndexerDeps, options: IndexOptions): Promis
   // Determine dimension (probe embedder if unknown).
   let dimension = settings.dimension
   const existingInfo = await store.info()
-  if (!dimension && existingInfo.profile?.dimension) dimension = existingInfo.profile.dimension
+  const existingProfile = existingInfo.profile
+  // The stored dimension is only authoritative for the profile we are about to
+  // write. Inheriting it across a provider change is how a 1536-wide Mistral
+  // index makes an OpenAI model look 1536-dimensional: the probe that would
+  // have asked the provider never runs, and the inherited number is then
+  // persisted as though it had been measured, which makes the mismatch
+  // self-consistent and undetectable on every later run.
+  const sameProfile =
+    existingProfile !== undefined &&
+    existingProfile.provider === settings.provider &&
+    existingProfile.modelId === settings.modelId
+  if (!dimension && sameProfile && existingProfile?.dimension) dimension = existingProfile.dimension
   if (!dimension) {
     const probe = await getEmbedder().embed(["dimension probe"])
     dimension = probe[0]?.length ?? 0
@@ -146,10 +157,15 @@ export async function runIndex(deps: IndexerDeps, options: IndexOptions): Promis
   if (shouldImport) {
     await deps.onProgress?.({ phase: "importing", processed: 0, total: 0 })
     try {
+      // Collected rather than thrown: discovery no longer fails on an
+      // unreadable source, and the caller has to be told why the scan below is
+      // about to re-embed the whole workspace at their expense.
+      const problems: string[] = []
       const sources = await discoverKiloSources(root, {
         qdrant,
         homeDir: undefined,
         targetProfile: profile,
+        onProblem: (message) => problems.push(message),
       })
       const source = sources.find((item) => item.compatible) ?? sources[0]
       if (source && source.compatible) {
@@ -179,6 +195,12 @@ export async function runIndex(deps: IndexerDeps, options: IndexOptions): Promis
         report.errors.push(
           `Kilo index found (${source.name}) but its embedding profile does not match ${profile.provider}:${profile.modelId}:${profile.dimension}; indexing from scratch`,
         )
+      } else if (problems.length > 0) {
+        // No usable source and a reason why. Without this the build reads as a
+        // workspace that has no Kilo index at all, and the full re-embedding
+        // that follows looks like the normal path rather than the expensive
+        // fallback it is.
+        report.errors.push(`${problems.join(" · ")} Indexing from scratch instead.`)
       }
     } catch (error) {
       report.errors.push(`import failed: ${describeError(error)}`)

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

@@ -19,6 +19,20 @@ const empty = { type: "object", properties: {}, additionalProperties: false } as
  */
 const directoryShape = { directory: { type: "string" } } as const
 
+/**
+ * Input schema for a method whose only argument is the caller's workspace.
+ *
+ * Exists so `kilo.discover` and `settings.test` cannot be written as a bare
+ * `directoryShape`: that is a fragment of `properties`, not a schema, and a
+ * validator reading it as one sees no `directory` at all — silently answering
+ * about the service's own workspace again.
+ */
+const workspaceInputShape = {
+  type: "object",
+  properties: { ...directoryShape },
+  additionalProperties: false,
+} as const
+
 const settingsShape = {
   type: "object",
   properties: {
@@ -32,8 +46,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"],
@@ -63,6 +76,9 @@ export const IndexingRpc = {
         type: "object",
         properties: {
           target: { type: "string", enum: ["qdrant", "lancedb", "provider", "kilo"] },
+          // Only `kilo` is workspace-scoped; the other targets describe global
+          // backends. Sending it costs nothing and keeps one shape for the client.
+          ...directoryShape,
         },
         required: ["target"],
         additionalProperties: false,
@@ -75,7 +91,7 @@ export const IndexingRpc = {
       },
     },
     "kilo.discover": {
-      input: empty,
+      input: workspaceInputShape,
       output: {
         type: "object",
         properties: {
@@ -95,6 +111,14 @@ export const IndexingRpc = {
               additionalProperties: true,
             },
           },
+          /**
+           * Sources that exist but could not be read, in plain language.
+           *
+           * Without this the only thing a caller can say when the list is empty
+           * is "not found", which is a different statement from "found, and the
+           * read failed" — and the second one is the one that needs acting on.
+           */
+          problems: { type: "array", items: { type: "string" } },
         },
         required: ["sources"],
         additionalProperties: false,

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 {
@@ -78,7 +81,7 @@ export async function getStatus(deps: StatusDeps, options?: { checkFreshness?: b
     }
   }
 
-  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
@@ -90,11 +93,19 @@ export async function getStatus(deps: StatusDeps, options?: { checkFreshness?: b
     settings.dimension > 0
       ? { provider: settings.provider, modelId: settings.modelId, dimension: settings.dimension }
       : undefined
+  // Discovery problems are collected here rather than thrown away, so `indexing_status`
+  // can say "found but unreadable" instead of the much less useful "nothing there".
+  const kiloProblems: string[] = []
   const [kiloInfo, ownInfo, manifest, kiloSources] = await Promise.all([
     kiloCollection ? getKiloStoreInfo(qdrant, kiloCollection).catch(() => null) : null,
     ownStore.info().catch(() => null),
     loadManifest(kv, root),
-    discoverKiloSources(root, { qdrant, homeDir: undefined, targetProfile }).catch(() => [] as KiloSourceInfo[]),
+    discoverKiloSources(root, {
+      qdrant,
+      homeDir: undefined,
+      targetProfile,
+      onProblem: (message) => kiloProblems.push(message),
+    }).catch(() => [] as KiloSourceInfo[]),
   ])
 
   const freshness = { checked: false, total: 0, added: 0, maybeStale: 0, deleted: 0 }
@@ -123,8 +134,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)."
@@ -169,6 +212,10 @@ export async function getStatus(deps: StatusDeps, options?: { checkFreshness?: b
     },
     freshness,
     recommendation,
-    warnings,
+    // Discovery problems ride along as warnings because that is the list
+    // `indexing_status` already renders, so they surface without a field of
+    // their own. It is the only consumer: the footer reads point counts and
+    // `ownStoreReachable`, and never looks at warnings.
+    warnings: [...warnings, ...kiloProblems],
   }
 }