codesearch-mcp 0.0.18-alpha → 0.2.0-alpha

package/dist/src/services/SearcherService.js

@@ -40,11 +40,13 @@ const readline = __importStar(require("readline"));
 const child_process_1 = require("child_process");
 const file_utils_1 = require("../file-utils");
 const MonorepoAwareDiscoveryService_1 = require("./MonorepoAwareDiscoveryService");
+const legacy_ollama_index_1 = require("./legacy-ollama-index");
 const SILENT_LOGGER = {
     debug() { },
     info() { },
     warn() { },
     error() { },
+    metric() { },
 };
 const EMPTY_META = { description: null, stack: null, notes: null, relations: null };
 const GREP_MAX_RESULTS = 200;
@@ -127,16 +129,53 @@ class SearcherService {
         }
         return edges;
     }
+    // Query translation was removed (legacy). The query is embedded as-is; the
+    // method is kept so the tool layer needs no change and `translated` is always
+    // false.
     async prepareQuery(raw) {
-        const t0 = Date.now();
-        if (this.config.search.autoTranslate && this.isNonEnglish(raw) && this.embedder.translate) {
-            const query = await this.embedder.translate(raw, this.config.search.translateModel);
-            this.logger.debug('SearcherService: prepareQuery', { translated: true, raw: raw.slice(0, 120), query: query.slice(0, 120), ms: Date.now() - t0 });
-            return { query, translated: true };
-        }
-        this.logger.debug('SearcherService: prepareQuery', { translated: false, query: raw.slice(0, 120), ms: Date.now() - t0 });
         return { query: raw, translated: false };
     }
+    /**
+     * Refuse when the configured embedding model disagrees with the one that built
+     * the index — embedding a query into a foreign vector space returns noise. A
+     * missing `index_meta` row with an empty (or altogether absent) `code_chunk`
+     * does not block — but a *populated* `code_chunk` with no `index_meta` row is a
+     * pre-`index_meta` install, treated as the legacy `ollama`/`bge-m3` index (same
+     * interpretation as the `rag-index` legacy-Ollama guard), read-only — this check
+     * never writes `index_meta`.
+     */
+    async assertIndexMatches() {
+        const meta = await this.db.readIndexMeta();
+        if (meta) {
+            this.compareIndexed(meta.provider, meta.model, meta.dimensions);
+            return;
+        }
+        // No row — a missing code_chunk table counts as empty; any other DB error
+        // while counting propagates rather than being read as "not indexed".
+        if (await (0, legacy_ollama_index_1.hasIndexedChunks)(this.db)) {
+            this.compareIndexed(legacy_ollama_index_1.LEGACY_OLLAMA_IDENTITY.provider, legacy_ollama_index_1.LEGACY_OLLAMA_IDENTITY.model, null);
+        }
+    }
+    compareIndexed(indexedProvider, indexedModel, indexedDimensions) {
+        const { provider, model } = this.config.embedding;
+        if (indexedProvider !== provider || indexedModel !== model) {
+            throw new Error(`Index was built with ${indexedProvider}/${indexedModel} but the config selects ${provider}/${model}. ` +
+                `Run \`rag-index --reindex\` to rebuild the index for the new model.`);
+        }
+        // Same model but a changed dimension (e.g. a Matryoshka `embedding.dimensions`
+        // override) would embed the query at a width the column can't hold — pgvector
+        // would throw an opaque "different vector dimensions" error mid-query. Catch
+        // it here with the friendly hint. `embedder.dimensions` is 0 when the width is
+        // only knowable by probing, in which case we skip (can't compare cheaply).
+        // `indexedDimensions` is null for the legacy-inferred identity, whose provider
+        // can never match a configured provider (ollama is no longer selectable), so
+        // this branch is unreached in that case.
+        const dim = this.embedder.dimensions;
+        if (indexedDimensions != null && dim > 0 && dim !== indexedDimensions) {
+            throw new Error(`Index was built at ${indexedDimensions} dimensions but ${provider}/${model} now resolves to ${dim}. ` +
+                `Run \`rag-index --reindex\` to rebuild the index at the new dimension.`);
+        }
+    }
     async listProjects() {
         const rows = await this.db.query(`SELECT "serviceName", COUNT(*)::int AS chunks
        FROM code_chunk
@@ -150,47 +189,114 @@ class SearcherService {
     }
     async searchChunks(query, limit, project, threshold) {
         const t0 = Date.now();
+        await this.assertIndexMatches();
         const effectiveThreshold = threshold ?? this.config.search.similarityThreshold;
-        const fetchLimit = this.embedder.rerank
-            ? Math.min(limit * this.config.search.rerankerOverfetch, 200)
+        const reranking = !!this.embedder.rerank;
+        // Candidate floor: decouple the pool size from `limit` so a small `limit`
+        // (e.g. the default 5) still gives the reranker a large-enough menu. Without
+        // a reranker the extra candidates are never reordered, so keep `limit`.
+        const fetchLimit = reranking
+            ? Math.min(Math.max(limit * this.config.reranker.overfetch, this.config.reranker.candidateFloor), 200)
             : limit;
+        // With metrics on, fetch one extra row to detect a saturated pool (more
+        // under-threshold candidates existed than the window took). The extra row is
+        // dropped before reranking so it never affects results.
+        const metricsOn = this.config.logging.searchMetrics;
+        const dbLimit = metricsOn ? fetchLimit + 1 : fetchLimit;
         this.logger.debug('SearcherService: searchChunks', {
             query: query.slice(0, 120), limit, fetchLimit, project, threshold: effectiveThreshold,
         });
-        const embedding = await this.embedder.embed(query);
-        const params = [`[${embedding}]`, effectiveThreshold, fetchLimit];
+        const tEmbed0 = Date.now();
+        const embedding = await this.embedder.embed(query, 'query');
+        const embedMs = Date.now() - tEmbed0;
+        const params = [`[${embedding}]`, effectiveThreshold, dbLimit];
         let projectFilter = '';
         if (project) {
             params.push(project);
             projectFilter = `AND "serviceName" = $${params.length}`;
         }
-        const candidates = await this.db.query(`SELECT "serviceName", "filePath", "startLine", content,
+        const tDb0 = Date.now();
+        const fetched = await this.db.query(`SELECT "serviceName", "filePath", "startLine", content, "ownerPath",
               ROUND((embedding <=> $1)::numeric, 4)::float8 AS score
        FROM code_chunk
        WHERE embedding <=> $1 < $2
        ${projectFilter}
        ORDER BY embedding <=> $1
        LIMIT $3`, params);
+        const dbMs = Date.now() - tDb0;
+        // Saturated iff the extra probe row came back — more candidates were under
+        // the threshold than `fetchLimit`. Trim the probe row before reranking.
+        const poolSaturated = metricsOn && fetched.length > fetchLimit;
+        const candidates = fetched.slice(0, fetchLimit);
         this.logger.debug('SearcherService: searchChunks candidates', {
             count: candidates.length,
             scores: candidates.map(r => r.score),
             files: candidates.map(r => r.filePath),
             ms: Date.now() - t0,
         });
-        if (!this.embedder.rerank || candidates.length === 0)
-            return candidates;
-        try {
-            const indices = await this.embedder.rerank(query, candidates.map(r => r.content), limit);
-            this.logger.debug('SearcherService: searchChunks rerank done', { indices, ms: Date.now() - t0 });
-            return indices.filter(i => i >= 0 && i < candidates.length).map(i => candidates[i]);
+        let results;
+        let rerankMs = 0;
+        if (!reranking || candidates.length === 0) {
+            results = candidates.slice(0, limit);
         }
-        catch (err) {
-            this.logger.warn('SearcherService: rerank failed, falling back to vector order', {
-                reason: err instanceof Error ? err.message : String(err),
-                ms: Date.now() - t0,
+        else {
+            const tRerank0 = Date.now();
+            try {
+                const indices = await this.embedder.rerank(query, candidates.map(r => r.content), limit);
+                rerankMs = Date.now() - tRerank0;
+                this.logger.debug('SearcherService: searchChunks rerank done', { indices, ms: Date.now() - t0 });
+                // Cap at `limit`: some rerank servers ignore `top_n` and echo back every
+                // candidate, so slicing here keeps the result count within the request.
+                results = indices.filter(i => i >= 0 && i < candidates.length).slice(0, limit).map(i => candidates[i]);
+            }
+            catch (err) {
+                rerankMs = Date.now() - tRerank0;
+                this.logger.warn('SearcherService: rerank failed, falling back to vector order', {
+                    reason: err instanceof Error ? err.message : String(err),
+                    ms: Date.now() - t0,
+                });
+                results = candidates.slice(0, limit);
+            }
+        }
+        if (metricsOn) {
+            this.emitSearchMetrics(query, {
+                fetchLimit, candidates, results, poolSaturated, embedMs, dbMs, rerankMs, totalMs: Date.now() - t0,
             });
-            return candidates.slice(0, limit);
         }
+        return results;
+    }
+    /**
+     * Emit one structured search-tuning line (via `logger.metric`, at `info`
+     * regardless of `logging.level`). `candidates` are in cosine order, so a
+     * candidate's array index is its cosine rank — `maxCosineRankSurvived` is the
+     * deepest cosine position that survived reranking into the returned set. Read
+     * it alongside `poolSaturated` to tune `candidateFloor`/`overfetch`/threshold
+     * per hardware. Never logs chunk content, embeddings, or credentials.
+     */
+    emitSearchMetrics(query, m) {
+        const { candidates, results } = m;
+        const contentIndex = new Map(candidates.map((c, i) => [c, i]));
+        const maxCosineRankSurvived = results.reduce((max, r) => Math.max(max, contentIndex.get(r) ?? -1), -1);
+        const fileCounts = new Map();
+        for (const r of results)
+            fileCounts.set(r.filePath, (fileCounts.get(r.filePath) ?? 0) + 1);
+        const topFileCount = results.length ? Math.max(...fileCounts.values()) : 0;
+        this.logger.metric('search metrics', {
+            query: query.slice(0, 120),
+            fetchLimit: m.fetchLimit,
+            candidatesReturned: candidates.length,
+            poolSaturated: m.poolSaturated,
+            maxCosineRankSurvived,
+            resultCount: results.length,
+            distinctFilesInResult: fileCounts.size,
+            topFileShare: results.length ? +(topFileCount / results.length).toFixed(3) : 0,
+            bestResultScore: results.length ? Math.min(...results.map(r => r.score)) : null,
+            worstResultScore: results.length ? Math.max(...results.map(r => r.score)) : null,
+            embedMs: m.embedMs,
+            rerankMs: m.rerankMs,
+            dbMs: m.dbMs,
+            totalMs: m.totalMs,
+        });
     }
     async fetchNeighbors(results) {
         const t0 = Date.now();
@@ -602,11 +708,6 @@ class SearcherService {
         this.logger.debug('SearcherService: readFileRange result', { linesRead: lines.length, hasMore, ms: Date.now() - t0 });
         return { ok: true, filePath, startLine, endLine: Math.min(endLine, lastRead), lines, hasMore };
     }
-    isNonEnglish(text) {
-        // Use Unicode script detection: check for CJK, Cyrillic, Arabic, Hebrew, Thai, etc.
-        // Excludes common non-ASCII punctuation (smart quotes, em-dashes, accented Latin chars)
-        return /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Cyrillic}\p{Script=Arabic}\p{Script=Hebrew}\p{Script=Thai}\p{Script=Devanagari}]/u.test(text);
-    }
     walkDir(absDir, currentDepth, maxDepth, pattern, lines) {
         let entries;
         try {

package/dist/src/services/VoyageEmbedder.d.ts

@@ -0,0 +1,22 @@
+import type { Config } from '../config';
+import type { IEmbedder, InputType } from '../interfaces/IEmbedder';
+import type { ILogger } from '../interfaces/ILogger';
+import type { EmbedderDeps } from './OpenAICompatibleEmbedder';
+/**
+ * Voyage AI embedder. Voyage's schema differs from OpenAI's: `input` is an array
+ * of strings, `input_type` (`query` | `document`) is required for best quality,
+ * and the optional `output_dimension` requests Matryoshka truncation. Response
+ * is `{ data: [{ embedding, index }] }`.
+ */
+export declare class VoyageEmbedder implements IEmbedder {
+    private config;
+    private logger;
+    readonly dimensions: number;
+    rerank?: (query: string, documents: string[], topN: number) => Promise<number[]>;
+    private readonly url;
+    private readonly doFetch;
+    private readonly baseDelayMs?;
+    constructor(config: Config, logger?: ILogger, deps?: EmbedderDeps);
+    embed(text: string, inputType?: InputType): Promise<number[]>;
+    embedBatch(texts: string[], inputType?: InputType): Promise<number[][]>;
+}

package/dist/src/services/VoyageEmbedder.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoyageEmbedder = void 0;
+const LoggerService_1 = require("./LoggerService");
+const config_1 = require("../config");
+const reranker_1 = require("./reranker");
+const http_retry_1 = require("./http-retry");
+const constants_1 = require("../constants");
+/**
+ * Voyage AI embedder. Voyage's schema differs from OpenAI's: `input` is an array
+ * of strings, `input_type` (`query` | `document`) is required for best quality,
+ * and the optional `output_dimension` requests Matryoshka truncation. Response
+ * is `{ data: [{ embedding, index }] }`.
+ */
+class VoyageEmbedder {
+    config;
+    logger;
+    dimensions;
+    rerank;
+    url;
+    doFetch;
+    baseDelayMs;
+    constructor(config, logger = LoggerService_1.LoggerService.silent(), deps = {}) {
+        this.config = config;
+        this.logger = logger;
+        const base = config.embedding.baseURL.replace(/\/+$/, '');
+        this.url = /\/embeddings$/.test(base) ? base : `${base}/embeddings`;
+        this.doFetch = deps.fetchImpl ?? fetch;
+        this.baseDelayMs = deps.baseDelayMs;
+        this.dimensions = config.embedding.dimensions ?? (0, constants_1.registryDimension)(config.embedding.model) ?? 0;
+        this.rerank = (0, reranker_1.makeReranker)(config, logger, deps);
+    }
+    async embed(text, inputType) {
+        const [v] = await this.embedBatch([text], inputType);
+        return v;
+    }
+    async embedBatch(texts, inputType = 'document') {
+        if (texts.length === 0)
+            return [];
+        return (0, http_retry_1.withRetry)(async () => {
+            const headers = { 'Content-Type': 'application/json' };
+            const apiKey = (0, config_1.resolveEnvRef)(this.config.embedding.apiKey);
+            if (apiKey)
+                headers['Authorization'] = `Bearer ${apiKey}`;
+            const body = {
+                model: this.config.embedding.model,
+                input: texts,
+                input_type: inputType,
+            };
+            if (this.config.embedding.dimensions != null)
+                body.output_dimension = this.config.embedding.dimensions;
+            const res = await this.doFetch(this.url, {
+                method: 'POST',
+                headers,
+                signal: AbortSignal.timeout(120_000),
+                body: JSON.stringify(body),
+            });
+            if (!res.ok) {
+                const errBody = (await res.text().catch(() => res.statusText)).slice(0, 200);
+                throw new http_retry_1.HttpError(res.status, `Voyage embeddings request failed: ${res.status} ${errBody}`);
+            }
+            const data = await res.json();
+            if (!Array.isArray(data.data) || data.data.length !== texts.length) {
+                throw new Error(`Voyage embeddings response returned ${data.data?.length ?? 0} vectors for ${texts.length} inputs`);
+            }
+            return [...data.data]
+                .sort((a, b) => (a.index ?? 0) - (b.index ?? 0))
+                .map(d => d.embedding);
+        }, { logger: this.logger, baseDelayMs: this.baseDelayMs, label: 'voyage-embed' });
+    }
+}
+exports.VoyageEmbedder = VoyageEmbedder;

package/dist/src/services/WebServerService.d.ts

@@ -1,31 +1,55 @@
-import type { Config } from '../config';
+import { Config } from '../config';
 import type { ISearcher } from '../interfaces';
 import type { IEmbedder } from '../interfaces';
 import type { ILogger } from '../interfaces';
 import { type JsonConfig } from '../config-store';
+import { type ProvisioningDeps } from './infinity-provisioning';
+export type BackendActionKind = 'started' | 'already-running' | 'not-needed' | 'manual-required' | 'failed';
+export interface BackendActionResult {
+    action: BackendActionKind;
+    message: string | null;
+}
+export type BackendStatusState = 'idle' | 'recreating' | 'ready' | 'failed';
+export interface BackendStatus {
+    state: BackendStatusState;
+    message: string | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+}
+export interface WebServerDeps {
+    /** Path to the managed docker-compose.yml. Defaults to `CONFIG_DIR/docker-compose.yml`. */
+    composePath?: string;
+    /** Injection seams (fetchImpl/runCommand/pollIntervalMs/readinessTimeoutMs) for the readiness primitive. */
+    provisioning?: ProvisioningDeps;
+    /** Reads the just-saved config back — defaults to `() => new Config()`. Injectable for tests. */
+    readSavedConfig?: () => Config;
+}
 /**
  * Per-field choice lists for the config form. `strict` → render a dropdown that
  * only accepts a listed value (e.g. the embedding model, tied to the vector
  * dimension). Non-strict → a combobox: the values are suggestions but free text
- * is still allowed (e.g. any Ollama model the user has pulled).
+ * is still allowed (e.g. any model served by a self-hosted backend).
  */
 export interface FieldOption {
     values: string[];
     strict: boolean;
 }
-/** Placeholder shown to the browser instead of the real DB password. */
+/** Placeholder shown to the browser instead of a real secret. */
 export declare const PASSWORD_MASK = "********";
 /**
- * Merge a config submitted from the browser with the stored one. If the
- * password field still holds the mask (i.e. the user did not change it),
- * preserve the previously stored password rather than overwriting it with the
- * placeholder. Pure — no I/O. Exported for unit testing.
+ * Merge a config submitted from the browser with the stored one. Any secret
+ * field (DB password, embedding/reranker API keys) still holding the mask means
+ * the user did not change it — restore the stored value rather than overwrite it
+ * with the placeholder. `env:` references are not masked and round-trip as-is.
+ * Pure — no I/O. Exported for unit testing.
  */
 export declare function mergeConfigForSave(incoming: JsonConfig, existing: JsonConfig | null): JsonConfig;
 /**
- * Return a copy of the config with the DB password replaced by the mask, so the
- * real secret never reaches the browser. The masked value round-trips through
- * `mergeConfigForSave` on save. Pure — no I/O. Exported for unit testing.
+ * Return a copy of the config with raw secrets (DB password, raw API keys)
+ * replaced by the mask, so real secrets never reach the browser. `env:`
+ * references are left verbatim — they are not secret and the dashboard shows
+ * them as "set via <VAR>". The masked value round-trips through
+ * `mergeConfigForSave`. Pure — no I/O. Exported for unit testing.
  */
 export declare function maskConfig(cfg: JsonConfig): JsonConfig;
 /**
@@ -38,7 +62,13 @@ export declare class WebServer {
     private readonly logger;
     private readonly embedder;
     private server?;
-    constructor(searcher: ISearcher, config: Config, logger: ILogger, embedder: IEmbedder);
+    private readonly composePath;
+    private readonly provisioningDeps;
+    private readonly readSavedConfig;
+    private backendStatus;
+    private taskInFlight;
+    private pending;
+    constructor(searcher: ISearcher, config: Config, logger: ILogger, embedder: IEmbedder, deps?: WebServerDeps);
     start(port: number, host: string): Promise<void>;
     stop(): Promise<void>;
     /** The bound address once started (e.g. `.port` after listen(0)); null otherwise. */
@@ -49,9 +79,22 @@ export declare class WebServer {
     private maskedConfig;
     private saveConfig;
     /**
-     * Choice lists for model fields. The embedding model is strict (only
-     * dimension-compatible models); the translate/reranker models are suggested
-     * from the user's installed Ollama models but stay free-text.
+     * After a successful config write, decide the Infinity backend action per
+     * the first-match decision table (`local-backend-provisioning`). Computes
+     * the required set from the SAVED config (a fresh `Config` re-read from the
+     * file just written — never the server's startup config/embedder). Never
+     * throws — an unexpected error becomes `{ action: 'failed', message }`; the
+     * saved config and `GET /api/backend-status` are unaffected either way.
+     */
+    private evaluateBackendAfterSave;
+    /** Kick off (or continue, via a follow-up) a background Infinity recreate. */
+    private startBackgroundTask;
+    /**
+     * Choice lists for model fields. Both are non-strict comboboxes (free text
+     * allowed): the embedding model suggests the known registry models plus any
+     * locally-installed models; the reranker model suggests installed models.
+     * Backends beyond the registry (e.g. arbitrary HuggingFace models on Infinity)
+     * still work — their dimension is probed at index time.
      */
     private fieldOptions;
     private installedModels;

package/dist/src/services/WebServerService.js

@@ -38,39 +38,62 @@ exports.mergeConfigForSave = mergeConfigForSave;
 exports.maskConfig = maskConfig;
 const http = __importStar(require("http"));
 const path = __importStar(require("path"));
+const config_1 = require("../config");
 const config_store_1 = require("../config-store");
 const constants_1 = require("../constants");
 const graph_1 = require("../graph");
 const dashboard_1 = require("../web/dashboard");
-/** Placeholder shown to the browser instead of the real DB password. */
+const infinity_provisioning_1 = require("./infinity-provisioning");
+function sameModelSet(a, b) {
+    return a.join(';') === b.join(';');
+}
+/** Placeholder shown to the browser instead of a real secret. */
 exports.PASSWORD_MASK = '********';
 const MAX_BODY = 1_000_000; // 1 MB — config payloads are tiny
+/** A secret worth masking: a non-empty string that is not an `env:` reference. */
+function isRawSecret(v) {
+    return typeof v === 'string' && v !== '' && !v.startsWith('env:');
+}
 /**
- * Merge a config submitted from the browser with the stored one. If the
- * password field still holds the mask (i.e. the user did not change it),
- * preserve the previously stored password rather than overwriting it with the
- * placeholder. Pure — no I/O. Exported for unit testing.
+ * Merge a config submitted from the browser with the stored one. Any secret
+ * field (DB password, embedding/reranker API keys) still holding the mask means
+ * the user did not change it — restore the stored value rather than overwrite it
+ * with the placeholder. `env:` references are not masked and round-trip as-is.
+ * Pure — no I/O. Exported for unit testing.
  */
 function mergeConfigForSave(incoming, existing) {
     const merged = JSON.parse(JSON.stringify(incoming ?? {}));
-    if (merged.db && merged.db.password === exports.PASSWORD_MASK) {
-        const prev = existing?.db?.password;
-        if (prev !== undefined)
-            merged.db.password = prev;
-        else
-            delete merged.db.password;
-    }
+    const restore = (grp, field) => {
+        const g = merged[grp];
+        if (g && g[field] === exports.PASSWORD_MASK) {
+            const prev = existing?.[grp]?.[field];
+            if (prev !== undefined)
+                g[field] = prev;
+            else
+                delete g[field];
+        }
+    };
+    restore('db', 'password');
+    restore('embedding', 'apiKey');
+    restore('reranker', 'apiKey');
     return merged;
 }
 /**
- * Return a copy of the config with the DB password replaced by the mask, so the
- * real secret never reaches the browser. The masked value round-trips through
- * `mergeConfigForSave` on save. Pure — no I/O. Exported for unit testing.
+ * Return a copy of the config with raw secrets (DB password, raw API keys)
+ * replaced by the mask, so real secrets never reach the browser. `env:`
+ * references are left verbatim — they are not secret and the dashboard shows
+ * them as "set via <VAR>". The masked value round-trips through
+ * `mergeConfigForSave`. Pure — no I/O. Exported for unit testing.
  */
 function maskConfig(cfg) {
-    if (!cfg.db?.password)
-        return cfg;
-    return { ...cfg, db: { ...cfg.db, password: exports.PASSWORD_MASK } };
+    const clone = JSON.parse(JSON.stringify(cfg ?? {}));
+    if (clone.db?.password)
+        clone.db.password = exports.PASSWORD_MASK;
+    if (isRawSecret(clone.embedding?.apiKey))
+        clone.embedding.apiKey = exports.PASSWORD_MASK;
+    if (isRawSecret(clone.reranker?.apiKey))
+        clone.reranker.apiKey = exports.PASSWORD_MASK;
+    return clone;
 }
 /**
  * Local HTTP dashboard. Serves a schema-driven config editor, a project
@@ -82,11 +105,22 @@ class WebServer {
     logger;
     embedder;
     server;
-    constructor(searcher, config, logger, embedder) {
+    composePath;
+    provisioningDeps;
+    readSavedConfig;
+    // Background Infinity-recreate task state (D6). In-memory, per-process — see
+    // `GET /api/backend-status`. `pending` holds at most one queued follow-up.
+    backendStatus = { state: 'idle', message: null, startedAt: null, finishedAt: null };
+    taskInFlight = false;
+    pending = null;
+    constructor(searcher, config, logger, embedder, deps = {}) {
         this.searcher = searcher;
         this.config = config;
         this.logger = logger;
         this.embedder = embedder;
+        this.composePath = deps.composePath ?? path.join(config_store_1.CONFIG_DIR, 'docker-compose.yml');
+        this.provisioningDeps = deps.provisioning ?? {};
+        this.readSavedConfig = deps.readSavedConfig ?? (() => new config_1.Config());
     }
     async start(port, host) {
         this.server = http.createServer((req, res) => {
@@ -131,6 +165,8 @@ class WebServer {
             return this.json(res, 200, this.maskedConfig());
         if (m === 'PUT' && p === '/api/config')
             return this.saveConfig(req, res);
+        if (m === 'GET' && p === '/api/backend-status')
+            return this.json(res, 200, this.backendStatus);
         if (m === 'GET' && p === '/api/projects')
             return this.json(res, 200, await this.searcher.listProjects());
         if (m === 'GET' && p === '/api/graph')
@@ -168,18 +204,90 @@ class WebServer {
         }
         (0, config_store_1.writeConfigJson)(validated);
         this.logger.info('WebServer: config updated');
-        this.json(res, 200, { ok: true });
+        const backend = await this.evaluateBackendAfterSave(validated);
+        this.json(res, 200, { ok: true, backend });
+    }
+    /**
+     * After a successful config write, decide the Infinity backend action per
+     * the first-match decision table (`local-backend-provisioning`). Computes
+     * the required set from the SAVED config (a fresh `Config` re-read from the
+     * file just written — never the server's startup config/embedder). Never
+     * throws — an unexpected error becomes `{ action: 'failed', message }`; the
+     * saved config and `GET /api/backend-status` are unaffected either way.
+     */
+    async evaluateBackendAfterSave(saved) {
+        const provider = saved.embedding?.provider ?? config_store_1.CONFIG_DEFAULTS['embedding.provider'];
+        if (provider !== 'infinity') {
+            this.pending = null;
+            return { action: 'not-needed', message: null };
+        }
+        try {
+            const freshConfig = this.readSavedConfig();
+            const baseURL = freshConfig.embedding.baseURL;
+            const composePath = this.composePath;
+            const modelSet = (0, infinity_provisioning_1.requiredModelSet)(freshConfig);
+            const managed = (0, infinity_provisioning_1.isManagedInfinity)(baseURL, composePath);
+            if (this.taskInFlight) {
+                if (managed) {
+                    this.pending = { modelSet, baseURL, composePath };
+                    return { action: 'already-running', message: 'A backend recreate is already in progress; this configuration will be applied next.' };
+                }
+                // No longer targets the managed container the in-flight task owns.
+                this.pending = null;
+            }
+            const evaluation = await (0, infinity_provisioning_1.evaluateBackend)(baseURL, composePath, modelSet, this.provisioningDeps);
+            switch (evaluation.action) {
+                case 'served':
+                    return { action: 'not-needed', message: null };
+                case 'missing-external':
+                case 'unreachable-external':
+                    return { action: 'manual-required', message: (0, infinity_provisioning_1.manualInstructionMessage)(evaluation, (0, infinity_provisioning_1.serverRoot)(baseURL), modelSet) };
+                case 'missing-managed':
+                case 'unreachable-managed':
+                    this.startBackgroundTask(baseURL, composePath, modelSet);
+                    return { action: 'started', message: 'Recreating the managed Infinity container in the background.' };
+            }
+        }
+        catch (err) {
+            return { action: 'failed', message: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    /** Kick off (or continue, via a follow-up) a background Infinity recreate. */
+    startBackgroundTask(baseURL, composePath, modelSet) {
+        this.taskInFlight = true;
+        this.backendStatus = { state: 'recreating', message: null, startedAt: new Date().toISOString(), finishedAt: null };
+        (0, infinity_provisioning_1.ensureModelSetServed)(baseURL, composePath, modelSet, this.provisioningDeps)
+            .then(() => {
+            this.backendStatus = { ...this.backendStatus, state: 'ready', message: null, finishedAt: new Date().toISOString() };
+        })
+            .catch((err) => {
+            this.backendStatus = {
+                ...this.backendStatus, state: 'failed',
+                message: err instanceof Error ? err.message : String(err),
+                finishedAt: new Date().toISOString(),
+            };
+        })
+            .finally(() => {
+            this.taskInFlight = false;
+            const next = this.pending;
+            this.pending = null;
+            if (next && !sameModelSet(next.modelSet, modelSet)) {
+                this.startBackgroundTask(next.baseURL, next.composePath, next.modelSet);
+            }
+        });
     }
     /**
-     * Choice lists for model fields. The embedding model is strict (only
-     * dimension-compatible models); the translate/reranker models are suggested
-     * from the user's installed Ollama models but stay free-text.
+     * Choice lists for model fields. Both are non-strict comboboxes (free text
+     * allowed): the embedding model suggests the known registry models plus any
+     * locally-installed models; the reranker model suggests installed models.
+     * Backends beyond the registry (e.g. arbitrary HuggingFace models on Infinity)
+     * still work — their dimension is probed at index time.
      */
     async fieldOptions() {
         const installed = await this.installedModels();
+        const registryModels = Object.keys(constants_1.MODEL_REGISTRY);
         return {
-            'ollama.model': { values: [...constants_1.SUPPORTED_EMBED_MODELS], strict: true },
-            'search.translateModel': { values: installed, strict: false },
+            'embedding.model': { values: [...new Set([...registryModels, ...installed])], strict: false },
             'reranker.model': { values: installed, strict: false },
         };
     }
@@ -188,7 +296,7 @@ class WebServer {
             return (await this.embedder.listModels?.()) ?? [];
         }
         catch (err) {
-            this.logger.warn('WebServer: could not list Ollama models', { reason: err instanceof Error ? err.message : String(err) });
+            this.logger.warn('WebServer: could not list models', { reason: err instanceof Error ? err.message : String(err) });
             return [];
         }
     }